SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/fuse/dir.c

   1 /*
   2   FUSE: Filesystem in Userspace
   3   Copyright (C) 2001-2006  Miklos Szeredi <miklos@szeredi.hu>
   4
   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
  17 #if BITS_PER_LONG >= 64
  18 static inline void fuse_dentry_settime(struct dentry *entry, u64 time)
  19 {
  20         entry->d_time = time;
  21 }
  22
  23 static 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  */
  31 static 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
  37 static 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
  44 /*
  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  */
  53 static u64 time_to_jiffies(unsigned long sec, unsigned long nsec)
  54 {
  55         if (sec || nsec) {
  56                 struct timespec ts = {sec, nsec};
  57                 return get_jiffies_64() + timespec_to_jiffies(&ts);
  58         } else
  59                 return 0;
  60 }
  61
  62 /*
  63  * Set dentry and possibly attribute timeouts from the lookup/mk*
  64  * replies
  65  */
  66 static void fuse_change_entry_timeout(struct dentry *entry,
  67                                       struct fuse_entry_out *o)
  68 {
  69         fuse_dentry_settime(entry,
  70                 time_to_jiffies(o->entry_valid, o->entry_valid_nsec));
  71 }
  72
  73 static u64 attr_timeout(struct fuse_attr_out *o)
  74 {
  75         return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
  76 }
  77
  78 static u64 entry_attr_timeout(struct fuse_entry_out *o)
  79 {
  80         return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
  81 }
  82
  83 /*
  84  * Mark the attributes as stale, so that at the next call to
  85  * ->getattr() they will be fetched from userspace
  86  */
  87 void fuse_invalidate_attr(struct inode *inode)
  88 {
  89         get_fuse_inode(inode)->i_time = 0;
  90 }
  91
  92 /*
  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  */
 100 static void fuse_invalidate_entry_cache(struct dentry *entry)
 101 {
 102         fuse_dentry_settime(entry, 0);
 103 }
 104
 105 /*
 106  * Same as fuse_invalidate_entry_cache(), but also try to remove the
 107  * dentry from the hash
 108  */
 109 static void fuse_invalidate_entry(struct dentry *entry)
 110 {
 111         d_invalidate(entry);
 112         fuse_invalidate_entry_cache(entry);
 113 }
 114
 115 static void fuse_lookup_init(struct fuse_req *req, struct inode *dir,
 116                              struct dentry *entry,
 117                              struct fuse_entry_out *outarg)
 118 {
 119         req->in.h.opcode = FUSE_LOOKUP;
 120         req->in.h.nodeid = get_node_id(dir);
 121         req->in.numargs = 1;
 122         req->in.args[0].size = entry->d_name.len + 1;
 123         req->in.args[0].value = entry->d_name.name;
 124         req->out.numargs = 1;
 125         req->out.args[0].size = sizeof(struct fuse_entry_out);
 126         req->out.args[0].value = outarg;
 127 }
 128
 129 /*
 130  * Check whether the dentry is still valid
 131  *
 132  * If the entry validity timeout has expired and the dentry is
 133  * positive, try to redo the lookup.  If the lookup results in a
 134  * different inode, then let the VFS invalidate the dentry and redo
 135  * the lookup once more.  If the lookup results in the same inode,
 136  * then refresh the attributes, timeouts and mark the dentry valid.
 137  */
 138 static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
 139 {
 140         struct inode *inode = entry->d_inode;
 141
 142         if (inode && is_bad_inode(inode))
 143                 return 0;
 144         else if (fuse_dentry_time(entry) < get_jiffies_64()) {
 145                 int err;
 146                 struct fuse_entry_out outarg;
 147                 struct fuse_conn *fc;
 148                 struct fuse_req *req;
 149                 struct fuse_req *forget_req;
 150                 struct dentry *parent;
 151                 u64 attr_version;
 152
 153                 /* For negative dentries, always do a fresh lookup */
 154                 if (!inode)
 155                         return 0;
 156
 157                 fc = get_fuse_conn(inode);
 158                 req = fuse_get_req(fc);
 159                 if (IS_ERR(req))
 160                         return 0;
 161
 162                 forget_req = fuse_get_req(fc);
 163                 if (IS_ERR(forget_req)) {
 164                         fuse_put_request(fc, req);
 165                         return 0;
 166                 }
 167
 168                 spin_lock(&fc->lock);
 169                 attr_version = fc->attr_version;
 170                 spin_unlock(&fc->lock);
 171
 172                 parent = dget_parent(entry);
 173                 fuse_lookup_init(req, parent->d_inode, entry, &outarg);
 174                 request_send(fc, req);
 175                 dput(parent);
 176                 err = req->out.h.error;
 177                 fuse_put_request(fc, req);
 178                 /* Zero nodeid is same as -ENOENT */
 179                 if (!err && !outarg.nodeid)
 180                         err = -ENOENT;
 181                 if (!err) {
 182                         struct fuse_inode *fi = get_fuse_inode(inode);
 183                         if (outarg.nodeid != get_node_id(inode)) {
 184                                 fuse_send_forget(fc, forget_req,
 185                                                  outarg.nodeid, 1);
 186                                 return 0;
 187                         }
 188                         spin_lock(&fc->lock);
 189                         fi->nlookup ++;
 190                         spin_unlock(&fc->lock);
 191                 }
 192                 fuse_put_request(fc, forget_req);
 193                 if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
 194                         return 0;
 195
 196                 fuse_change_attributes(inode, &outarg.attr,
 197                                        entry_attr_timeout(&outarg),
 198                                        attr_version);
 199                 fuse_change_entry_timeout(entry, &outarg);
 200         }
 201         return 1;
 202 }
 203
 204 static int invalid_nodeid(u64 nodeid)
 205 {
 206         return !nodeid || nodeid == FUSE_ROOT_ID;
 207 }
 208
 209 static struct dentry_operations fuse_dentry_operations = {
 210         .d_revalidate   = fuse_dentry_revalidate,
 211 };
 212
 213 int fuse_valid_type(int m)
 214 {
 215         return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
 216                 S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
 217 }
 218
 219 /*
 220  * Add a directory inode to a dentry, ensuring that no other dentry
 221  * refers to this inode.  Called with fc->inst_mutex.
 222  */
 223 static int fuse_d_add_directory(struct dentry *entry, struct inode *inode)
 224 {
 225         struct dentry *alias = d_find_alias(inode);
 226         if (alias) {
 227                 /* This tries to shrink the subtree below alias */
 228                 fuse_invalidate_entry(alias);
 229                 dput(alias);
 230                 if (!list_empty(&inode->i_dentry))
 231                         return -EBUSY;
 232         }
 233         d_add(entry, inode);
 234         return 0;
 235 }
 236
 237 static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
 238                                   struct nameidata *nd)
 239 {
 240         int err;
 241         struct fuse_entry_out outarg;
 242         struct inode *inode = NULL;
 243         struct fuse_conn *fc = get_fuse_conn(dir);
 244         struct fuse_req *req;
 245         struct fuse_req *forget_req;
 246         u64 attr_version;
 247
 248         if (entry->d_name.len > FUSE_NAME_MAX)
 249                 return ERR_PTR(-ENAMETOOLONG);
 250
 251         req = fuse_get_req(fc);
 252         if (IS_ERR(req))
 253                 return ERR_PTR(PTR_ERR(req));
 254
 255         forget_req = fuse_get_req(fc);
 256         if (IS_ERR(forget_req)) {
 257                 fuse_put_request(fc, req);
 258                 return ERR_PTR(PTR_ERR(forget_req));
 259         }
 260
 261         spin_lock(&fc->lock);
 262         attr_version = fc->attr_version;
 263         spin_unlock(&fc->lock);
 264
 265         fuse_lookup_init(req, dir, entry, &outarg);
 266         request_send(fc, req);
 267         err = req->out.h.error;
 268         fuse_put_request(fc, req);
 269         /* Zero nodeid is same as -ENOENT, but with valid timeout */
 270         if (!err && outarg.nodeid &&
 271             (invalid_nodeid(outarg.nodeid) ||
 272              !fuse_valid_type(outarg.attr.mode)))
 273                 err = -EIO;
 274         if (!err && outarg.nodeid) {
 275                 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
 276                                   &outarg.attr, entry_attr_timeout(&outarg),
 277                                   attr_version);
 278                 if (!inode) {
 279                         fuse_send_forget(fc, forget_req, outarg.nodeid, 1);
 280                         return ERR_PTR(-ENOMEM);
 281                 }
 282         }
 283         fuse_put_request(fc, forget_req);
 284         if (err && err != -ENOENT)
 285                 return ERR_PTR(err);
 286
 287         if (inode && S_ISDIR(inode->i_mode)) {
 288                 mutex_lock(&fc->inst_mutex);
 289                 err = fuse_d_add_directory(entry, inode);
 290                 mutex_unlock(&fc->inst_mutex);
 291                 if (err) {
 292                         iput(inode);
 293                         return ERR_PTR(err);
 294                 }
 295         } else
 296                 d_add(entry, inode);
 297
 298         entry->d_op = &fuse_dentry_operations;
 299         if (!err)
 300                 fuse_change_entry_timeout(entry, &outarg);
 301         else
 302                 fuse_invalidate_entry_cache(entry);
 303         return NULL;
 304 }
 305
 306 /*
 307  * Synchronous release for the case when something goes wrong in CREATE_OPEN
 308  */
 309 static void fuse_sync_release(struct fuse_conn *fc, struct fuse_file *ff,
 310                               u64 nodeid, int flags)
 311 {
 312         fuse_release_fill(ff, nodeid, flags, FUSE_RELEASE);
 313         ff->reserved_req->force = 1;
 314         request_send(fc, ff->reserved_req);
 315         fuse_put_request(fc, ff->reserved_req);
 316         kfree(ff);
 317 }
 318
 319 /*
 320  * Atomic create+open operation
 321  *
 322  * If the filesystem doesn't support this, then fall back to separate
 323  * 'mknod' + 'open' requests.
 324  */
 325 static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
 326                             struct nameidata *nd)
 327 {
 328         int err;
 329         struct inode *inode;
 330         struct fuse_conn *fc = get_fuse_conn(dir);
 331         struct fuse_req *req;
 332         struct fuse_req *forget_req;
 333         struct fuse_open_in inarg;
 334         struct fuse_open_out outopen;
 335         struct fuse_entry_out outentry;
 336         struct fuse_file *ff;
 337         struct file *file;
 338         int flags = nd->intent.open.flags - 1;
 339
 340         if (fc->no_create)
 341                 return -ENOSYS;
 342
 343         forget_req = fuse_get_req(fc);
 344         if (IS_ERR(forget_req))
 345                 return PTR_ERR(forget_req);
 346
 347         req = fuse_get_req(fc);
 348         err = PTR_ERR(req);
 349         if (IS_ERR(req))
 350                 goto out_put_forget_req;
 351
 352         err = -ENOMEM;
 353         ff = fuse_file_alloc();
 354         if (!ff)
 355                 goto out_put_request;
 356
 357         flags &= ~O_NOCTTY;
 358         memset(&inarg, 0, sizeof(inarg));
 359         inarg.flags = flags;
 360         inarg.mode = mode;
 361         req->in.h.opcode = FUSE_CREATE;
 362         req->in.h.nodeid = get_node_id(dir);
 363         req->in.numargs = 2;
 364         req->in.args[0].size = sizeof(inarg);
 365         req->in.args[0].value = &inarg;
 366         req->in.args[1].size = entry->d_name.len + 1;
 367         req->in.args[1].value = entry->d_name.name;
 368         req->out.numargs = 2;
 369         req->out.args[0].size = sizeof(outentry);
 370         req->out.args[0].value = &outentry;
 371         req->out.args[1].size = sizeof(outopen);
 372         req->out.args[1].value = &outopen;
 373         request_send(fc, req);
 374         err = req->out.h.error;
 375         if (err) {
 376                 if (err == -ENOSYS)
 377                         fc->no_create = 1;
 378                 goto out_free_ff;
 379         }
 380
 381         err = -EIO;
 382         if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
 383                 goto out_free_ff;
 384
 385         fuse_put_request(fc, req);
 386         inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
 387                           &outentry.attr, entry_attr_timeout(&outentry), 0);
 388         if (!inode) {
 389                 flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
 390                 ff->fh = outopen.fh;
 391                 fuse_sync_release(fc, ff, outentry.nodeid, flags);
 392                 fuse_send_forget(fc, forget_req, outentry.nodeid, 1);
 393                 return -ENOMEM;
 394         }
 395         fuse_put_request(fc, forget_req);
 396         d_instantiate(entry, inode);
 397         fuse_change_entry_timeout(entry, &outentry);
 398         file = lookup_instantiate_filp(nd, entry, generic_file_open);
 399         if (IS_ERR(file)) {
 400                 ff->fh = outopen.fh;
 401                 fuse_sync_release(fc, ff, outentry.nodeid, flags);
 402                 return PTR_ERR(file);
 403         }
 404         fuse_finish_open(inode, file, ff, &outopen);
 405         return 0;
 406
 407  out_free_ff:
 408         fuse_file_free(ff);
 409  out_put_request:
 410         fuse_put_request(fc, req);
 411  out_put_forget_req:
 412         fuse_put_request(fc, forget_req);
 413         return err;
 414 }
 415
 416 /*
 417  * Code shared between mknod, mkdir, symlink and link
 418  */
 419 static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
 420                             struct inode *dir, struct dentry *entry,
 421                             int mode)
 422 {
 423         struct fuse_entry_out outarg;
 424         struct inode *inode;
 425         int err;
 426         struct fuse_req *forget_req;
 427
 428         forget_req = fuse_get_req(fc);
 429         if (IS_ERR(forget_req)) {
 430                 fuse_put_request(fc, req);
 431                 return PTR_ERR(forget_req);
 432         }
 433
 434         req->in.h.nodeid = get_node_id(dir);
 435         req->out.numargs = 1;
 436         req->out.args[0].size = sizeof(outarg);
 437         req->out.args[0].value = &outarg;
 438         request_send(fc, req);
 439         err = req->out.h.error;
 440         fuse_put_request(fc, req);
 441         if (err)
 442                 goto out_put_forget_req;
 443
 444         err = -EIO;
 445         if (invalid_nodeid(outarg.nodeid))
 446                 goto out_put_forget_req;
 447
 448         if ((outarg.attr.mode ^ mode) & S_IFMT)
 449                 goto out_put_forget_req;
 450
 451         inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
 452                           &outarg.attr, entry_attr_timeout(&outarg), 0);
 453         if (!inode) {
 454                 fuse_send_forget(fc, forget_req, outarg.nodeid, 1);
 455                 return -ENOMEM;
 456         }
 457         fuse_put_request(fc, forget_req);
 458
 459         if (S_ISDIR(inode->i_mode)) {
 460                 struct dentry *alias;
 461                 mutex_lock(&fc->inst_mutex);
 462                 alias = d_find_alias(inode);
 463                 if (alias) {
 464                         /* New directory must have moved since mkdir */
 465                         mutex_unlock(&fc->inst_mutex);
 466                         dput(alias);
 467                         iput(inode);
 468                         return -EBUSY;
 469                 }
 470                 d_instantiate(entry, inode);
 471                 mutex_unlock(&fc->inst_mutex);
 472         } else
 473                 d_instantiate(entry, inode);
 474
 475         fuse_change_entry_timeout(entry, &outarg);
 476         fuse_invalidate_attr(dir);
 477         return 0;
 478
 479  out_put_forget_req:
 480         fuse_put_request(fc, forget_req);
 481         return err;
 482 }
 483
 484 static int fuse_mknod(struct inode *dir, struct dentry *entry, int mode,
 485                       dev_t rdev)
 486 {
 487         struct fuse_mknod_in inarg;
 488         struct fuse_conn *fc = get_fuse_conn(dir);
 489         struct fuse_req *req = fuse_get_req(fc);
 490         if (IS_ERR(req))
 491                 return PTR_ERR(req);
 492
 493         memset(&inarg, 0, sizeof(inarg));
 494         inarg.mode = mode;
 495         inarg.rdev = new_encode_dev(rdev);
 496         req->in.h.opcode = FUSE_MKNOD;
 497         req->in.numargs = 2;
 498         req->in.args[0].size = sizeof(inarg);
 499         req->in.args[0].value = &inarg;
 500         req->in.args[1].size = entry->d_name.len + 1;
 501         req->in.args[1].value = entry->d_name.name;
 502         return create_new_entry(fc, req, dir, entry, mode);
 503 }
 504
 505 static int fuse_create(struct inode *dir, struct dentry *entry, int mode,
 506                        struct nameidata *nd)
 507 {
 508         if (nd && (nd->flags & LOOKUP_OPEN)) {
 509                 int err = fuse_create_open(dir, entry, mode, nd);
 510                 if (err != -ENOSYS)
 511                         return err;
 512                 /* Fall back on mknod */
 513         }
 514         return fuse_mknod(dir, entry, mode, 0);
 515 }
 516
 517 static int fuse_mkdir(struct inode *dir, struct dentry *entry, int mode)
 518 {
 519         struct fuse_mkdir_in inarg;
 520         struct fuse_conn *fc = get_fuse_conn(dir);
 521         struct fuse_req *req = fuse_get_req(fc);
 522         if (IS_ERR(req))
 523                 return PTR_ERR(req);
 524
 525         memset(&inarg, 0, sizeof(inarg));
 526         inarg.mode = mode;
 527         req->in.h.opcode = FUSE_MKDIR;
 528         req->in.numargs = 2;
 529         req->in.args[0].size = sizeof(inarg);
 530         req->in.args[0].value = &inarg;
 531         req->in.args[1].size = entry->d_name.len + 1;
 532         req->in.args[1].value = entry->d_name.name;
 533         return create_new_entry(fc, req, dir, entry, S_IFDIR);
 534 }
 535
 536 static int fuse_symlink(struct inode *dir, struct dentry *entry,
 537                         const char *link)
 538 {
 539         struct fuse_conn *fc = get_fuse_conn(dir);
 540         unsigned len = strlen(link) + 1;
 541         struct fuse_req *req = fuse_get_req(fc);
 542         if (IS_ERR(req))
 543                 return PTR_ERR(req);
 544
 545         req->in.h.opcode = FUSE_SYMLINK;
 546         req->in.numargs = 2;
 547         req->in.args[0].size = entry->d_name.len + 1;
 548         req->in.args[0].value = entry->d_name.name;
 549         req->in.args[1].size = len;
 550         req->in.args[1].value = link;
 551         return create_new_entry(fc, req, dir, entry, S_IFLNK);
 552 }
 553
 554 static int fuse_unlink(struct inode *dir, struct dentry *entry)
 555 {
 556         int err;
 557         struct fuse_conn *fc = get_fuse_conn(dir);
 558         struct fuse_req *req = fuse_get_req(fc);
 559         if (IS_ERR(req))
 560                 return PTR_ERR(req);
 561
 562         req->in.h.opcode = FUSE_UNLINK;
 563         req->in.h.nodeid = get_node_id(dir);
 564         req->in.numargs = 1;
 565         req->in.args[0].size = entry->d_name.len + 1;
 566         req->in.args[0].value = entry->d_name.name;
 567         request_send(fc, req);
 568         err = req->out.h.error;
 569         fuse_put_request(fc, req);
 570         if (!err) {
 571                 struct inode *inode = entry->d_inode;
 572
 573                 /* Set nlink to zero so the inode can be cleared, if
 574                    the inode does have more links this will be
 575                    discovered at the next lookup/getattr */
 576                 clear_nlink(inode);
 577                 fuse_invalidate_attr(inode);
 578                 fuse_invalidate_attr(dir);
 579                 fuse_invalidate_entry_cache(entry);
 580         } else if (err == -EINTR)
 581                 fuse_invalidate_entry(entry);
 582         return err;
 583 }
 584
 585 static int fuse_rmdir(struct inode *dir, struct dentry *entry)
 586 {
 587         int err;
 588         struct fuse_conn *fc = get_fuse_conn(dir);
 589         struct fuse_req *req = fuse_get_req(fc);
 590         if (IS_ERR(req))
 591                 return PTR_ERR(req);
 592
 593         req->in.h.opcode = FUSE_RMDIR;
 594         req->in.h.nodeid = get_node_id(dir);
 595         req->in.numargs = 1;
 596         req->in.args[0].size = entry->d_name.len + 1;
 597         req->in.args[0].value = entry->d_name.name;
 598         request_send(fc, req);
 599         err = req->out.h.error;
 600         fuse_put_request(fc, req);
 601         if (!err) {
 602                 clear_nlink(entry->d_inode);
 603                 fuse_invalidate_attr(dir);
 604                 fuse_invalidate_entry_cache(entry);
 605         } else if (err == -EINTR)
 606                 fuse_invalidate_entry(entry);
 607         return err;
 608 }
 609
 610 static int fuse_rename(struct inode *olddir, struct dentry *oldent,
 611                        struct inode *newdir, struct dentry *newent)
 612 {
 613         int err;
 614         struct fuse_rename_in inarg;
 615         struct fuse_conn *fc = get_fuse_conn(olddir);
 616         struct fuse_req *req = fuse_get_req(fc);
 617         if (IS_ERR(req))
 618                 return PTR_ERR(req);
 619
 620         memset(&inarg, 0, sizeof(inarg));
 621         inarg.newdir = get_node_id(newdir);
 622         req->in.h.opcode = FUSE_RENAME;
 623         req->in.h.nodeid = get_node_id(olddir);
 624         req->in.numargs = 3;
 625         req->in.args[0].size = sizeof(inarg);
 626         req->in.args[0].value = &inarg;
 627         req->in.args[1].size = oldent->d_name.len + 1;
 628         req->in.args[1].value = oldent->d_name.name;
 629         req->in.args[2].size = newent->d_name.len + 1;
 630         req->in.args[2].value = newent->d_name.name;
 631         request_send(fc, req);
 632         err = req->out.h.error;
 633         fuse_put_request(fc, req);
 634         if (!err) {
 635                 fuse_invalidate_attr(olddir);
 636                 if (olddir != newdir)
 637                         fuse_invalidate_attr(newdir);
 638
 639                 /* newent will end up negative */
 640                 if (newent->d_inode)
 641                         fuse_invalidate_entry_cache(newent);
 642         } else if (err == -EINTR) {
 643                 /* If request was interrupted, DEITY only knows if the
 644                    rename actually took place.  If the invalidation
 645                    fails (e.g. some process has CWD under the renamed
 646                    directory), then there can be inconsistency between
 647                    the dcache and the real filesystem.  Tough luck. */
 648                 fuse_invalidate_entry(oldent);
 649                 if (newent->d_inode)
 650                         fuse_invalidate_entry(newent);
 651         }
 652
 653         return err;
 654 }
 655
 656 static int fuse_link(struct dentry *entry, struct inode *newdir,
 657                      struct dentry *newent)
 658 {
 659         int err;
 660         struct fuse_link_in inarg;
 661         struct inode *inode = entry->d_inode;
 662         struct fuse_conn *fc = get_fuse_conn(inode);
 663         struct fuse_req *req = fuse_get_req(fc);
 664         if (IS_ERR(req))
 665                 return PTR_ERR(req);
 666
 667         memset(&inarg, 0, sizeof(inarg));
 668         inarg.oldnodeid = get_node_id(inode);
 669         req->in.h.opcode = FUSE_LINK;
 670         req->in.numargs = 2;
 671         req->in.args[0].size = sizeof(inarg);
 672         req->in.args[0].value = &inarg;
 673         req->in.args[1].size = newent->d_name.len + 1;
 674         req->in.args[1].value = newent->d_name.name;
 675         err = create_new_entry(fc, req, newdir, newent, inode->i_mode);
 676         /* Contrary to "normal" filesystems it can happen that link
 677            makes two "logical" inodes point to the same "physical"
 678            inode.  We invalidate the attributes of the old one, so it
 679            will reflect changes in the backing inode (link count,
 680            etc.)
 681         */
 682         if (!err || err == -EINTR)
 683                 fuse_invalidate_attr(inode);
 684         return err;
 685 }
 686
 687 static void fuse_fillattr(struct inode *inode, struct fuse_attr *attr,
 688                           struct kstat *stat)
 689 {
 690         stat->dev = inode->i_sb->s_dev;
 691         stat->ino = attr->ino;
 692         stat->mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
 693         stat->nlink = attr->nlink;
 694         stat->uid = attr->uid;
 695         stat->gid = attr->gid;
 696         stat->rdev = inode->i_rdev;
 697         stat->atime.tv_sec = attr->atime;
 698         stat->atime.tv_nsec = attr->atimensec;
 699         stat->mtime.tv_sec = attr->mtime;
 700         stat->mtime.tv_nsec = attr->mtimensec;
 701         stat->ctime.tv_sec = attr->ctime;
 702         stat->ctime.tv_nsec = attr->ctimensec;
 703         stat->size = attr->size;
 704         stat->blocks = attr->blocks;
 705         stat->blksize = (1 << inode->i_blkbits);
 706 }
 707
 708 static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
 709                            struct file *file)
 710 {
 711         int err;
 712         struct fuse_getattr_in inarg;
 713         struct fuse_attr_out outarg;
 714         struct fuse_conn *fc = get_fuse_conn(inode);
 715         struct fuse_req *req;
 716         u64 attr_version;
 717
 718         req = fuse_get_req(fc);
 719         if (IS_ERR(req))
 720                 return PTR_ERR(req);
 721
 722         spin_lock(&fc->lock);
 723         attr_version = fc->attr_version;
 724         spin_unlock(&fc->lock);
 725
 726         memset(&inarg, 0, sizeof(inarg));
 727         /* Directories have separate file-handle space */
 728         if (file && S_ISREG(inode->i_mode)) {
 729                 struct fuse_file *ff = file->private_data;
 730
 731                 inarg.getattr_flags |= FUSE_GETATTR_FH;
 732                 inarg.fh = ff->fh;
 733         }
 734         req->in.h.opcode = FUSE_GETATTR;
 735         req->in.h.nodeid = get_node_id(inode);
 736         req->in.numargs = 1;
 737         req->in.args[0].size = sizeof(inarg);
 738         req->in.args[0].value = &inarg;
 739         req->out.numargs = 1;
 740         req->out.args[0].size = sizeof(outarg);
 741         req->out.args[0].value = &outarg;
 742         request_send(fc, req);
 743         err = req->out.h.error;
 744         fuse_put_request(fc, req);
 745         if (!err) {
 746                 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
 747                         make_bad_inode(inode);
 748                         err = -EIO;
 749                 } else {
 750                         fuse_change_attributes(inode, &outarg.attr,
 751                                                attr_timeout(&outarg),
 752                                                attr_version);
 753                         if (stat)
 754                                 fuse_fillattr(inode, &outarg.attr, stat);
 755                 }
 756         }
 757         return err;
 758 }
 759
 760 /*
 761  * Calling into a user-controlled filesystem gives the filesystem
 762  * daemon ptrace-like capabilities over the requester process.  This
 763  * means, that the filesystem daemon is able to record the exact
 764  * filesystem operations performed, and can also control the behavior
 765  * of the requester process in otherwise impossible ways.  For example
 766  * it can delay the operation for arbitrary length of time allowing
 767  * DoS against the requester.
 768  *
 769  * For this reason only those processes can call into the filesystem,
 770  * for which the owner of the mount has ptrace privilege.  This
 771  * excludes processes started by other users, suid or sgid processes.
 772  */
 773 int fuse_allow_task(struct fuse_conn *fc, struct task_struct *task)
 774 {
 775         if (fc->flags & FUSE_ALLOW_OTHER)
 776                 return 1;
 777
 778         if (task->euid == fc->user_id &&
 779             task->suid == fc->user_id &&
 780             task->uid == fc->user_id &&
 781             task->egid == fc->group_id &&
 782             task->sgid == fc->group_id &&
 783             task->gid == fc->group_id)
 784                 return 1;
 785
 786         return 0;
 787 }
 788
 789 static int fuse_access(struct inode *inode, int mask)
 790 {
 791         struct fuse_conn *fc = get_fuse_conn(inode);
 792         struct fuse_req *req;
 793         struct fuse_access_in inarg;
 794         int err;
 795
 796         if (fc->no_access)
 797                 return 0;
 798
 799         req = fuse_get_req(fc);
 800         if (IS_ERR(req))
 801                 return PTR_ERR(req);
 802
 803         memset(&inarg, 0, sizeof(inarg));
 804         inarg.mask = mask;
 805         req->in.h.opcode = FUSE_ACCESS;
 806         req->in.h.nodeid = get_node_id(inode);
 807         req->in.numargs = 1;
 808         req->in.args[0].size = sizeof(inarg);
 809         req->in.args[0].value = &inarg;
 810         request_send(fc, req);
 811         err = req->out.h.error;
 812         fuse_put_request(fc, req);
 813         if (err == -ENOSYS) {
 814                 fc->no_access = 1;
 815                 err = 0;
 816         }
 817         return err;
 818 }
 819
 820 /*
 821  * Check permission.  The two basic access models of FUSE are:
 822  *
 823  * 1) Local access checking ('default_permissions' mount option) based
 824  * on file mode.  This is the plain old disk filesystem permission
 825  * modell.
 826  *
 827  * 2) "Remote" access checking, where server is responsible for
 828  * checking permission in each inode operation.  An exception to this
 829  * is if ->permission() was invoked from sys_access() in which case an
 830  * access request is sent.  Execute permission is still checked
 831  * locally based on file mode.
 832  */
 833 static int fuse_permission(struct inode *inode, int mask, struct nameidata *nd)
 834 {
 835         struct fuse_conn *fc = get_fuse_conn(inode);
 836         bool refreshed = false;
 837         int err = 0;
 838
 839         if (!fuse_allow_task(fc, current))
 840                 return -EACCES;
 841
 842         /*
 843          * If attributes are needed, refresh them before proceeding
 844          */
 845         if ((fc->flags & FUSE_DEFAULT_PERMISSIONS) ||
 846             ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
 847                 struct fuse_inode *fi = get_fuse_inode(inode);
 848                 if (fi->i_time < get_jiffies_64()) {
 849                         err = fuse_do_getattr(inode, NULL, NULL);
 850                         if (err)
 851                                 return err;
 852
 853                         refreshed = true;
 854                 }
 855         }
 856
 857         if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
 858                 int err = generic_permission(inode, mask, NULL);
 859
 860                 /* If permission is denied, try to refresh file
 861                    attributes.  This is also needed, because the root
 862                    node will at first have no permissions */
 863                 if (err == -EACCES && !refreshed) {
 864                         err = fuse_do_getattr(inode, NULL, NULL);
 865                         if (!err)
 866                                 err = generic_permission(inode, mask, NULL);
 867                 }
 868
 869                 /* Note: the opposite of the above test does not
 870                    exist.  So if permissions are revoked this won't be
 871                    noticed immediately, only after the attribute
 872                    timeout has expired */
 873         } else if (nd && (nd->flags & (LOOKUP_ACCESS | LOOKUP_CHDIR))) {
 874                 err = fuse_access(inode, mask);
 875         } else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
 876                 if (!(inode->i_mode & S_IXUGO)) {
 877                         if (refreshed)
 878                                 return -EACCES;
 879
 880                         err = fuse_do_getattr(inode, NULL, NULL);
 881                         if (!err && !(inode->i_mode & S_IXUGO))
 882                                 return -EACCES;
 883                 }
 884         }
 885         return err;
 886 }
 887
 888 static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
 889                          void *dstbuf, filldir_t filldir)
 890 {
 891         while (nbytes >= FUSE_NAME_OFFSET) {
 892                 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
 893                 size_t reclen = FUSE_DIRENT_SIZE(dirent);
 894                 int over;
 895                 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
 896                         return -EIO;
 897                 if (reclen > nbytes)
 898                         break;
 899
 900                 over = filldir(dstbuf, dirent->name, dirent->namelen,
 901                                file->f_pos, dirent->ino, dirent->type);
 902                 if (over)
 903                         break;
 904
 905                 buf += reclen;
 906                 nbytes -= reclen;
 907                 file->f_pos = dirent->off;
 908         }
 909
 910         return 0;
 911 }
 912
 913 static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
 914 {
 915         int err;
 916         size_t nbytes;
 917         struct page *page;
 918         struct inode *inode = file->f_path.dentry->d_inode;
 919         struct fuse_conn *fc = get_fuse_conn(inode);
 920         struct fuse_file *ff = file->private_data;
 921         struct fuse_req *req;
 922
 923         if (is_bad_inode(inode))
 924                 return -EIO;
 925
 926         req = fuse_get_req(fc);
 927         if (IS_ERR(req))
 928                 return PTR_ERR(req);
 929
 930         page = alloc_page(GFP_KERNEL);
 931         if (!page) {
 932                 fuse_put_request(fc, req);
 933                 return -ENOMEM;
 934         }
 935         req->num_pages = 1;
 936         req->pages[0] = page;
 937         fuse_read_fill(req, ff, inode, file->f_pos, PAGE_SIZE, FUSE_READDIR);
 938         request_send(fc, req);
 939         nbytes = req->out.args[0].size;
 940         err = req->out.h.error;
 941         fuse_put_request(fc, req);
 942         if (!err)
 943                 err = parse_dirfile(page_address(page), nbytes, file, dstbuf,
 944                                     filldir);
 945
 946         __free_page(page);
 947         fuse_invalidate_attr(inode); /* atime changed */
 948         return err;
 949 }
 950
 951 static char *read_link(struct dentry *dentry)
 952 {
 953         struct inode *inode = dentry->d_inode;
 954         struct fuse_conn *fc = get_fuse_conn(inode);
 955         struct fuse_req *req = fuse_get_req(fc);
 956         char *link;
 957
 958         if (IS_ERR(req))
 959                 return ERR_PTR(PTR_ERR(req));
 960
 961         link = (char *) __get_free_page(GFP_KERNEL);
 962         if (!link) {
 963                 link = ERR_PTR(-ENOMEM);
 964                 goto out;
 965         }
 966         req->in.h.opcode = FUSE_READLINK;
 967         req->in.h.nodeid = get_node_id(inode);
 968         req->out.argvar = 1;
 969         req->out.numargs = 1;
 970         req->out.args[0].size = PAGE_SIZE - 1;
 971         req->out.args[0].value = link;
 972         request_send(fc, req);
 973         if (req->out.h.error) {
 974                 free_page((unsigned long) link);
 975                 link = ERR_PTR(req->out.h.error);
 976         } else
 977                 link[req->out.args[0].size] = '\0';
 978  out:
 979         fuse_put_request(fc, req);
 980         fuse_invalidate_attr(inode); /* atime changed */
 981         return link;
 982 }
 983
 984 static void free_link(char *link)
 985 {
 986         if (!IS_ERR(link))
 987                 free_page((unsigned long) link);
 988 }
 989
 990 static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
 991 {
 992         nd_set_link(nd, read_link(dentry));
 993         return NULL;
 994 }
 995
 996 static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
 997 {
 998         free_link(nd_get_link(nd));
 999 }
