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