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