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