fs/fuse/dir.c

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