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