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