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