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