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