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/sched.h>
  14 #include <linux/namei.h>
  15 #include <linux/slab.h>
  16
  17 static bool fuse_use_readdirplus(struct inode *dir, struct dir_context *ctx)
  18 {
  19         struct fuse_conn *fc = get_fuse_conn(dir);
  20         struct fuse_inode *fi = get_fuse_inode(dir);
  21
  22         if (!fc->do_readdirplus)
  23                 return false;
  24         if (!fc->readdirplus_auto)
  25                 return true;
  26         if (test_and_clear_bit(FUSE_I_ADVISE_RDPLUS, &fi->state))
  27                 return true;
  28         if (ctx->pos == 0)
  29                 return true;
  30         return false;
  31 }
  32
  33 static void fuse_advise_use_readdirplus(struct inode *dir)
  34 {
  35         struct fuse_inode *fi = get_fuse_inode(dir);
  36
  37         set_bit(FUSE_I_ADVISE_RDPLUS, &fi->state);
  38 }
  39
  40 #if BITS_PER_LONG >= 64
  41 static inline void fuse_dentry_settime(struct dentry *entry, u64 time)
  42 {
  43         entry->d_time = time;
  44 }
  45
  46 static inline u64 fuse_dentry_time(struct dentry *entry)
  47 {
  48         return entry->d_time;
  49 }
  50 #else
  51 /*
  52  * On 32 bit archs store the high 32 bits of time in d_fsdata
  53  */
  54 static void fuse_dentry_settime(struct dentry *entry, u64 time)
  55 {
  56         entry->d_time = time;
  57         entry->d_fsdata = (void *) (unsigned long) (time >> 32);
  58 }
  59
  60 static u64 fuse_dentry_time(struct dentry *entry)
  61 {
  62         return (u64) entry->d_time +
  63                 ((u64) (unsigned long) entry->d_fsdata << 32);
  64 }
  65 #endif
  66
  67 /*
  68  * FUSE caches dentries and attributes with separate timeout.  The
  69  * time in jiffies until the dentry/attributes are valid is stored in
  70  * dentry->d_time and fuse_inode->i_time respectively.
  71  */
  72
  73 /*
  74  * Calculate the time in jiffies until a dentry/attributes are valid
  75  */
  76 static u64 time_to_jiffies(unsigned long sec, unsigned long nsec)
  77 {
  78         if (sec || nsec) {
  79                 struct timespec ts = {sec, nsec};
  80                 return get_jiffies_64() + timespec_to_jiffies(&ts);
  81         } else
  82                 return 0;
  83 }
  84
  85 /*
  86  * Set dentry and possibly attribute timeouts from the lookup/mk*
  87  * replies
  88  */
  89 static void fuse_change_entry_timeout(struct dentry *entry,
  90                                       struct fuse_entry_out *o)
  91 {
  92         fuse_dentry_settime(entry,
  93                 time_to_jiffies(o->entry_valid, o->entry_valid_nsec));
  94 }
  95
  96 static u64 attr_timeout(struct fuse_attr_out *o)
  97 {
  98         return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
  99 }
 100
 101 static u64 entry_attr_timeout(struct fuse_entry_out *o)
 102 {
 103         return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
 104 }
 105
 106 /*
 107  * Mark the attributes as stale, so that at the next call to
 108  * ->getattr() they will be fetched from userspace
 109  */
 110 void fuse_invalidate_attr(struct inode *inode)
 111 {
 112         get_fuse_inode(inode)->i_time = 0;
 113 }
 114
 115 /**
 116  * Mark the attributes as stale due to an atime change.  Avoid the invalidate if
 117  * atime is not used.
 118  */
 119 void fuse_invalidate_atime(struct inode *inode)
 120 {
 121         if (!IS_RDONLY(inode))
 122                 fuse_invalidate_attr(inode);
 123 }
 124
 125 /*
 126  * Just mark the entry as stale, so that a next attempt to look it up
 127  * will result in a new lookup call to userspace
 128  *
 129  * This is called when a dentry is about to become negative and the
 130  * timeout is unknown (unlink, rmdir, rename and in some cases
 131  * lookup)
 132  */
 133 void fuse_invalidate_entry_cache(struct dentry *entry)
 134 {
 135         fuse_dentry_settime(entry, 0);
 136 }
 137
 138 /*
 139  * Same as fuse_invalidate_entry_cache(), but also try to remove the
 140  * dentry from the hash
 141  */
 142 static void fuse_invalidate_entry(struct dentry *entry)
 143 {
 144         d_invalidate(entry);
 145         fuse_invalidate_entry_cache(entry);
 146 }
 147
 148 static void fuse_lookup_init(struct fuse_conn *fc, struct fuse_req *req,
 149                              u64 nodeid, struct qstr *name,
 150                              struct fuse_entry_out *outarg)
 151 {
 152         memset(outarg, 0, sizeof(struct fuse_entry_out));
 153         req->in.h.opcode = FUSE_LOOKUP;
 154         req->in.h.nodeid = nodeid;
 155         req->in.numargs = 1;
 156         req->in.args[0].size = name->len + 1;
 157         req->in.args[0].value = name->name;
 158         req->out.numargs = 1;
 159         if (fc->minor < 9)
 160                 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
 161         else
 162                 req->out.args[0].size = sizeof(struct fuse_entry_out);
 163         req->out.args[0].value = outarg;
 164 }
 165
 166 u64 fuse_get_attr_version(struct fuse_conn *fc)
 167 {
 168         u64 curr_version;
 169
 170         /*
 171          * The spin lock isn't actually needed on 64bit archs, but we
 172          * don't yet care too much about such optimizations.
 173          */
 174         spin_lock(&fc->lock);
 175         curr_version = fc->attr_version;
 176         spin_unlock(&fc->lock);
 177
 178         return curr_version;
 179 }
 180
 181 /*
 182  * Check whether the dentry is still valid
 183  *
 184  * If the entry validity timeout has expired and the dentry is
 185  * positive, try to redo the lookup.  If the lookup results in a
 186  * different inode, then let the VFS invalidate the dentry and redo
 187  * the lookup once more.  If the lookup results in the same inode,
 188  * then refresh the attributes, timeouts and mark the dentry valid.
 189  */
 190 static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
 191 {
 192         struct inode *inode;
 193         struct dentry *parent;
 194         struct fuse_conn *fc;
 195         struct fuse_inode *fi;
 196         int ret;
 197
 198         inode = ACCESS_ONCE(entry->d_inode);
 199         if (inode && is_bad_inode(inode))
 200                 goto invalid;
 201         else if (time_before64(fuse_dentry_time(entry), get_jiffies_64()) ||
 202                  (flags & LOOKUP_REVAL)) {
 203                 int err;
 204                 struct fuse_entry_out outarg;
 205                 struct fuse_req *req;
 206                 struct fuse_forget_link *forget;
 207                 u64 attr_version;
 208
 209                 /* For negative dentries, always do a fresh lookup */
 210                 if (!inode)
 211                         goto invalid;
 212
 213                 ret = -ECHILD;
 214                 if (flags & LOOKUP_RCU)
 215                         goto out;
 216
 217                 fc = get_fuse_conn(inode);
 218                 req = fuse_get_req_nopages(fc);
 219                 ret = PTR_ERR(req);
 220                 if (IS_ERR(req))
 221                         goto out;
 222
 223                 forget = fuse_alloc_forget();
 224                 if (!forget) {
 225                         fuse_put_request(fc, req);
 226                         ret = -ENOMEM;
 227                         goto out;
 228                 }
 229
 230                 attr_version = fuse_get_attr_version(fc);
 231
 232                 parent = dget_parent(entry);
 233                 fuse_lookup_init(fc, req, get_node_id(parent->d_inode),
 234                                  &entry->d_name, &outarg);
 235                 fuse_request_send(fc, req);
 236                 dput(parent);
 237                 err = req->out.h.error;
 238                 fuse_put_request(fc, req);
 239                 /* Zero nodeid is same as -ENOENT */
 240                 if (!err && !outarg.nodeid)
 241                         err = -ENOENT;
 242                 if (!err) {
 243                         fi = get_fuse_inode(inode);
 244                         if (outarg.nodeid != get_node_id(inode)) {
 245                                 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
 246                                 goto invalid;
 247                         }
 248                         spin_lock(&fc->lock);
 249                         fi->nlookup++;
 250                         spin_unlock(&fc->lock);
 251                 }
 252                 kfree(forget);
 253                 if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
 254                         goto invalid;
 255
 256                 fuse_change_attributes(inode, &outarg.attr,
 257                                        entry_attr_timeout(&outarg),
 258                                        attr_version);
 259                 fuse_change_entry_timeout(entry, &outarg);
 260         } else if (inode) {
 261                 fi = get_fuse_inode(inode);
 262                 if (flags & LOOKUP_RCU) {
 263                         if (test_bit(FUSE_I_INIT_RDPLUS, &fi->state))
 264                                 return -ECHILD;
 265                 } else if (test_and_clear_bit(FUSE_I_INIT_RDPLUS, &fi->state)) {
 266                         parent = dget_parent(entry);
 267                         fuse_advise_use_readdirplus(parent->d_inode);
 268                         dput(parent);
 269                 }
 270         }
 271         ret = 1;
 272 out:
 273         return ret;
 274
 275 invalid:
 276         ret = 0;
 277         goto out;
 278 }
 279
 280 static int invalid_nodeid(u64 nodeid)
 281 {
 282         return !nodeid || nodeid == FUSE_ROOT_ID;
 283 }
 284
 285 const struct dentry_operations fuse_dentry_operations = {
 286         .d_revalidate   = fuse_dentry_revalidate,
 287 };
 288
 289 int fuse_valid_type(int m)
 290 {
 291         return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
 292                 S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
 293 }
 294
 295 int fuse_lookup_name(struct super_block *sb, u64 nodeid, struct qstr *name,
 296                      struct fuse_entry_out *outarg, struct inode **inode)
 297 {
 298         struct fuse_conn *fc = get_fuse_conn_super(sb);
 299         struct fuse_req *req;
 300         struct fuse_forget_link *forget;
 301         u64 attr_version;
 302         int err;
 303
 304         *inode = NULL;
 305         err = -ENAMETOOLONG;
 306         if (name->len > FUSE_NAME_MAX)
 307                 goto out;
 308
 309         req = fuse_get_req_nopages(fc);
 310         err = PTR_ERR(req);
 311         if (IS_ERR(req))
 312                 goto out;
 313
 314         forget = fuse_alloc_forget();
 315         err = -ENOMEM;
 316         if (!forget) {
 317                 fuse_put_request(fc, req);
 318                 goto out;
 319         }
 320
 321         attr_version = fuse_get_attr_version(fc);
 322
 323         fuse_lookup_init(fc, req, nodeid, name, outarg);
 324         fuse_request_send(fc, req);
 325         err = req->out.h.error;
 326         fuse_put_request(fc, req);
 327         /* Zero nodeid is same as -ENOENT, but with valid timeout */
 328         if (err || !outarg->nodeid)
 329                 goto out_put_forget;
 330
 331         err = -EIO;
 332         if (!outarg->nodeid)
 333                 goto out_put_forget;
 334         if (!fuse_valid_type(outarg->attr.mode))
 335                 goto out_put_forget;
 336
 337         *inode = fuse_iget(sb, outarg->nodeid, outarg->generation,
 338                            &outarg->attr, entry_attr_timeout(outarg),
 339                            attr_version);
 340         err = -ENOMEM;
 341         if (!*inode) {
 342                 fuse_queue_forget(fc, forget, outarg->nodeid, 1);
 343                 goto out;
 344         }
 345         err = 0;
 346
 347  out_put_forget:
 348         kfree(forget);
 349  out:
 350         return err;
 351 }
 352
 353 static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
 354                                   unsigned int flags)
 355 {
 356         int err;
 357         struct fuse_entry_out outarg;
 358         struct inode *inode;
 359         struct dentry *newent;
 360         bool outarg_valid = true;
 361
 362         err = fuse_lookup_name(dir->i_sb, get_node_id(dir), &entry->d_name,
 363                                &outarg, &inode);
 364         if (err == -ENOENT) {
 365                 outarg_valid = false;
 366                 err = 0;
 367         }
 368         if (err)
 369                 goto out_err;
 370
 371         err = -EIO;
 372         if (inode && get_node_id(inode) == FUSE_ROOT_ID)
 373                 goto out_iput;
 374
 375         newent = d_materialise_unique(entry, inode);
 376         err = PTR_ERR(newent);
 377         if (IS_ERR(newent))
 378                 goto out_err;
 379
 380         entry = newent ? newent : entry;
 381         if (outarg_valid)
 382                 fuse_change_entry_timeout(entry, &outarg);
 383         else
 384                 fuse_invalidate_entry_cache(entry);
 385
 386         fuse_advise_use_readdirplus(dir);
 387         return newent;
 388
 389  out_iput:
 390         iput(inode);
 391  out_err:
 392         return ERR_PTR(err);
 393 }
 394
 395 /*
 396  * Atomic create+open operation
 397  *
 398  * If the filesystem doesn't support this, then fall back to separate
 399  * 'mknod' + 'open' requests.
 400  */
 401 static int fuse_create_open(struct inode *dir, struct dentry *entry,
 402                             struct file *file, unsigned flags,
 403                             umode_t mode, int *opened)
 404 {
 405         int err;
 406         struct inode *inode;
 407         struct fuse_conn *fc = get_fuse_conn(dir);
 408         struct fuse_req *req;
 409         struct fuse_forget_link *forget;
 410         struct fuse_create_in inarg;
 411         struct fuse_open_out outopen;
 412         struct fuse_entry_out outentry;
 413         struct fuse_file *ff;
 414
 415         /* Userspace expects S_IFREG in create mode */
 416         BUG_ON((mode & S_IFMT) != S_IFREG);
 417
 418         forget = fuse_alloc_forget();
 419         err = -ENOMEM;
 420         if (!forget)
 421                 goto out_err;
 422
 423         req = fuse_get_req_nopages(fc);
 424         err = PTR_ERR(req);
 425         if (IS_ERR(req))
 426                 goto out_put_forget_req;
 427
 428         err = -ENOMEM;
 429         ff = fuse_file_alloc(fc);
 430         if (!ff)
 431                 goto out_put_request;
 432
 433         if (!fc->dont_mask)
 434                 mode &= ~current_umask();
 435
 436         flags &= ~O_NOCTTY;
 437         memset(&inarg, 0, sizeof(inarg));
 438         memset(&outentry, 0, sizeof(outentry));
 439         inarg.flags = flags;
 440         inarg.mode = mode;
 441         inarg.umask = current_umask();
 442         req->in.h.opcode = FUSE_CREATE;
 443         req->in.h.nodeid = get_node_id(dir);
 444         req->in.numargs = 2;
 445         req->in.args[0].size = fc->minor < 12 ? sizeof(struct fuse_open_in) :
 446                                                 sizeof(inarg);
 447         req->in.args[0].value = &inarg;
 448         req->in.args[1].size = entry->d_name.len + 1;
 449         req->in.args[1].value = entry->d_name.name;
 450         req->out.numargs = 2;
 451         if (fc->minor < 9)
 452                 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
 453         else
 454                 req->out.args[0].size = sizeof(outentry);
 455         req->out.args[0].value = &outentry;
 456         req->out.args[1].size = sizeof(outopen);
 457         req->out.args[1].value = &outopen;
 458         fuse_request_send(fc, req);
 459         err = req->out.h.error;
 460         if (err)
 461                 goto out_free_ff;
 462
 463         err = -EIO;
 464         if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
 465                 goto out_free_ff;
 466
 467         fuse_put_request(fc, req);
 468         ff->fh = outopen.fh;
 469         ff->nodeid = outentry.nodeid;
 470         ff->open_flags = outopen.open_flags;
 471         inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
 472                           &outentry.attr, entry_attr_timeout(&outentry), 0);
 473         if (!inode) {
 474                 flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
 475                 fuse_sync_release(ff, flags);
 476                 fuse_queue_forget(fc, forget, outentry.nodeid, 1);
 477                 err = -ENOMEM;
 478                 goto out_err;
 479         }
 480         kfree(forget);
 481         d_instantiate(entry, inode);
 482         fuse_change_entry_timeout(entry, &outentry);
 483         fuse_invalidate_attr(dir);
 484         err = finish_open(file, entry, generic_file_open, opened);
 485         if (err) {
 486                 fuse_sync_release(ff, flags);
 487         } else {
 488                 file->private_data = fuse_file_get(ff);
 489                 fuse_finish_open(inode, file);
 490         }
 491         return err;
 492
 493 out_free_ff:
 494         fuse_file_free(ff);
 495 out_put_request:
 496         fuse_put_request(fc, req);
 497 out_put_forget_req:
 498         kfree(forget);
 499 out_err:
 500         return err;
 501 }
 502
 503 static int fuse_mknod(struct inode *, struct dentry *, umode_t, dev_t);
 504 static int fuse_atomic_open(struct inode *dir, struct dentry *entry,
 505                             struct file *file, unsigned flags,
 506                             umode_t mode, int *opened)
 507 {
 508         int err;
 509         struct fuse_conn *fc = get_fuse_conn(dir);
 510         struct dentry *res = NULL;
 511
 512         if (d_unhashed(entry)) {
 513                 res = fuse_lookup(dir, entry, 0);
 514                 if (IS_ERR(res))
 515                         return PTR_ERR(res);
 516
 517                 if (res)
 518                         entry = res;
 519         }
 520
 521         if (!(flags & O_CREAT) || entry->d_inode)
 522                 goto no_open;
 523
 524         /* Only creates */
 525         *opened |= FILE_CREATED;
 526
 527         if (fc->no_create)
 528                 goto mknod;
 529
 530         err = fuse_create_open(dir, entry, file, flags, mode, opened);
 531         if (err == -ENOSYS) {
 532                 fc->no_create = 1;
 533                 goto mknod;
 534         }
 535 out_dput:
 536         dput(res);
 537         return err;
 538
 539 mknod:
 540         err = fuse_mknod(dir, entry, mode, 0);
 541         if (err)
 542                 goto out_dput;
 543 no_open:
 544         return finish_no_open(file, res);
 545 }
 546
 547 /*
 548  * Code shared between mknod, mkdir, symlink and link
 549  */
 550 static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
 551                             struct inode *dir, struct dentry *entry,
 552                             umode_t mode)
 553 {
 554         struct fuse_entry_out outarg;
 555         struct inode *inode;
 556         int err;
 557         struct fuse_forget_link *forget;
 558
 559         forget = fuse_alloc_forget();
 560         if (!forget) {
 561                 fuse_put_request(fc, req);
 562                 return -ENOMEM;
 563         }
 564
 565         memset(&outarg, 0, sizeof(outarg));
 566         req->in.h.nodeid = get_node_id(dir);
 567         req->out.numargs = 1;
 568         if (fc->minor < 9)
 569                 req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
 570         else
 571                 req->out.args[0].size = sizeof(outarg);
 572         req->out.args[0].value = &outarg;
 573         fuse_request_send(fc, req);
 574         err = req->out.h.error;
 575         fuse_put_request(fc, req);
 576         if (err)
 577                 goto out_put_forget_req;
 578
 579         err = -EIO;
 580         if (invalid_nodeid(outarg.nodeid))
 581                 goto out_put_forget_req;
 582
 583         if ((outarg.attr.mode ^ mode) & S_IFMT)
 584                 goto out_put_forget_req;
 585
 586         inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
 587                           &outarg.attr, entry_attr_timeout(&outarg), 0);
 588         if (!inode) {
 589                 fuse_queue_forget(fc, forget, outarg.nodeid, 1);
 590                 return -ENOMEM;
 591         }
 592         kfree(forget);
 593
 594         err = d_instantiate_no_diralias(entry, inode);
 595         if (err)
 596                 return err;
 597
 598         fuse_change_entry_timeout(entry, &outarg);
 599         fuse_invalidate_attr(dir);
 600         return 0;
 601
 602  out_put_forget_req:
 603         kfree(forget);
 604         return err;
 605 }
 606
 607 static int fuse_mknod(struct inode *dir, struct dentry *entry, umode_t mode,
 608                       dev_t rdev)
 609 {
 610         struct fuse_mknod_in inarg;
 611         struct fuse_conn *fc = get_fuse_conn(dir);
 612         struct fuse_req *req = fuse_get_req_nopages(fc);
 613         if (IS_ERR(req))
 614                 return PTR_ERR(req);
 615
 616         if (!fc->dont_mask)
 617                 mode &= ~current_umask();
 618
 619         memset(&inarg, 0, sizeof(inarg));
 620         inarg.mode = mode;
 621         inarg.rdev = new_encode_dev(rdev);
 622         inarg.umask = current_umask();
 623         req->in.h.opcode = FUSE_MKNOD;
 624         req->in.numargs = 2;
 625         req->in.args[0].size = fc->minor < 12 ? FUSE_COMPAT_MKNOD_IN_SIZE :
 626                                                 sizeof(inarg);
 627         req->in.args[0].value = &inarg;
 628         req->in.args[1].size = entry->d_name.len + 1;
 629         req->in.args[1].value = entry->d_name.name;
 630         return create_new_entry(fc, req, dir, entry, mode);
 631 }
 632
 633 static int fuse_create(struct inode *dir, struct dentry *entry, umode_t mode,
 634                        bool excl)
 635 {
 636         return fuse_mknod(dir, entry, mode, 0);
 637 }
 638
 639 static int fuse_mkdir(struct inode *dir, struct dentry *entry, umode_t mode)
 640 {
 641         struct fuse_mkdir_in inarg;
 642         struct fuse_conn *fc = get_fuse_conn(dir);
 643         struct fuse_req *req = fuse_get_req_nopages(fc);
 644         if (IS_ERR(req))
 645                 return PTR_ERR(req);
 646
 647         if (!fc->dont_mask)
 648                 mode &= ~current_umask();
 649
 650         memset(&inarg, 0, sizeof(inarg));
 651         inarg.mode = mode;
 652         inarg.umask = current_umask();
 653         req->in.h.opcode = FUSE_MKDIR;
 654         req->in.numargs = 2;
 655         req->in.args[0].size = sizeof(inarg);
 656         req->in.args[0].value = &inarg;
 657         req->in.args[1].size = entry->d_name.len + 1;
 658         req->in.args[1].value = entry->d_name.name;
 659         return create_new_entry(fc, req, dir, entry, S_IFDIR);
 660 }
 661
 662 static int fuse_symlink(struct inode *dir, struct dentry *entry,
 663                         const char *link)
 664 {
 665         struct fuse_conn *fc = get_fuse_conn(dir);
 666         unsigned len = strlen(link) + 1;
 667         struct fuse_req *req = fuse_get_req_nopages(fc);
 668         if (IS_ERR(req))
 669                 return PTR_ERR(req);
 670
 671         req->in.h.opcode = FUSE_SYMLINK;
 672         req->in.numargs = 2;
 673         req->in.args[0].size = entry->d_name.len + 1;
 674         req->in.args[0].value = entry->d_name.name;
 675         req->in.args[1].size = len;
 676         req->in.args[1].value = link;
 677         return create_new_entry(fc, req, dir, entry, S_IFLNK);
 678 }
 679
 680 static inline void fuse_update_ctime(struct inode *inode)
 681 {
 682         if (!IS_NOCMTIME(inode)) {
 683                 inode->i_ctime = current_fs_time(inode->i_sb);
 684                 mark_inode_dirty_sync(inode);
 685         }
 686 }
 687
 688 static int fuse_unlink(struct inode *dir, struct dentry *entry)
 689 {
 690         int err;
 691         struct fuse_conn *fc = get_fuse_conn(dir);
 692         struct fuse_req *req = fuse_get_req_nopages(fc);
 693         if (IS_ERR(req))
 694                 return PTR_ERR(req);
 695
 696         req->in.h.opcode = FUSE_UNLINK;
 697         req->in.h.nodeid = get_node_id(dir);
 698         req->in.numargs = 1;
 699         req->in.args[0].size = entry->d_name.len + 1;
 700         req->in.args[0].value = entry->d_name.name;
 701         fuse_request_send(fc, req);
 702         err = req->out.h.error;
 703         fuse_put_request(fc, req);
 704         if (!err) {
 705                 struct inode *inode = entry->d_inode;
 706                 struct fuse_inode *fi = get_fuse_inode(inode);
 707
 708                 spin_lock(&fc->lock);
 709                 fi->attr_version = ++fc->attr_version;
 710                 /*
 711                  * If i_nlink == 0 then unlink doesn't make sense, yet this can
 712                  * happen if userspace filesystem is careless.  It would be
 713                  * difficult to enforce correct nlink usage so just ignore this
 714                  * condition here
 715                  */
 716                 if (inode->i_nlink > 0)
 717                         drop_nlink(inode);
 718                 spin_unlock(&fc->lock);
 719                 fuse_invalidate_attr(inode);
 720                 fuse_invalidate_attr(dir);
 721                 fuse_invalidate_entry_cache(entry);
 722                 fuse_update_ctime(inode);
 723         } else if (err == -EINTR)
 724                 fuse_invalidate_entry(entry);
 725         return err;
 726 }
 727
 728 static int fuse_rmdir(struct inode *dir, struct dentry *entry)
 729 {
 730         int err;
 731         struct fuse_conn *fc = get_fuse_conn(dir);
 732         struct fuse_req *req = fuse_get_req_nopages(fc);
 733         if (IS_ERR(req))
 734                 return PTR_ERR(req);
 735
 736         req->in.h.opcode = FUSE_RMDIR;
 737         req->in.h.nodeid = get_node_id(dir);
 738         req->in.numargs = 1;
 739         req->in.args[0].size = entry->d_name.len + 1;
 740         req->in.args[0].value = entry->d_name.name;
 741         fuse_request_send(fc, req);
 742         err = req->out.h.error;
 743         fuse_put_request(fc, req);
 744         if (!err) {
 745                 clear_nlink(entry->d_inode);
 746                 fuse_invalidate_attr(dir);
 747                 fuse_invalidate_entry_cache(entry);
 748         } else if (err == -EINTR)
 749                 fuse_invalidate_entry(entry);
 750         return err;
 751 }
 752
 753 static int fuse_rename_common(struct inode *olddir, struct dentry *oldent,
 754                               struct inode *newdir, struct dentry *newent,
 755                               unsigned int flags, int opcode, size_t argsize)
 756 {
 757         int err;
 758         struct fuse_rename2_in inarg;
 759         struct fuse_conn *fc = get_fuse_conn(olddir);
 760         struct fuse_req *req;
 761
 762         req = fuse_get_req_nopages(fc);
 763         if (IS_ERR(req))
 764                 return PTR_ERR(req);
 765
 766         memset(&inarg, 0, argsize);
 767         inarg.newdir = get_node_id(newdir);
 768         inarg.flags = flags;
 769         req->in.h.opcode = opcode;
 770         req->in.h.nodeid = get_node_id(olddir);
 771         req->in.numargs = 3;
 772         req->in.args[0].size = argsize;
 773         req->in.args[0].value = &inarg;
 774         req->in.args[1].size = oldent->d_name.len + 1;
 775         req->in.args[1].value = oldent->d_name.name;
 776         req->in.args[2].size = newent->d_name.len + 1;
 777         req->in.args[2].value = newent->d_name.name;
 778         fuse_request_send(fc, req);
 779         err = req->out.h.error;
 780         fuse_put_request(fc, req);
 781         if (!err) {
 782                 /* ctime changes */
 783                 fuse_invalidate_attr(oldent->d_inode);
 784                 fuse_update_ctime(oldent->d_inode);
 785
 786                 if (flags & RENAME_EXCHANGE) {
 787                         fuse_invalidate_attr(newent->d_inode);
 788                         fuse_update_ctime(newent->d_inode);
 789                 }
 790
 791                 fuse_invalidate_attr(olddir);
 792                 if (olddir != newdir)
 793                         fuse_invalidate_attr(newdir);
 794
 795                 /* newent will end up negative */
 796                 if (!(flags & RENAME_EXCHANGE) && newent->d_inode) {
 797                         fuse_invalidate_attr(newent->d_inode);
 798                         fuse_invalidate_entry_cache(newent);
 799                         fuse_update_ctime(newent->d_inode);
 800                 }
 801         } else if (err == -EINTR) {
 802                 /* If request was interrupted, DEITY only knows if the
 803                    rename actually took place.  If the invalidation
 804                    fails (e.g. some process has CWD under the renamed
 805                    directory), then there can be inconsistency between
 806                    the dcache and the real filesystem.  Tough luck. */
 807                 fuse_invalidate_entry(oldent);
 808                 if (newent->d_inode)
 809                         fuse_invalidate_entry(newent);
 810         }
 811
 812         return err;
 813 }
 814
 815 static int fuse_rename2(struct inode *olddir, struct dentry *oldent,
 816                         struct inode *newdir, struct dentry *newent,
 817                         unsigned int flags)
 818 {
 819         struct fuse_conn *fc = get_fuse_conn(olddir);
 820         int err;
 821
 822         if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE))
 823                 return -EINVAL;
 824
 825         if (flags) {
 826                 if (fc->no_rename2 || fc->minor < 23)
 827                         return -EINVAL;
 828
 829                 err = fuse_rename_common(olddir, oldent, newdir, newent, flags,
 830                                          FUSE_RENAME2,
 831                                          sizeof(struct fuse_rename2_in));
 832                 if (err == -ENOSYS) {
 833                         fc->no_rename2 = 1;
 834                         err = -EINVAL;
 835                 }
 836         } else {
 837                 err = fuse_rename_common(olddir, oldent, newdir, newent, 0,
 838                                          FUSE_RENAME,
 839                                          sizeof(struct fuse_rename_in));
 840         }
 841
 842         return err;
 843 }
 844
 845 static int fuse_link(struct dentry *entry, struct inode *newdir,
 846                      struct dentry *newent)
 847 {
 848         int err;
 849         struct fuse_link_in inarg;
 850         struct inode *inode = entry->d_inode;
 851         struct fuse_conn *fc = get_fuse_conn(inode);
 852         struct fuse_req *req = fuse_get_req_nopages(fc);
 853         if (IS_ERR(req))
 854                 return PTR_ERR(req);
 855
 856         memset(&inarg, 0, sizeof(inarg));
 857         inarg.oldnodeid = get_node_id(inode);
 858         req->in.h.opcode = FUSE_LINK;
 859         req->in.numargs = 2;
 860         req->in.args[0].size = sizeof(inarg);
 861         req->in.args[0].value = &inarg;
 862         req->in.args[1].size = newent->d_name.len + 1;
 863         req->in.args[1].value = newent->d_name.name;
 864         err = create_new_entry(fc, req, newdir, newent, inode->i_mode);
 865         /* Contrary to "normal" filesystems it can happen that link
 866            makes two "logical" inodes point to the same "physical"
 867            inode.  We invalidate the attributes of the old one, so it
 868            will reflect changes in the backing inode (link count,
 869            etc.)
 870         */
 871         if (!err) {
 872                 struct fuse_inode *fi = get_fuse_inode(inode);
 873
 874                 spin_lock(&fc->lock);
 875                 fi->attr_version = ++fc->attr_version;
 876                 inc_nlink(inode);
 877                 spin_unlock(&fc->lock);
 878                 fuse_invalidate_attr(inode);
 879                 fuse_update_ctime(inode);
 880         } else if (err == -EINTR) {
 881                 fuse_invalidate_attr(inode);
 882         }
 883         return err;
 884 }
 885
 886 static void fuse_fillattr(struct inode *inode, struct fuse_attr *attr,
 887                           struct kstat *stat)
 888 {
 889         unsigned int blkbits;
 890         struct fuse_conn *fc = get_fuse_conn(inode);
 891
 892         /* see the comment in fuse_change_attributes() */
 893         if (fc->writeback_cache && S_ISREG(inode->i_mode)) {
 894                 attr->size = i_size_read(inode);
 895                 attr->mtime = inode->i_mtime.tv_sec;
 896                 attr->mtimensec = inode->i_mtime.tv_nsec;
 897                 attr->ctime = inode->i_ctime.tv_sec;
 898                 attr->ctimensec = inode->i_ctime.tv_nsec;
 899         }
 900
 901         stat->dev = inode->i_sb->s_dev;
 902         stat->ino = attr->ino;
 903         stat->mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
 904         stat->nlink = attr->nlink;
 905         stat->uid = make_kuid(&init_user_ns, attr->uid);
 906         stat->gid = make_kgid(&init_user_ns, attr->gid);
 907         stat->rdev = inode->i_rdev;
 908         stat->atime.tv_sec = attr->atime;
 909         stat->atime.tv_nsec = attr->atimensec;
 910         stat->mtime.tv_sec = attr->mtime;
 911         stat->mtime.tv_nsec = attr->mtimensec;
 912         stat->ctime.tv_sec = attr->ctime;
 913         stat->ctime.tv_nsec = attr->ctimensec;
 914         stat->size = attr->size;
 915         stat->blocks = attr->blocks;
 916
 917         if (attr->blksize != 0)
 918                 blkbits = ilog2(attr->blksize);
 919         else
 920                 blkbits = inode->i_sb->s_blocksize_bits;
 921
 922         stat->blksize = 1 << blkbits;
 923 }
 924
 925 static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
 926                            struct file *file)
 927 {
 928         int err;
 929         struct fuse_getattr_in inarg;
 930         struct fuse_attr_out outarg;
 931         struct fuse_conn *fc = get_fuse_conn(inode);
 932         struct fuse_req *req;
 933         u64 attr_version;
 934
 935         req = fuse_get_req_nopages(fc);
 936         if (IS_ERR(req))
 937                 return PTR_ERR(req);
 938
 939         attr_version = fuse_get_attr_version(fc);
 940
 941         memset(&inarg, 0, sizeof(inarg));
 942         memset(&outarg, 0, sizeof(outarg));
 943         /* Directories have separate file-handle space */
 944         if (file && S_ISREG(inode->i_mode)) {
 945                 struct fuse_file *ff = file->private_data;
 946
 947                 inarg.getattr_flags |= FUSE_GETATTR_FH;
 948                 inarg.fh = ff->fh;
 949         }
 950         req->in.h.opcode = FUSE_GETATTR;
 951         req->in.h.nodeid = get_node_id(inode);
 952         req->in.numargs = 1;
 953         req->in.args[0].size = sizeof(inarg);
 954         req->in.args[0].value = &inarg;
 955         req->out.numargs = 1;
 956         if (fc->minor < 9)
 957                 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
 958         else
 959                 req->out.args[0].size = sizeof(outarg);
 960         req->out.args[0].value = &outarg;
 961         fuse_request_send(fc, req);
 962         err = req->out.h.error;
 963         fuse_put_request(fc, req);
 964         if (!err) {
 965                 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
 966                         make_bad_inode(inode);
 967                         err = -EIO;
 968                 } else {
 969                         fuse_change_attributes(inode, &outarg.attr,
 970                                                attr_timeout(&outarg),
 971                                                attr_version);
 972                         if (stat)
 973                                 fuse_fillattr(inode, &outarg.attr, stat);
 974                 }
 975         }
 976         return err;
 977 }
 978
 979 int fuse_update_attributes(struct inode *inode, struct kstat *stat,
 980                            struct file *file, bool *refreshed)
 981 {
 982         struct fuse_inode *fi = get_fuse_inode(inode);
 983         int err;
 984         bool r;
 985
 986         if (time_before64(fi->i_time, get_jiffies_64())) {
 987                 r = true;
 988                 err = fuse_do_getattr(inode, stat, file);
 989         } else {
 990                 r = false;
 991                 err = 0;
 992                 if (stat) {
 993                         generic_fillattr(inode, stat);
 994                         stat->mode = fi->orig_i_mode;
 995                         stat->ino = fi->orig_ino;
 996                 }
 997         }
 998
 999         if (refreshed != NULL)
1000                 *refreshed = r;
1001
1002         return err;
1003 }
1004
1005 int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
1006                              u64 child_nodeid, struct qstr *name)
1007 {
1008         int err = -ENOTDIR;
1009         struct inode *parent;
1010         struct dentry *dir;
1011         struct dentry *entry;
1012
1013         parent = ilookup5(sb, parent_nodeid, fuse_inode_eq, &parent_nodeid);
1014         if (!parent)
1015                 return -ENOENT;
1016
1017         mutex_lock(&parent->i_mutex);
1018         if (!S_ISDIR(parent->i_mode))
1019                 goto unlock;
1020
1021         err = -ENOENT;
1022         dir = d_find_alias(parent);
1023         if (!dir)
1024                 goto unlock;
1025
1026         entry = d_lookup(dir, name);
1027         dput(dir);
1028         if (!entry)
1029                 goto unlock;
1030
1031         fuse_invalidate_attr(parent);
1032         fuse_invalidate_entry(entry);
1033
1034         if (child_nodeid != 0 && entry->d_inode) {
1035                 mutex_lock(&entry->d_inode->i_mutex);
1036                 if (get_node_id(entry->d_inode) != child_nodeid) {
1037                         err = -ENOENT;
1038                         goto badentry;
1039                 }
1040                 if (d_mountpoint(entry)) {
1041                         err = -EBUSY;
1042                         goto badentry;
1043                 }
1044                 if (S_ISDIR(entry->d_inode->i_mode)) {
1045                         shrink_dcache_parent(entry);
1046                         if (!simple_empty(entry)) {
1047                                 err = -ENOTEMPTY;
1048                                 goto badentry;
1049                         }
1050                         entry->d_inode->i_flags |= S_DEAD;
1051                 }
1052                 dont_mount(entry);
1053                 clear_nlink(entry->d_inode);
1054                 err = 0;
1055  badentry:
1056                 mutex_unlock(&entry->d_inode->i_mutex);
1057                 if (!err)
1058                         d_delete(entry);
1059         } else {
1060                 err = 0;
1061         }
1062         dput(entry);
1063
1064  unlock:
1065         mutex_unlock(&parent->i_mutex);
1066         iput(parent);
1067         return err;
1068 }
1069
1070 /*
1071  * Calling into a user-controlled filesystem gives the filesystem
1072  * daemon ptrace-like capabilities over the current process.  This
1073  * means, that the filesystem daemon is able to record the exact
1074  * filesystem operations performed, and can also control the behavior
1075  * of the requester process in otherwise impossible ways.  For example
1076  * it can delay the operation for arbitrary length of time allowing
1077  * DoS against the requester.
1078  *
1079  * For this reason only those processes can call into the filesystem,
1080  * for which the owner of the mount has ptrace privilege.  This
1081  * excludes processes started by other users, suid or sgid processes.
1082  */
1083 int fuse_allow_current_process(struct fuse_conn *fc)
1084 {
1085         const struct cred *cred;
1086
1087         if (fc->flags & FUSE_ALLOW_OTHER)
1088                 return 1;
1089
1090         cred = current_cred();
1091         if (uid_eq(cred->euid, fc->user_id) &&
1092             uid_eq(cred->suid, fc->user_id) &&
1093             uid_eq(cred->uid,  fc->user_id) &&
1094             gid_eq(cred->egid, fc->group_id) &&
1095             gid_eq(cred->sgid, fc->group_id) &&
1096             gid_eq(cred->gid,  fc->group_id))
1097                 return 1;
1098
1099         return 0;
1100 }
1101
1102 static int fuse_access(struct inode *inode, int mask)
1103 {
1104         struct fuse_conn *fc = get_fuse_conn(inode);
1105         struct fuse_req *req;
1106         struct fuse_access_in inarg;
1107         int err;
1108
1109         BUG_ON(mask & MAY_NOT_BLOCK);
1110
1111         if (fc->no_access)
1112                 return 0;
1113
1114         req = fuse_get_req_nopages(fc);
1115         if (IS_ERR(req))
1116                 return PTR_ERR(req);
1117
1118         memset(&inarg, 0, sizeof(inarg));
1119         inarg.mask = mask & (MAY_READ | MAY_WRITE | MAY_EXEC);
1120         req->in.h.opcode = FUSE_ACCESS;
1121         req->in.h.nodeid = get_node_id(inode);
1122         req->in.numargs = 1;
1123         req->in.args[0].size = sizeof(inarg);
1124         req->in.args[0].value = &inarg;
1125         fuse_request_send(fc, req);
1126         err = req->out.h.error;
1127         fuse_put_request(fc, req);
1128         if (err == -ENOSYS) {
1129                 fc->no_access = 1;
1130                 err = 0;
1131         }
1132         return err;
1133 }
1134
1135 static int fuse_perm_getattr(struct inode *inode, int mask)
1136 {
1137         if (mask & MAY_NOT_BLOCK)
1138                 return -ECHILD;
1139
1140         return fuse_do_getattr(inode, NULL, NULL);
1141 }
1142
1143 /*
1144  * Check permission.  The two basic access models of FUSE are:
1145  *
1146  * 1) Local access checking ('default_permissions' mount option) based
1147  * on file mode.  This is the plain old disk filesystem permission
1148  * modell.
1149  *
1150  * 2) "Remote" access checking, where server is responsible for
1151  * checking permission in each inode operation.  An exception to this
1152  * is if ->permission() was invoked from sys_access() in which case an
1153  * access request is sent.  Execute permission is still checked
1154  * locally based on file mode.
1155  */
1156 static int fuse_permission(struct inode *inode, int mask)
1157 {
1158         struct fuse_conn *fc = get_fuse_conn(inode);
1159         bool refreshed = false;
1160         int err = 0;
1161
1162         if (!fuse_allow_current_process(fc))
1163                 return -EACCES;
1164
1165         /*
1166          * If attributes are needed, refresh them before proceeding
1167          */
1168         if ((fc->flags & FUSE_DEFAULT_PERMISSIONS) ||
1169             ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
1170                 struct fuse_inode *fi = get_fuse_inode(inode);
1171
1172                 if (time_before64(fi->i_time, get_jiffies_64())) {
1173                         refreshed = true;
1174
1175                         err = fuse_perm_getattr(inode, mask);
1176                         if (err)
1177                                 return err;
1178                 }
1179         }
1180
1181         if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
1182                 err = generic_permission(inode, mask);
1183
1184                 /* If permission is denied, try to refresh file
1185                    attributes.  This is also needed, because the root
1186                    node will at first have no permissions */
1187                 if (err == -EACCES && !refreshed) {
1188                         err = fuse_perm_getattr(inode, mask);
1189                         if (!err)
1190                                 err = generic_permission(inode, mask);
1191                 }
1192
1193                 /* Note: the opposite of the above test does not
1194                    exist.  So if permissions are revoked this won't be
1195                    noticed immediately, only after the attribute
1196                    timeout has expired */
1197         } else if (mask & (MAY_ACCESS | MAY_CHDIR)) {
1198                 err = fuse_access(inode, mask);
1199         } else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
1200                 if (!(inode->i_mode & S_IXUGO)) {
1201                         if (refreshed)
1202                                 return -EACCES;
1203
1204                         err = fuse_perm_getattr(inode, mask);
1205                         if (!err && !(inode->i_mode & S_IXUGO))
1206                                 return -EACCES;
1207                 }
1208         }
1209         return err;
1210 }
1211
1212 static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
1213                          struct dir_context *ctx)
1214 {
1215         while (nbytes >= FUSE_NAME_OFFSET) {
1216                 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
1217                 size_t reclen = FUSE_DIRENT_SIZE(dirent);
1218                 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1219                         return -EIO;
1220                 if (reclen > nbytes)
1221                         break;
1222                 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
1223                         return -EIO;
1224
1225                 if (!dir_emit(ctx, dirent->name, dirent->namelen,
1226                                dirent->ino, dirent->type))
1227                         break;
1228
1229                 buf += reclen;
1230                 nbytes -= reclen;
1231                 ctx->pos = dirent->off;
1232         }
1233
1234         return 0;
1235 }
1236
1237 static int fuse_direntplus_link(struct file *file,
1238                                 struct fuse_direntplus *direntplus,
1239                                 u64 attr_version)
1240 {
1241         int err;
1242         struct fuse_entry_out *o = &direntplus->entry_out;
1243         struct fuse_dirent *dirent = &direntplus->dirent;
1244         struct dentry *parent = file->f_path.dentry;
1245         struct qstr name = QSTR_INIT(dirent->name, dirent->namelen);
1246         struct dentry *dentry;
1247         struct dentry *alias;
1248         struct inode *dir = parent->d_inode;
1249         struct fuse_conn *fc;
1250         struct inode *inode;
1251
1252         if (!o->nodeid) {
1253                 /*
1254                  * Unlike in the case of fuse_lookup, zero nodeid does not mean
1255                  * ENOENT. Instead, it only means the userspace filesystem did
1256                  * not want to return attributes/handle for this entry.
1257                  *
1258                  * So do nothing.
1259                  */
1260                 return 0;
1261         }
1262
1263         if (name.name[0] == '.') {
1264                 /*
1265                  * We could potentially refresh the attributes of the directory
1266                  * and its parent?
1267                  */
1268                 if (name.len == 1)
1269                         return 0;
1270                 if (name.name[1] == '.' && name.len == 2)
1271                         return 0;
1272         }
1273
1274         if (invalid_nodeid(o->nodeid))
1275                 return -EIO;
1276         if (!fuse_valid_type(o->attr.mode))
1277                 return -EIO;
1278
1279         fc = get_fuse_conn(dir);
1280
1281         name.hash = full_name_hash(name.name, name.len);
1282         dentry = d_lookup(parent, &name);
1283         if (dentry) {
1284                 inode = dentry->d_inode;
1285                 if (!inode) {
1286                         d_drop(dentry);
1287                 } else if (get_node_id(inode) != o->nodeid ||
1288                            ((o->attr.mode ^ inode->i_mode) & S_IFMT)) {
1289                         d_invalidate(dentry);
1290                 } else if (is_bad_inode(inode)) {
1291                         err = -EIO;
1292                         goto out;
1293                 } else {
1294                         struct fuse_inode *fi;
1295                         fi = get_fuse_inode(inode);
1296                         spin_lock(&fc->lock);
1297                         fi->nlookup++;
1298                         spin_unlock(&fc->lock);
1299
1300                         fuse_change_attributes(inode, &o->attr,
1301                                                entry_attr_timeout(o),
1302                                                attr_version);
1303
1304                         /*
1305                          * The other branch to 'found' comes via fuse_iget()
1306                          * which bumps nlookup inside
1307                          */
1308                         goto found;
1309                 }
1310                 dput(dentry);
1311         }
1312
1313         dentry = d_alloc(parent, &name);
1314         err = -ENOMEM;
1315         if (!dentry)
1316                 goto out;
1317
1318         inode = fuse_iget(dir->i_sb, o->nodeid, o->generation,
1319                           &o->attr, entry_attr_timeout(o), attr_version);
1320         if (!inode)
1321                 goto out;
1322
1323         alias = d_materialise_unique(dentry, inode);
1324         err = PTR_ERR(alias);
1325         if (IS_ERR(alias))
1326                 goto out;
1327
1328         if (alias) {
1329                 dput(dentry);
1330                 dentry = alias;
1331         }
1332
1333 found:
1334         if (fc->readdirplus_auto)
1335                 set_bit(FUSE_I_INIT_RDPLUS, &get_fuse_inode(inode)->state);
1336         fuse_change_entry_timeout(dentry, o);
1337
1338         err = 0;
1339 out:
1340         dput(dentry);
1341         return err;
1342 }
1343
1344 static int parse_dirplusfile(char *buf, size_t nbytes, struct file *file,
1345                              struct dir_context *ctx, u64 attr_version)
1346 {
1347         struct fuse_direntplus *direntplus;
1348         struct fuse_dirent *dirent;
1349         size_t reclen;
1350         int over = 0;
1351         int ret;
1352
1353         while (nbytes >= FUSE_NAME_OFFSET_DIRENTPLUS) {
1354                 direntplus = (struct fuse_direntplus *) buf;
1355                 dirent = &direntplus->dirent;
1356                 reclen = FUSE_DIRENTPLUS_SIZE(direntplus);
1357
1358                 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1359                         return -EIO;
1360                 if (reclen > nbytes)
1361                         break;
1362                 if (memchr(dirent->name, '/', dirent->namelen) != NULL)
1363                         return -EIO;
1364
1365                 if (!over) {
1366                         /* We fill entries into dstbuf only as much as
1367                            it can hold. But we still continue iterating
1368                            over remaining entries to link them. If not,
1369                            we need to send a FORGET for each of those
1370                            which we did not link.
1371                         */
1372                         over = !dir_emit(ctx, dirent->name, dirent->namelen,
1373                                        dirent->ino, dirent->type);
1374                         ctx->pos = dirent->off;
1375                 }
1376
1377                 buf += reclen;
1378                 nbytes -= reclen;
1379
1380                 ret = fuse_direntplus_link(file, direntplus, attr_version);
1381                 if (ret)
1382                         fuse_force_forget(file, direntplus->entry_out.nodeid);
1383         }
1384
1385         return 0;
1386 }
1387
1388 static int fuse_readdir(struct file *file, struct dir_context *ctx)
1389 {
1390         int plus, err;
1391         size_t nbytes;
1392         struct page *page;
1393         struct inode *inode = file_inode(file);
1394         struct fuse_conn *fc = get_fuse_conn(inode);
1395         struct fuse_req *req;
1396         u64 attr_version = 0;
1397
1398         if (is_bad_inode(inode))
1399                 return -EIO;
1400
1401         req = fuse_get_req(fc, 1);
1402         if (IS_ERR(req))
1403                 return PTR_ERR(req);
1404
1405         page = alloc_page(GFP_KERNEL);
1406         if (!page) {
1407                 fuse_put_request(fc, req);
1408                 return -ENOMEM;
1409         }
1410
1411         plus = fuse_use_readdirplus(inode, ctx);
1412         req->out.argpages = 1;
1413         req->num_pages = 1;
1414         req->pages[0] = page;
1415         req->page_descs[0].length = PAGE_SIZE;
1416         if (plus) {
1417                 attr_version = fuse_get_attr_version(fc);
1418                 fuse_read_fill(req, file, ctx->pos, PAGE_SIZE,
1419                                FUSE_READDIRPLUS);
1420         } else {
1421                 fuse_read_fill(req, file, ctx->pos, PAGE_SIZE,
1422                                FUSE_READDIR);
1423         }
1424         fuse_request_send(fc, req);
1425         nbytes = req->out.args[0].size;
1426         err = req->out.h.error;
1427         fuse_put_request(fc, req);
1428         if (!err) {
1429                 if (plus) {
1430                         err = parse_dirplusfile(page_address(page), nbytes,
1431                                                 file, ctx,
1432                                                 attr_version);
1433                 } else {
1434                         err = parse_dirfile(page_address(page), nbytes, file,
1435                                             ctx);
1436                 }
1437         }
1438
1439         __free_page(page);
1440         fuse_invalidate_atime(inode);
1441         return err;
1442 }
1443
1444 static char *read_link(struct dentry *dentry)
1445 {
1446         struct inode *inode = dentry->d_inode;
1447         struct fuse_conn *fc = get_fuse_conn(inode);
1448         struct fuse_req *req = fuse_get_req_nopages(fc);
1449         char *link;
1450
1451         if (IS_ERR(req))
1452                 return ERR_CAST(req);
1453
1454         link = (char *) __get_free_page(GFP_KERNEL);
1455         if (!link) {
1456                 link = ERR_PTR(-ENOMEM);
1457                 goto out;
1458         }
1459         req->in.h.opcode = FUSE_READLINK;
1460         req->in.h.nodeid = get_node_id(inode);
1461         req->out.argvar = 1;
1462         req->out.numargs = 1;
1463         req->out.args[0].size = PAGE_SIZE - 1;
1464         req->out.args[0].value = link;
1465         fuse_request_send(fc, req);
1466         if (req->out.h.error) {
1467                 free_page((unsigned long) link);
1468                 link = ERR_PTR(req->out.h.error);
1469         } else
1470                 link[req->out.args[0].size] = '\0';
1471  out:
1472         fuse_put_request(fc, req);
1473         fuse_invalidate_atime(inode);
1474         return link;
1475 }
1476
1477 static void free_link(char *link)
1478 {
1479         if (!IS_ERR(link))
1480                 free_page((unsigned long) link);
1481 }
1482
1483 static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
1484 {
1485         nd_set_link(nd, read_link(dentry));
1486         return NULL;
1487 }
1488
1489 static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
1490 {
1491         free_link(nd_get_link(nd));
1492 }
1493
1494 static int fuse_dir_open(struct inode *inode, struct file *file)
1495 {
1496         return fuse_open_common(inode, file, true);
1497 }
1498
1499 static int fuse_dir_release(struct inode *inode, struct file *file)
1500 {
1501         fuse_release_common(file, FUSE_RELEASEDIR);
1502
1503         return 0;
1504 }
1505
1506 static int fuse_dir_fsync(struct file *file, loff_t start, loff_t end,
1507                           int datasync)
1508 {
1509         return fuse_fsync_common(file, start, end, datasync, 1);
1510 }
1511
1512 static long fuse_dir_ioctl(struct file *file, unsigned int cmd,
1513                             unsigned long arg)
1514 {
1515         struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1516
1517         /* FUSE_IOCTL_DIR only supported for API version >= 7.18 */
1518         if (fc->minor < 18)
1519                 return -ENOTTY;
1520
1521         return fuse_ioctl_common(file, cmd, arg, FUSE_IOCTL_DIR);
1522 }
1523
1524 static long fuse_dir_compat_ioctl(struct file *file, unsigned int cmd,
1525                                    unsigned long arg)
1526 {
1527         struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1528
1529         if (fc->minor < 18)
1530                 return -ENOTTY;
1531
1532         return fuse_ioctl_common(file, cmd, arg,
1533                                  FUSE_IOCTL_COMPAT | FUSE_IOCTL_DIR);
1534 }
1535
1536 static bool update_mtime(unsigned ivalid, bool trust_local_mtime)
1537 {
1538         /* Always update if mtime is explicitly set  */
1539         if (ivalid & ATTR_MTIME_SET)
1540                 return true;
1541
1542         /* Or if kernel i_mtime is the official one */
1543         if (trust_local_mtime)
1544                 return true;
1545
1546         /* If it's an open(O_TRUNC) or an ftruncate(), don't update */
1547         if ((ivalid & ATTR_SIZE) && (ivalid & (ATTR_OPEN | ATTR_FILE)))
1548                 return false;
1549
1550         /* In all other cases update */
1551         return true;
1552 }
1553
1554 static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg,
1555                            bool trust_local_cmtime)
1556 {
1557         unsigned ivalid = iattr->ia_valid;
1558
1559         if (ivalid & ATTR_MODE)
1560                 arg->valid |= FATTR_MODE,   arg->mode = iattr->ia_mode;
1561         if (ivalid & ATTR_UID)
1562                 arg->valid |= FATTR_UID,    arg->uid = from_kuid(&init_user_ns, iattr->ia_uid);
1563         if (ivalid & ATTR_GID)
1564                 arg->valid |= FATTR_GID,    arg->gid = from_kgid(&init_user_ns, iattr->ia_gid);
1565         if (ivalid & ATTR_SIZE)
1566                 arg->valid |= FATTR_SIZE,   arg->size = iattr->ia_size;
1567         if (ivalid & ATTR_ATIME) {
1568                 arg->valid |= FATTR_ATIME;
1569                 arg->atime = iattr->ia_atime.tv_sec;
1570                 arg->atimensec = iattr->ia_atime.tv_nsec;
1571                 if (!(ivalid & ATTR_ATIME_SET))
1572                         arg->valid |= FATTR_ATIME_NOW;
1573         }
1574         if ((ivalid & ATTR_MTIME) && update_mtime(ivalid, trust_local_cmtime)) {
1575                 arg->valid |= FATTR_MTIME;
1576                 arg->mtime = iattr->ia_mtime.tv_sec;
1577                 arg->mtimensec = iattr->ia_mtime.tv_nsec;
1578                 if (!(ivalid & ATTR_MTIME_SET) && !trust_local_cmtime)
1579                         arg->valid |= FATTR_MTIME_NOW;
1580         }
1581         if ((ivalid & ATTR_CTIME) && trust_local_cmtime) {
1582                 arg->valid |= FATTR_CTIME;
1583                 arg->ctime = iattr->ia_ctime.tv_sec;
1584                 arg->ctimensec = iattr->ia_ctime.tv_nsec;
1585         }
1586 }
1587
1588 /*
1589  * Prevent concurrent writepages on inode
1590  *
1591  * This is done by adding a negative bias to the inode write counter
1592  * and waiting for all pending writes to finish.
1593  */
1594 void fuse_set_nowrite(struct inode *inode)
1595 {
1596         struct fuse_conn *fc = get_fuse_conn(inode);
1597         struct fuse_inode *fi = get_fuse_inode(inode);
1598
1599         BUG_ON(!mutex_is_locked(&inode->i_mutex));
1600
1601         spin_lock(&fc->lock);
1602         BUG_ON(fi->writectr < 0);
1603         fi->writectr += FUSE_NOWRITE;
1604         spin_unlock(&fc->lock);
1605         wait_event(fi->page_waitq, fi->writectr == FUSE_NOWRITE);
1606 }
1607
1608 /*
1609  * Allow writepages on inode
1610  *
1611  * Remove the bias from the writecounter and send any queued
1612  * writepages.
1613  */
1614 static void __fuse_release_nowrite(struct inode *inode)
1615 {
1616         struct fuse_inode *fi = get_fuse_inode(inode);
1617
1618         BUG_ON(fi->writectr != FUSE_NOWRITE);
1619         fi->writectr = 0;
1620         fuse_flush_writepages(inode);
1621 }
1622
1623 void fuse_release_nowrite(struct inode *inode)
1624 {
1625         struct fuse_conn *fc = get_fuse_conn(inode);
1626
1627         spin_lock(&fc->lock);
1628         __fuse_release_nowrite(inode);
1629         spin_unlock(&fc->lock);
1630 }
1631
1632 static void fuse_setattr_fill(struct fuse_conn *fc, struct fuse_req *req,
1633                               struct inode *inode,
1634                               struct fuse_setattr_in *inarg_p,
1635                               struct fuse_attr_out *outarg_p)
1636 {
1637         req->in.h.opcode = FUSE_SETATTR;
1638         req->in.h.nodeid = get_node_id(inode);
1639         req->in.numargs = 1;
1640         req->in.args[0].size = sizeof(*inarg_p);
1641         req->in.args[0].value = inarg_p;
1642         req->out.numargs = 1;
1643         if (fc->minor < 9)
1644                 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
1645         else
1646                 req->out.args[0].size = sizeof(*outarg_p);
1647         req->out.args[0].value = outarg_p;
1648 }
1649
1650 /*
1651  * Flush inode->i_mtime to the server
1652  */
1653 int fuse_flush_times(struct inode *inode, struct fuse_file *ff)
1654 {
1655         struct fuse_conn *fc = get_fuse_conn(inode);
1656         struct fuse_req *req;
1657         struct fuse_setattr_in inarg;
1658         struct fuse_attr_out outarg;
1659         int err;
1660
1661         req = fuse_get_req_nopages(fc);
1662         if (IS_ERR(req))
1663                 return PTR_ERR(req);
1664
1665         memset(&inarg, 0, sizeof(inarg));
1666         memset(&outarg, 0, sizeof(outarg));
1667
1668         inarg.valid = FATTR_MTIME;
1669         inarg.mtime = inode->i_mtime.tv_sec;
1670         inarg.mtimensec = inode->i_mtime.tv_nsec;
1671         if (fc->minor >= 23) {
1672                 inarg.valid |= FATTR_CTIME;
1673                 inarg.ctime = inode->i_ctime.tv_sec;
1674                 inarg.ctimensec = inode->i_ctime.tv_nsec;
1675         }
1676         if (ff) {
1677                 inarg.valid |= FATTR_FH;
1678                 inarg.fh = ff->fh;
1679         }
1680         fuse_setattr_fill(fc, req, inode, &inarg, &outarg);
1681         fuse_request_send(fc, req);
1682         err = req->out.h.error;
1683         fuse_put_request(fc, req);
1684
1685         return err;
1686 }
1687
1688 /*
1689  * Set attributes, and at the same time refresh them.
1690  *
1691  * Truncation is slightly complicated, because the 'truncate' request
1692  * may fail, in which case we don't want to touch the mapping.
1693  * vmtruncate() doesn't allow for this case, so do the rlimit checking
1694  * and the actual truncation by hand.
1695  */
1696 int fuse_do_setattr(struct inode *inode, struct iattr *attr,
1697                     struct file *file)
1698 {
1699         struct fuse_conn *fc = get_fuse_conn(inode);
1700         struct fuse_inode *fi = get_fuse_inode(inode);
1701         struct fuse_req *req;
1702         struct fuse_setattr_in inarg;
1703         struct fuse_attr_out outarg;
1704         bool is_truncate = false;
1705         bool is_wb = fc->writeback_cache;
1706         loff_t oldsize;
1707         int err;
1708         bool trust_local_cmtime = is_wb && S_ISREG(inode->i_mode);
1709
1710         if (!(fc->flags & FUSE_DEFAULT_PERMISSIONS))
1711                 attr->ia_valid |= ATTR_FORCE;
1712
1713         err = inode_change_ok(inode, attr);
1714         if (err)
1715                 return err;
1716
1717         if (attr->ia_valid & ATTR_OPEN) {
1718                 if (fc->atomic_o_trunc)
1719                         return 0;
1720                 file = NULL;
1721         }
1722
1723         if (attr->ia_valid & ATTR_SIZE)
1724                 is_truncate = true;
1725
1726         req = fuse_get_req_nopages(fc);
1727         if (IS_ERR(req))
1728                 return PTR_ERR(req);
1729
1730         if (is_truncate) {
1731                 fuse_set_nowrite(inode);
1732                 set_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1733                 if (trust_local_cmtime && attr->ia_size != inode->i_size)
1734                         attr->ia_valid |= ATTR_MTIME | ATTR_CTIME;
1735         }
1736
1737         memset(&inarg, 0, sizeof(inarg));
1738         memset(&outarg, 0, sizeof(outarg));
1739         iattr_to_fattr(attr, &inarg, trust_local_cmtime);
1740         if (file) {
1741                 struct fuse_file *ff = file->private_data;
1742                 inarg.valid |= FATTR_FH;
1743                 inarg.fh = ff->fh;
1744         }
1745         if (attr->ia_valid & ATTR_SIZE) {
1746                 /* For mandatory locking in truncate */
1747                 inarg.valid |= FATTR_LOCKOWNER;
1748                 inarg.lock_owner = fuse_lock_owner_id(fc, current->files);
1749         }
1750         fuse_setattr_fill(fc, req, inode, &inarg, &outarg);
1751         fuse_request_send(fc, req);
1752         err = req->out.h.error;
1753         fuse_put_request(fc, req);
1754         if (err) {
1755                 if (err == -EINTR)
1756                         fuse_invalidate_attr(inode);
1757                 goto error;
1758         }
1759
1760         if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
1761                 make_bad_inode(inode);
1762                 err = -EIO;
1763                 goto error;
1764         }
1765
1766         spin_lock(&fc->lock);
1767         /* the kernel maintains i_mtime locally */
1768         if (trust_local_cmtime) {
1769                 if (attr->ia_valid & ATTR_MTIME)
1770                         inode->i_mtime = attr->ia_mtime;
1771                 if (attr->ia_valid & ATTR_CTIME)
1772                         inode->i_ctime = attr->ia_ctime;
1773                 /* FIXME: clear I_DIRTY_SYNC? */
1774         }
1775
1776         fuse_change_attributes_common(inode, &outarg.attr,
1777                                       attr_timeout(&outarg));
1778         oldsize = inode->i_size;
1779         /* see the comment in fuse_change_attributes() */
1780         if (!is_wb || is_truncate || !S_ISREG(inode->i_mode))
1781                 i_size_write(inode, outarg.attr.size);
1782
1783         if (is_truncate) {
1784                 /* NOTE: this may release/reacquire fc->lock */
1785                 __fuse_release_nowrite(inode);
1786         }
1787         spin_unlock(&fc->lock);
1788
1789         /*
1790          * Only call invalidate_inode_pages2() after removing
1791          * FUSE_NOWRITE, otherwise fuse_launder_page() would deadlock.
1792          */
1793         if ((is_truncate || !is_wb) &&
1794             S_ISREG(inode->i_mode) && oldsize != outarg.attr.size) {
1795                 truncate_pagecache(inode, outarg.attr.size);
1796                 invalidate_inode_pages2(inode->i_mapping);
1797         }
1798
1799         clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1800         return 0;
1801
1802 error:
1803         if (is_truncate)
1804                 fuse_release_nowrite(inode);
1805
1806         clear_bit(FUSE_I_SIZE_UNSTABLE, &fi->state);
1807         return err;
1808 }
1809
1810 static int fuse_setattr(struct dentry *entry, struct iattr *attr)
1811 {
1812         struct inode *inode = entry->d_inode;
1813
1814         if (!fuse_allow_current_process(get_fuse_conn(inode)))
1815                 return -EACCES;
1816
1817         if (attr->ia_valid & ATTR_FILE)
1818                 return fuse_do_setattr(inode, attr, attr->ia_file);
1819         else
1820                 return fuse_do_setattr(inode, attr, NULL);
1821 }
1822
1823 static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
1824                         struct kstat *stat)
1825 {
1826         struct inode *inode = entry->d_inode;
1827         struct fuse_conn *fc = get_fuse_conn(inode);
1828
1829         if (!fuse_allow_current_process(fc))
1830                 return -EACCES;
1831
1832         return fuse_update_attributes(inode, stat, NULL, NULL);
1833 }
1834
1835 static int fuse_setxattr(struct dentry *entry, const char *name,
1836                          const void *value, size_t size, int flags)
1837 {
1838         struct inode *inode = entry->d_inode;
1839         struct fuse_conn *fc = get_fuse_conn(inode);
1840         struct fuse_req *req;
1841         struct fuse_setxattr_in inarg;
1842         int err;
1843
1844         if (fc->no_setxattr)
1845                 return -EOPNOTSUPP;
1846
1847         req = fuse_get_req_nopages(fc);
1848         if (IS_ERR(req))
1849                 return PTR_ERR(req);
1850
1851         memset(&inarg, 0, sizeof(inarg));
1852         inarg.size = size;
1853         inarg.flags = flags;
1854         req->in.h.opcode = FUSE_SETXATTR;
1855         req->in.h.nodeid = get_node_id(inode);
1856         req->in.numargs = 3;
1857         req->in.args[0].size = sizeof(inarg);
1858         req->in.args[0].value = &inarg;
1859         req->in.args[1].size = strlen(name) + 1;
1860         req->in.args[1].value = name;
1861         req->in.args[2].size = size;
1862         req->in.args[2].value = value;
1863         fuse_request_send(fc, req);
1864         err = req->out.h.error;
1865         fuse_put_request(fc, req);
1866         if (err == -ENOSYS) {
1867                 fc->no_setxattr = 1;
1868                 err = -EOPNOTSUPP;
1869         }
1870         if (!err) {
1871                 fuse_invalidate_attr(inode);
1872                 fuse_update_ctime(inode);
1873         }
1874         return err;
1875 }
1876
1877 static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
1878                              void *value, size_t size)
1879 {
1880         struct inode *inode = entry->d_inode;
1881         struct fuse_conn *fc = get_fuse_conn(inode);
1882         struct fuse_req *req;
1883         struct fuse_getxattr_in inarg;
1884         struct fuse_getxattr_out outarg;
1885         ssize_t ret;
1886
1887         if (fc->no_getxattr)
1888                 return -EOPNOTSUPP;
1889
1890         req = fuse_get_req_nopages(fc);
1891         if (IS_ERR(req))
1892                 return PTR_ERR(req);
1893
1894         memset(&inarg, 0, sizeof(inarg));
1895         inarg.size = size;
1896         req->in.h.opcode = FUSE_GETXATTR;
1897         req->in.h.nodeid = get_node_id(inode);
1898         req->in.numargs = 2;
1899         req->in.args[0].size = sizeof(inarg);
1900         req->in.args[0].value = &inarg;
1901         req->in.args[1].size = strlen(name) + 1;
1902         req->in.args[1].value = name;
1903         /* This is really two different operations rolled into one */
1904         req->out.numargs = 1;
1905         if (size) {
1906                 req->out.argvar = 1;
1907                 req->out.args[0].size = size;
1908                 req->out.args[0].value = value;
1909         } else {
1910                 req->out.args[0].size = sizeof(outarg);
1911                 req->out.args[0].value = &outarg;
1912         }
1913         fuse_request_send(fc, req);
1914         ret = req->out.h.error;
1915         if (!ret)
1916                 ret = size ? req->out.args[0].size : outarg.size;
1917         else {
1918                 if (ret == -ENOSYS) {
1919                         fc->no_getxattr = 1;
1920                         ret = -EOPNOTSUPP;
1921                 }
1922         }
1923         fuse_put_request(fc, req);
1924         return ret;
1925 }
1926
1927 static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
1928 {
1929         struct inode *inode = entry->d_inode;
1930         struct fuse_conn *fc = get_fuse_conn(inode);
1931         struct fuse_req *req;
1932         struct fuse_getxattr_in inarg;
1933         struct fuse_getxattr_out outarg;
1934         ssize_t ret;
1935
1936         if (!fuse_allow_current_process(fc))
1937                 return -EACCES;
1938
1939         if (fc->no_listxattr)
1940                 return -EOPNOTSUPP;
1941
1942         req = fuse_get_req_nopages(fc);
1943         if (IS_ERR(req))
1944                 return PTR_ERR(req);
1945
1946         memset(&inarg, 0, sizeof(inarg));
1947         inarg.size = size;
1948         req->in.h.opcode = FUSE_LISTXATTR;
1949         req->in.h.nodeid = get_node_id(inode);
1950         req->in.numargs = 1;
1951         req->in.args[0].size = sizeof(inarg);
1952         req->in.args[0].value = &inarg;
1953         /* This is really two different operations rolled into one */
1954         req->out.numargs = 1;
1955         if (size) {
1956                 req->out.argvar = 1;
1957                 req->out.args[0].size = size;
1958                 req->out.args[0].value = list;
1959         } else {
1960                 req->out.args[0].size = sizeof(outarg);
1961                 req->out.args[0].value = &outarg;
1962         }
1963         fuse_request_send(fc, req);
1964         ret = req->out.h.error;
1965         if (!ret)
1966                 ret = size ? req->out.args[0].size : outarg.size;
1967         else {
1968                 if (ret == -ENOSYS) {
1969                         fc->no_listxattr = 1;
1970                         ret = -EOPNOTSUPP;
1971                 }
1972         }
1973         fuse_put_request(fc, req);
1974         return ret;
1975 }
1976
1977 static int fuse_removexattr(struct dentry *entry, const char *name)
1978 {
1979         struct inode *inode = entry->d_inode;
1980         struct fuse_conn *fc = get_fuse_conn(inode);
1981         struct fuse_req *req;
1982         int err;
1983
1984         if (fc->no_removexattr)
1985                 return -EOPNOTSUPP;
1986
1987         req = fuse_get_req_nopages(fc);
1988         if (IS_ERR(req))
1989                 return PTR_ERR(req);
1990
1991         req->in.h.opcode = FUSE_REMOVEXATTR;
1992         req->in.h.nodeid = get_node_id(inode);
1993         req->in.numargs = 1;
1994         req->in.args[0].size = strlen(name) + 1;
1995         req->in.args[0].value = name;
1996         fuse_request_send(fc, req);
1997         err = req->out.h.error;
1998         fuse_put_request(fc, req);
1999         if (err == -ENOSYS) {
2000                 fc->no_removexattr = 1;
2001                 err = -EOPNOTSUPP;
2002         }
2003         if (!err) {
2004                 fuse_invalidate_attr(inode);
2005                 fuse_update_ctime(inode);
2006         }
2007         return err;
2008 }
2009
2010 static const struct inode_operations fuse_dir_inode_operations = {
2011         .lookup         = fuse_lookup,
2012         .mkdir          = fuse_mkdir,
2013         .symlink        = fuse_symlink,
2014         .unlink         = fuse_unlink,
2015         .rmdir          = fuse_rmdir,
2016         .rename2        = fuse_rename2,
2017         .link           = fuse_link,
2018         .setattr        = fuse_setattr,
2019         .create         = fuse_create,
2020         .atomic_open    = fuse_atomic_open,
2021         .mknod          = fuse_mknod,
2022         .permission     = fuse_permission,
2023         .getattr        = fuse_getattr,
2024         .setxattr       = fuse_setxattr,
2025         .getxattr       = fuse_getxattr,
2026         .listxattr      = fuse_listxattr,
2027         .removexattr    = fuse_removexattr,
2028 };
2029
2030 static const struct file_operations fuse_dir_operations = {
2031         .llseek         = generic_file_llseek,
2032         .read           = generic_read_dir,
2033         .iterate        = fuse_readdir,
2034         .open           = fuse_dir_open,
2035         .release        = fuse_dir_release,
2036         .fsync          = fuse_dir_fsync,
2037         .unlocked_ioctl = fuse_dir_ioctl,
2038         .compat_ioctl   = fuse_dir_compat_ioctl,
2039 };
2040
2041 static const struct inode_operations fuse_common_inode_operations = {
2042         .setattr        = fuse_setattr,
2043         .permission     = fuse_permission,
2044         .getattr        = fuse_getattr,
2045         .setxattr       = fuse_setxattr,
2046         .getxattr       = fuse_getxattr,
2047         .listxattr      = fuse_listxattr,
2048         .removexattr    = fuse_removexattr,
2049 };
2050
2051 static const struct inode_operations fuse_symlink_inode_operations = {
2052         .setattr        = fuse_setattr,
2053         .follow_link    = fuse_follow_link,
2054         .put_link       = fuse_put_link,
2055         .readlink       = generic_readlink,
2056         .getattr        = fuse_getattr,
2057         .setxattr       = fuse_setxattr,
2058         .getxattr       = fuse_getxattr,
2059         .listxattr      = fuse_listxattr,
2060         .removexattr    = fuse_removexattr,
2061 };
2062
2063 void fuse_init_common(struct inode *inode)
2064 {
2065         inode->i_op = &fuse_common_inode_operations;
2066 }
2067
2068 void fuse_init_dir(struct inode *inode)
2069 {
2070         inode->i_op = &fuse_dir_inode_operations;
2071         inode->i_fop = &fuse_dir_operations;
2072 }
2073
2074 void fuse_init_symlink(struct inode *inode)
2075 {
2076         inode->i_op = &fuse_symlink_inode_operations;
2077 }