1000
1001 static int fuse_dir_open(struct inode *inode, struct file *file)
1002 {
1003         return fuse_open_common(inode, file, 1);
1004 }
1005
1006 static int fuse_dir_release(struct inode *inode, struct file *file)
1007 {
1008         return fuse_release_common(inode, file, 1);
1009 }
1010
1011 static int fuse_dir_fsync(struct file *file, struct dentry *de, int datasync)
1012 {
1013         /* nfsd can call this with no file */
1014         return file ? fuse_fsync_common(file, de, datasync, 1) : 0;
1015 }
1016
1017 static bool update_mtime(unsigned ivalid)
1018 {
1019         /* Always update if mtime is explicitly set  */
1020         if (ivalid & ATTR_MTIME_SET)
1021                 return true;
1022
1023         /* If it's an open(O_TRUNC) or an ftruncate(), don't update */
1024         if ((ivalid & ATTR_SIZE) && (ivalid & (ATTR_OPEN | ATTR_FILE)))
1025                 return false;
1026
1027         /* In all other cases update */
1028         return true;
1029 }
1030
1031 static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg)
1032 {
1033         unsigned ivalid = iattr->ia_valid;
1034
1035         if (ivalid & ATTR_MODE)
1036                 arg->valid |= FATTR_MODE,   arg->mode = iattr->ia_mode;
1037         if (ivalid & ATTR_UID)
1038                 arg->valid |= FATTR_UID,    arg->uid = iattr->ia_uid;
1039         if (ivalid & ATTR_GID)
1040                 arg->valid |= FATTR_GID,    arg->gid = iattr->ia_gid;
1041         if (ivalid & ATTR_SIZE)
1042                 arg->valid |= FATTR_SIZE,   arg->size = iattr->ia_size;
1043         if (ivalid & ATTR_ATIME) {
1044                 arg->valid |= FATTR_ATIME;
1045                 arg->atime = iattr->ia_atime.tv_sec;
1046                 arg->atimensec = iattr->ia_atime.tv_nsec;
1047                 if (!(ivalid & ATTR_ATIME_SET))
1048                         arg->valid |= FATTR_ATIME_NOW;
1049         }
1050         if ((ivalid & ATTR_MTIME) && update_mtime(ivalid)) {
1051                 arg->valid |= FATTR_MTIME;
1052                 arg->mtime = iattr->ia_mtime.tv_sec;
1053                 arg->mtimensec = iattr->ia_mtime.tv_nsec;
1054                 if (!(ivalid & ATTR_MTIME_SET))
1055                         arg->valid |= FATTR_MTIME_NOW;
1056         }
1057 }
1058
1059 /*
1060  * Set attributes, and at the same time refresh them.
1061  *
1062  * Truncation is slightly complicated, because the 'truncate' request
1063  * may fail, in which case we don't want to touch the mapping.
1064  * vmtruncate() doesn't allow for this case, so do the rlimit checking
1065  * and the actual truncation by hand.
1066  */
1067 static int fuse_do_setattr(struct dentry *entry, struct iattr *attr,
1068                            struct file *file)
1069 {
1070         struct inode *inode = entry->d_inode;
1071         struct fuse_conn *fc = get_fuse_conn(inode);
1072         struct fuse_req *req;
1073         struct fuse_setattr_in inarg;
1074         struct fuse_attr_out outarg;
1075         int err;
1076
1077         if (!fuse_allow_task(fc, current))
1078                 return -EACCES;
1079
1080         if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
1081                 err = inode_change_ok(inode, attr);
1082                 if (err)
1083                         return err;
1084         }
1085
1086         if ((attr->ia_valid & ATTR_OPEN) && fc->atomic_o_trunc)
1087                 return 0;
1088
1089         if (attr->ia_valid & ATTR_SIZE) {
1090                 unsigned long limit;
1091                 if (IS_SWAPFILE(inode))
1092                         return -ETXTBSY;
1093                 limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
1094                 if (limit != RLIM_INFINITY && attr->ia_size > (loff_t) limit) {
1095                         send_sig(SIGXFSZ, current, 0);
1096                         return -EFBIG;
1097                 }
1098         }
1099
1100         req = fuse_get_req(fc);
1101         if (IS_ERR(req))
1102                 return PTR_ERR(req);
1103
1104         memset(&inarg, 0, sizeof(inarg));
1105         iattr_to_fattr(attr, &inarg);
1106         if (file) {
1107                 struct fuse_file *ff = file->private_data;
1108                 inarg.valid |= FATTR_FH;
1109                 inarg.fh = ff->fh;
1110         }
1111         req->in.h.opcode = FUSE_SETATTR;
1112         req->in.h.nodeid = get_node_id(inode);
1113         req->in.numargs = 1;
1114         req->in.args[0].size = sizeof(inarg);
1115         req->in.args[0].value = &inarg;
1116         req->out.numargs = 1;
1117         req->out.args[0].size = sizeof(outarg);
1118         req->out.args[0].value = &outarg;
1119         request_send(fc, req);
1120         err = req->out.h.error;
1121         fuse_put_request(fc, req);
1122         if (err) {
1123                 if (err == -EINTR)
1124                         fuse_invalidate_attr(inode);
1125                 return err;
1126         }
1127
1128         if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
1129                 make_bad_inode(inode);
1130                 return -EIO;
1131         }
1132
1133         fuse_change_attributes(inode, &outarg.attr, attr_timeout(&outarg), 0);
1134         return 0;
1135 }
1136
1137 static int fuse_setattr(struct dentry *entry, struct iattr *attr)
1138 {
1139         if (attr->ia_valid & ATTR_FILE)
1140                 return fuse_do_setattr(entry, attr, attr->ia_file);
1141         else
1142                 return fuse_do_setattr(entry, attr, NULL);
1143 }
1144
1145 static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
1146                         struct kstat *stat)
1147 {
1148         struct inode *inode = entry->d_inode;
1149         struct fuse_inode *fi = get_fuse_inode(inode);
1150         struct fuse_conn *fc = get_fuse_conn(inode);
1151         int err;
1152
1153         if (!fuse_allow_task(fc, current))
1154                 return -EACCES;
1155
1156         if (fi->i_time < get_jiffies_64())
1157                 err = fuse_do_getattr(inode, stat, NULL);
1158         else {
1159                 err = 0;
1160                 generic_fillattr(inode, stat);
1161                 stat->mode = fi->orig_i_mode;
1162         }
1163
1164         return err;
1165 }
1166
1167 static int fuse_setxattr(struct dentry *entry, const char *name,
1168                          const void *value, size_t size, int flags)
1169 {
1170         struct inode *inode = entry->d_inode;
1171         struct fuse_conn *fc = get_fuse_conn(inode);
1172         struct fuse_req *req;
1173         struct fuse_setxattr_in inarg;
1174         int err;
1175
1176         if (fc->no_setxattr)
1177                 return -EOPNOTSUPP;
1178
1179         req = fuse_get_req(fc);
1180         if (IS_ERR(req))
1181                 return PTR_ERR(req);
1182
1183         memset(&inarg, 0, sizeof(inarg));
1184         inarg.size = size;
1185         inarg.flags = flags;
1186         req->in.h.opcode = FUSE_SETXATTR;
1187         req->in.h.nodeid = get_node_id(inode);
1188         req->in.numargs = 3;
1189         req->in.args[0].size = sizeof(inarg);
1190         req->in.args[0].value = &inarg;
1191         req->in.args[1].size = strlen(name) + 1;
1192         req->in.args[1].value = name;
1193         req->in.args[2].size = size;
1194         req->in.args[2].value = value;
1195         request_send(fc, req);
1196         err = req->out.h.error;
1197         fuse_put_request(fc, req);
1198         if (err == -ENOSYS) {
1199                 fc->no_setxattr = 1;
1200                 err = -EOPNOTSUPP;
1201         }
1202         return err;
1203 }
1204
1205 static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
1206                              void *value, size_t size)
1207 {
1208         struct inode *inode = entry->d_inode;
1209         struct fuse_conn *fc = get_fuse_conn(inode);
1210         struct fuse_req *req;
1211         struct fuse_getxattr_in inarg;
1212         struct fuse_getxattr_out outarg;
1213         ssize_t ret;
1214
1215         if (fc->no_getxattr)
1216                 return -EOPNOTSUPP;
1217
1218         req = fuse_get_req(fc);
1219         if (IS_ERR(req))
1220                 return PTR_ERR(req);
1221
1222         memset(&inarg, 0, sizeof(inarg));
1223         inarg.size = size;
1224         req->in.h.opcode = FUSE_GETXATTR;
1225         req->in.h.nodeid = get_node_id(inode);
1226         req->in.numargs = 2;
1227         req->in.args[0].size = sizeof(inarg);
1228         req->in.args[0].value = &inarg;
1229         req->in.args[1].size = strlen(name) + 1;
1230         req->in.args[1].value = name;
1231         /* This is really two different operations rolled into one */
1232         req->out.numargs = 1;
1233         if (size) {
1234                 req->out.argvar = 1;
1235                 req->out.args[0].size = size;
1236                 req->out.args[0].value = value;
1237         } else {
1238                 req->out.args[0].size = sizeof(outarg);
1239                 req->out.args[0].value = &outarg;
1240         }
1241         request_send(fc, req);
1242         ret = req->out.h.error;
1243         if (!ret)
1244                 ret = size ? req->out.args[0].size : outarg.size;
1245         else {
1246                 if (ret == -ENOSYS) {
1247                         fc->no_getxattr = 1;
1248                         ret = -EOPNOTSUPP;
1249                 }
1250         }
1251         fuse_put_request(fc, req);
1252         return ret;
1253 }
1254
1255 static ssize_t fuse_listxattr(struct dentry *entry, char *list, 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 (!fuse_allow_task(fc, current))
1265                 return -EACCES;
1266
1267         if (fc->no_listxattr)
1268                 return -EOPNOTSUPP;
1269
1270         req = fuse_get_req(fc);
1271         if (IS_ERR(req))
1272                 return PTR_ERR(req);
1273
1274         memset(&inarg, 0, sizeof(inarg));
1275         inarg.size = size;
1276         req->in.h.opcode = FUSE_LISTXATTR;
1277         req->in.h.nodeid = get_node_id(inode);
1278         req->in.numargs = 1;
1279         req->in.args[0].size = sizeof(inarg);
1280         req->in.args[0].value = &inarg;
1281         /* This is really two different operations rolled into one */
1282         req->out.numargs = 1;
1283         if (size) {
1284                 req->out.argvar = 1;
1285                 req->out.args[0].size = size;
1286                 req->out.args[0].value = list;
1287         } else {
1288                 req->out.args[0].size = sizeof(outarg);
1289                 req->out.args[0].value = &outarg;
1290         }
1291         request_send(fc, req);
1292         ret = req->out.h.error;
1293         if (!ret)
1294                 ret = size ? req->out.args[0].size : outarg.size;
1295         else {
1296                 if (ret == -ENOSYS) {
1297                         fc->no_listxattr = 1;
1298                         ret = -EOPNOTSUPP;
1299                 }
1300         }
1301         fuse_put_request(fc, req);
1302         return ret;
1303 }
1304
1305 static int fuse_removexattr(struct dentry *entry, const char *name)
1306 {
1307         struct inode *inode = entry->d_inode;
1308         struct fuse_conn *fc = get_fuse_conn(inode);
1309         struct fuse_req *req;
1310         int err;
1311
1312         if (fc->no_removexattr)
1313                 return -EOPNOTSUPP;
1314
1315         req = fuse_get_req(fc);
1316         if (IS_ERR(req))
1317                 return PTR_ERR(req);
1318
1319         req->in.h.opcode = FUSE_REMOVEXATTR;
1320         req->in.h.nodeid = get_node_id(inode);
1321         req->in.numargs = 1;
1322         req->in.args[0].size = strlen(name) + 1;
1323         req->in.args[0].value = name;
1324         request_send(fc, req);
1325         err = req->out.h.error;
1326         fuse_put_request(fc, req);
1327         if (err == -ENOSYS) {
1328                 fc->no_removexattr = 1;
1329                 err = -EOPNOTSUPP;
1330         }
1331         return err;
1332 }
1333
1334 static const struct inode_operations fuse_dir_inode_operations = {
1335         .lookup         = fuse_lookup,
1336         .mkdir          = fuse_mkdir,
1337         .symlink        = fuse_symlink,
1338         .unlink         = fuse_unlink,
1339         .rmdir          = fuse_rmdir,
1340         .rename         = fuse_rename,
1341         .link           = fuse_link,
1342         .setattr        = fuse_setattr,
1343         .create         = fuse_create,
1344         .mknod          = fuse_mknod,
1345         .permission     = fuse_permission,
1346         .getattr        = fuse_getattr,
1347         .setxattr       = fuse_setxattr,
1348         .getxattr       = fuse_getxattr,
1349         .listxattr      = fuse_listxattr,
1350         .removexattr    = fuse_removexattr,
1351 };
1352
1353 static const struct file_operations fuse_dir_operations = {
1354         .llseek         = generic_file_llseek,
1355         .read           = generic_read_dir,
1356         .readdir        = fuse_readdir,
1357         .open           = fuse_dir_open,
1358         .release        = fuse_dir_release,
1359         .fsync          = fuse_dir_fsync,
1360 };
1361
1362 static const struct inode_operations fuse_common_inode_operations = {
1363         .setattr        = fuse_setattr,
1364         .permission     = fuse_permission,
1365         .getattr        = fuse_getattr,
1366         .setxattr       = fuse_setxattr,
1367         .getxattr       = fuse_getxattr,
1368         .listxattr      = fuse_listxattr,
1369         .removexattr    = fuse_removexattr,
1370 };
1371
1372 static const struct inode_operations fuse_symlink_inode_operations = {
1373         .setattr        = fuse_setattr,
1374         .follow_link    = fuse_follow_link,
1375         .put_link       = fuse_put_link,
1376         .readlink       = generic_readlink,
1377         .getattr        = fuse_getattr,
1378         .setxattr       = fuse_setxattr,
1379         .getxattr       = fuse_getxattr,
1380         .listxattr      = fuse_listxattr,
1381         .removexattr    = fuse_removexattr,
1382 };
1383
1384 void fuse_init_common(struct inode *inode)
1385 {
1386         inode->i_op = &fuse_common_inode_operations;
1387 }
1388
1389 void fuse_init_dir(struct inode *inode)
1390 {
1391         inode->i_op = &fuse_dir_inode_operations;
1392         inode->i_fop = &fuse_dir_operations;
1393 }
1394
1395 void fuse_init_symlink(struct inode *inode)
1396 {
1397         inode->i_op = &fuse_symlink_inode_operations;
1398 }