Pileus Git - ~andy/linux/blob - 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         unsigned int blkbits;
 779
 780         stat->dev = inode->i_sb->s_dev;
 781         stat->ino = attr->ino;
 782         stat->mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
 783         stat->nlink = attr->nlink;
 784         stat->uid = attr->uid;
 785         stat->gid = attr->gid;
 786         stat->rdev = inode->i_rdev;
 787         stat->atime.tv_sec = attr->atime;
 788         stat->atime.tv_nsec = attr->atimensec;
 789         stat->mtime.tv_sec = attr->mtime;
 790         stat->mtime.tv_nsec = attr->mtimensec;
 791         stat->ctime.tv_sec = attr->ctime;
 792         stat->ctime.tv_nsec = attr->ctimensec;
 793         stat->size = attr->size;
 794         stat->blocks = attr->blocks;
 795
 796         if (attr->blksize != 0)
 797                 blkbits = ilog2(attr->blksize);
 798         else
 799                 blkbits = inode->i_sb->s_blocksize_bits;
 800
 801         stat->blksize = 1 << blkbits;
 802 }
 803
 804 static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
 805                            struct file *file)
 806 {
 807         int err;
 808         struct fuse_getattr_in inarg;
 809         struct fuse_attr_out outarg;
 810         struct fuse_conn *fc = get_fuse_conn(inode);
 811         struct fuse_req *req;
 812         u64 attr_version;
 813
 814         req = fuse_get_req(fc);
 815         if (IS_ERR(req))
 816                 return PTR_ERR(req);
 817
 818         attr_version = fuse_get_attr_version(fc);
 819
 820         memset(&inarg, 0, sizeof(inarg));
 821         memset(&outarg, 0, sizeof(outarg));
 822         /* Directories have separate file-handle space */
 823         if (file && S_ISREG(inode->i_mode)) {
 824                 struct fuse_file *ff = file->private_data;
 825
 826                 inarg.getattr_flags |= FUSE_GETATTR_FH;
 827                 inarg.fh = ff->fh;
 828         }
 829         req->in.h.opcode = FUSE_GETATTR;
 830         req->in.h.nodeid = get_node_id(inode);
 831         req->in.numargs = 1;
 832         req->in.args[0].size = sizeof(inarg);
 833         req->in.args[0].value = &inarg;
 834         req->out.numargs = 1;
 835         if (fc->minor < 9)
 836                 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
 837         else
 838                 req->out.args[0].size = sizeof(outarg);
 839         req->out.args[0].value = &outarg;
 840         fuse_request_send(fc, req);
 841         err = req->out.h.error;
 842         fuse_put_request(fc, req);
 843         if (!err) {
 844                 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
 845                         make_bad_inode(inode);
 846                         err = -EIO;
 847                 } else {
 848                         fuse_change_attributes(inode, &outarg.attr,
 849                                                attr_timeout(&outarg),
 850                                                attr_version);
 851                         if (stat)
 852                                 fuse_fillattr(inode, &outarg.attr, stat);
 853                 }
 854         }
 855         return err;
 856 }
 857
 858 int fuse_update_attributes(struct inode *inode, struct kstat *stat,
 859                            struct file *file, bool *refreshed)
 860 {
 861         struct fuse_inode *fi = get_fuse_inode(inode);
 862         int err;
 863         bool r;
 864
 865         if (fi->i_time < get_jiffies_64()) {
 866                 r = true;
 867                 err = fuse_do_getattr(inode, stat, file);
 868         } else {
 869                 r = false;
 870                 err = 0;
 871                 if (stat) {
 872                         generic_fillattr(inode, stat);
 873                         stat->mode = fi->orig_i_mode;
 874                         stat->ino = fi->orig_ino;
 875                 }
 876         }
 877
 878         if (refreshed != NULL)
 879                 *refreshed = r;
 880
 881         return err;
 882 }
 883
 884 int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
 885                              u64 child_nodeid, struct qstr *name)
 886 {
 887         int err = -ENOTDIR;
 888         struct inode *parent;
 889         struct dentry *dir;
 890         struct dentry *entry;
 891
 892         parent = ilookup5(sb, parent_nodeid, fuse_inode_eq, &parent_nodeid);
 893         if (!parent)
 894                 return -ENOENT;
 895
 896         mutex_lock(&parent->i_mutex);
 897         if (!S_ISDIR(parent->i_mode))
 898                 goto unlock;
 899
 900         err = -ENOENT;
 901         dir = d_find_alias(parent);
 902         if (!dir)
 903                 goto unlock;
 904
 905         entry = d_lookup(dir, name);
 906         dput(dir);
 907         if (!entry)
 908                 goto unlock;
 909
 910         fuse_invalidate_attr(parent);
 911         fuse_invalidate_entry(entry);
 912
 913         if (child_nodeid != 0 && entry->d_inode) {
 914                 mutex_lock(&entry->d_inode->i_mutex);
 915                 if (get_node_id(entry->d_inode) != child_nodeid) {
 916                         err = -ENOENT;
 917                         goto badentry;
 918                 }
 919                 if (d_mountpoint(entry)) {
 920                         err = -EBUSY;
 921                         goto badentry;
 922                 }
 923                 if (S_ISDIR(entry->d_inode->i_mode)) {
 924                         shrink_dcache_parent(entry);
 925                         if (!simple_empty(entry)) {
 926                                 err = -ENOTEMPTY;
 927                                 goto badentry;
 928                         }
 929                         entry->d_inode->i_flags |= S_DEAD;
 930                 }
 931                 dont_mount(entry);
 932                 clear_nlink(entry->d_inode);
 933                 err = 0;
 934  badentry:
 935                 mutex_unlock(&entry->d_inode->i_mutex);
 936                 if (!err)
 937                         d_delete(entry);
 938         } else {
 939                 err = 0;
 940         }
 941         dput(entry);
 942
 943  unlock:
 944         mutex_unlock(&parent->i_mutex);
 945         iput(parent);
 946         return err;
 947 }
 948
 949 /*
 950  * Calling into a user-controlled filesystem gives the filesystem
 951  * daemon ptrace-like capabilities over the requester process.  This
 952  * means, that the filesystem daemon is able to record the exact
 953  * filesystem operations performed, and can also control the behavior
 954  * of the requester process in otherwise impossible ways.  For example
 955  * it can delay the operation for arbitrary length of time allowing
 956  * DoS against the requester.
 957  *
 958  * For this reason only those processes can call into the filesystem,
 959  * for which the owner of the mount has ptrace privilege.  This
 960  * excludes processes started by other users, suid or sgid processes.
 961  */
 962 int fuse_allow_task(struct fuse_conn *fc, struct task_struct *task)
 963 {
 964         const struct cred *cred;
 965         int ret;
 966
 967         if (fc->flags & FUSE_ALLOW_OTHER)
 968                 return 1;
 969
 970         rcu_read_lock();
 971         ret = 0;
 972         cred = __task_cred(task);
 973         if (cred->euid == fc->user_id &&
 974             cred->suid == fc->user_id &&
 975             cred->uid  == fc->user_id &&
 976             cred->egid == fc->group_id &&
 977             cred->sgid == fc->group_id &&
 978             cred->gid  == fc->group_id)
 979                 ret = 1;
 980         rcu_read_unlock();
 981
 982         return ret;
 983 }
 984
 985 static int fuse_access(struct inode *inode, int mask)
 986 {
 987         struct fuse_conn *fc = get_fuse_conn(inode);
 988         struct fuse_req *req;
 989         struct fuse_access_in inarg;
 990         int err;
 991
 992         if (fc->no_access)
 993                 return 0;
 994
 995         req = fuse_get_req(fc);
 996         if (IS_ERR(req))
 997                 return PTR_ERR(req);
 998
 999         memset(&inarg, 0, sizeof(inarg));
1000         inarg.mask = mask & (MAY_READ | MAY_WRITE | MAY_EXEC);
1001         req->in.h.opcode = FUSE_ACCESS;
1002         req->in.h.nodeid = get_node_id(inode);
1003         req->in.numargs = 1;
1004         req->in.args[0].size = sizeof(inarg);
1005         req->in.args[0].value = &inarg;
1006         fuse_request_send(fc, req);
1007         err = req->out.h.error;
1008         fuse_put_request(fc, req);
1009         if (err == -ENOSYS) {
1010                 fc->no_access = 1;
1011                 err = 0;
1012         }
1013         return err;
1014 }
1015
1016 static int fuse_perm_getattr(struct inode *inode, int mask)
1017 {
1018         if (mask & MAY_NOT_BLOCK)
1019                 return -ECHILD;
1020
1021         return fuse_do_getattr(inode, NULL, NULL);
1022 }
1023
1024 /*
1025  * Check permission.  The two basic access models of FUSE are:
1026  *
1027  * 1) Local access checking ('default_permissions' mount option) based
1028  * on file mode.  This is the plain old disk filesystem permission
1029  * modell.
1030  *
1031  * 2) "Remote" access checking, where server is responsible for
1032  * checking permission in each inode operation.  An exception to this
1033  * is if ->permission() was invoked from sys_access() in which case an
1034  * access request is sent.  Execute permission is still checked
1035  * locally based on file mode.
1036  */
1037 static int fuse_permission(struct inode *inode, int mask)
1038 {
1039         struct fuse_conn *fc = get_fuse_conn(inode);
1040         bool refreshed = false;
1041         int err = 0;
1042
1043         if (!fuse_allow_task(fc, current))
1044                 return -EACCES;
1045
1046         /*
1047          * If attributes are needed, refresh them before proceeding
1048          */
1049         if ((fc->flags & FUSE_DEFAULT_PERMISSIONS) ||
1050             ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
1051                 struct fuse_inode *fi = get_fuse_inode(inode);
1052
1053                 if (fi->i_time < get_jiffies_64()) {
1054                         refreshed = true;
1055
1056                         err = fuse_perm_getattr(inode, mask);
1057                         if (err)
1058                                 return err;
1059                 }
1060         }
1061
1062         if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
1063                 err = generic_permission(inode, mask);
1064
1065                 /* If permission is denied, try to refresh file
1066                    attributes.  This is also needed, because the root
1067                    node will at first have no permissions */
1068                 if (err == -EACCES && !refreshed) {
1069                         err = fuse_perm_getattr(inode, mask);
1070                         if (!err)
1071                                 err = generic_permission(inode, mask);
1072                 }
1073
1074                 /* Note: the opposite of the above test does not
1075                    exist.  So if permissions are revoked this won't be
1076                    noticed immediately, only after the attribute
1077                    timeout has expired */
1078         } else if (mask & (MAY_ACCESS | MAY_CHDIR)) {
1079                 if (mask & MAY_NOT_BLOCK)
1080                         return -ECHILD;
1081
1082                 err = fuse_access(inode, mask);
1083         } else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
1084                 if (!(inode->i_mode & S_IXUGO)) {
1085                         if (refreshed)
1086                                 return -EACCES;
1087
1088                         err = fuse_perm_getattr(inode, mask);
1089                         if (!err && !(inode->i_mode & S_IXUGO))
1090                                 return -EACCES;
1091                 }
1092         }
1093         return err;
1094 }
1095
1096 static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
1097                          void *dstbuf, filldir_t filldir)
1098 {
1099         while (nbytes >= FUSE_NAME_OFFSET) {
1100                 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
1101                 size_t reclen = FUSE_DIRENT_SIZE(dirent);
1102                 int over;
1103                 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1104                         return -EIO;
1105                 if (reclen > nbytes)
1106                         break;
1107
1108                 over = filldir(dstbuf, dirent->name, dirent->namelen,
1109                                file->f_pos, dirent->ino, dirent->type);
1110                 if (over)
1111                         break;
1112
1113                 buf += reclen;
1114                 nbytes -= reclen;
1115                 file->f_pos = dirent->off;
1116         }
1117
1118         return 0;
1119 }
1120
1121 static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
1122 {
1123         int err;
1124         size_t nbytes;
1125         struct page *page;
1126         struct inode *inode = file->f_path.dentry->d_inode;
1127         struct fuse_conn *fc = get_fuse_conn(inode);
1128         struct fuse_req *req;
1129
1130         if (is_bad_inode(inode))
1131                 return -EIO;
1132
1133         req = fuse_get_req(fc);
1134         if (IS_ERR(req))
1135                 return PTR_ERR(req);
1136
1137         page = alloc_page(GFP_KERNEL);
1138         if (!page) {
1139                 fuse_put_request(fc, req);
1140                 return -ENOMEM;
1141         }
1142         req->out.argpages = 1;
1143         req->num_pages = 1;
1144         req->pages[0] = page;
1145         fuse_read_fill(req, file, file->f_pos, PAGE_SIZE, FUSE_READDIR);
1146         fuse_request_send(fc, req);
1147         nbytes = req->out.args[0].size;
1148         err = req->out.h.error;
1149         fuse_put_request(fc, req);
1150         if (!err)
1151                 err = parse_dirfile(page_address(page), nbytes, file, dstbuf,
1152                                     filldir);
1153
1154         __free_page(page);
1155         fuse_invalidate_attr(inode); /* atime changed */
1156         return err;
1157 }
1158
1159 static char *read_link(struct dentry *dentry)
1160 {
1161         struct inode *inode = dentry->d_inode;
1162         struct fuse_conn *fc = get_fuse_conn(inode);
1163         struct fuse_req *req = fuse_get_req(fc);
1164         char *link;
1165
1166         if (IS_ERR(req))
1167                 return ERR_CAST(req);
1168
1169         link = (char *) __get_free_page(GFP_KERNEL);
1170         if (!link) {
1171                 link = ERR_PTR(-ENOMEM);
1172                 goto out;
1173         }
1174         req->in.h.opcode = FUSE_READLINK;
1175         req->in.h.nodeid = get_node_id(inode);
1176         req->out.argvar = 1;
1177         req->out.numargs = 1;
1178         req->out.args[0].size = PAGE_SIZE - 1;
1179         req->out.args[0].value = link;
1180         fuse_request_send(fc, req);
1181         if (req->out.h.error) {
1182                 free_page((unsigned long) link);
1183                 link = ERR_PTR(req->out.h.error);
1184         } else
1185                 link[req->out.args[0].size] = '\0';
1186  out:
1187         fuse_put_request(fc, req);
1188         fuse_invalidate_attr(inode); /* atime changed */
1189         return link;
1190 }
1191
1192 static void free_link(char *link)
1193 {
1194         if (!IS_ERR(link))
1195                 free_page((unsigned long) link);
1196 }
1197
1198 static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
1199 {
1200         nd_set_link(nd, read_link(dentry));
1201         return NULL;
1202 }
1203
1204 static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
1205 {
1206         free_link(nd_get_link(nd));
1207 }
1208
1209 static int fuse_dir_open(struct inode *inode, struct file *file)
1210 {
1211         return fuse_open_common(inode, file, true);
1212 }
1213
1214 static int fuse_dir_release(struct inode *inode, struct file *file)
1215 {
1216         fuse_release_common(file, FUSE_RELEASEDIR);
1217
1218         return 0;
1219 }
1220
1221 static int fuse_dir_fsync(struct file *file, loff_t start, loff_t end,
1222                           int datasync)
1223 {
1224         return fuse_fsync_common(file, start, end, datasync, 1);
1225 }
1226
1227 static long fuse_dir_ioctl(struct file *file, unsigned int cmd,
1228                             unsigned long arg)
1229 {
1230         struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1231
1232         /* FUSE_IOCTL_DIR only supported for API version >= 7.18 */
1233         if (fc->minor < 18)
1234                 return -ENOTTY;
1235
1236         return fuse_ioctl_common(file, cmd, arg, FUSE_IOCTL_DIR);
1237 }
1238
1239 static long fuse_dir_compat_ioctl(struct file *file, unsigned int cmd,
1240                                    unsigned long arg)
1241 {
1242         struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1243
1244         if (fc->minor < 18)
1245                 return -ENOTTY;
1246
1247         return fuse_ioctl_common(file, cmd, arg,
1248                                  FUSE_IOCTL_COMPAT | FUSE_IOCTL_DIR);
1249 }
1250
1251 static bool update_mtime(unsigned ivalid)
1252 {
1253         /* Always update if mtime is explicitly set  */
1254         if (ivalid & ATTR_MTIME_SET)
1255                 return true;
1256
1257         /* If it's an open(O_TRUNC) or an ftruncate(), don't update */
1258         if ((ivalid & ATTR_SIZE) && (ivalid & (ATTR_OPEN | ATTR_FILE)))
1259                 return false;
1260
1261         /* In all other cases update */
1262         return true;
1263 }
1264
1265 static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg)
1266 {
1267         unsigned ivalid = iattr->ia_valid;
1268
1269         if (ivalid & ATTR_MODE)
1270                 arg->valid |= FATTR_MODE,   arg->mode = iattr->ia_mode;
1271         if (ivalid & ATTR_UID)
1272                 arg->valid |= FATTR_UID,    arg->uid = iattr->ia_uid;
1273         if (ivalid & ATTR_GID)
1274                 arg->valid |= FATTR_GID,    arg->gid = iattr->ia_gid;
1275         if (ivalid & ATTR_SIZE)
1276                 arg->valid |= FATTR_SIZE,   arg->size = iattr->ia_size;
1277         if (ivalid & ATTR_ATIME) {
1278                 arg->valid |= FATTR_ATIME;
1279                 arg->atime = iattr->ia_atime.tv_sec;
1280                 arg->atimensec = iattr->ia_atime.tv_nsec;
1281                 if (!(ivalid & ATTR_ATIME_SET))
1282                         arg->valid |= FATTR_ATIME_NOW;
1283         }
1284         if ((ivalid & ATTR_MTIME) && update_mtime(ivalid)) {
1285                 arg->valid |= FATTR_MTIME;
1286                 arg->mtime = iattr->ia_mtime.tv_sec;
1287                 arg->mtimensec = iattr->ia_mtime.tv_nsec;
1288                 if (!(ivalid & ATTR_MTIME_SET))
1289                         arg->valid |= FATTR_MTIME_NOW;
1290         }
1291 }
1292
1293 /*
1294  * Prevent concurrent writepages on inode
1295  *
1296  * This is done by adding a negative bias to the inode write counter
1297  * and waiting for all pending writes to finish.
1298  */
1299 void fuse_set_nowrite(struct inode *inode)
1300 {
1301         struct fuse_conn *fc = get_fuse_conn(inode);
1302         struct fuse_inode *fi = get_fuse_inode(inode);
1303
1304         BUG_ON(!mutex_is_locked(&inode->i_mutex));
1305
1306         spin_lock(&fc->lock);
1307         BUG_ON(fi->writectr < 0);
1308         fi->writectr += FUSE_NOWRITE;
1309         spin_unlock(&fc->lock);
1310         wait_event(fi->page_waitq, fi->writectr == FUSE_NOWRITE);
1311 }
1312
1313 /*
1314  * Allow writepages on inode
1315  *
1316  * Remove the bias from the writecounter and send any queued
1317  * writepages.
1318  */
1319 static void __fuse_release_nowrite(struct inode *inode)
1320 {
1321         struct fuse_inode *fi = get_fuse_inode(inode);
1322
1323         BUG_ON(fi->writectr != FUSE_NOWRITE);
1324         fi->writectr = 0;
1325         fuse_flush_writepages(inode);
1326 }
1327
1328 void fuse_release_nowrite(struct inode *inode)
1329 {
1330         struct fuse_conn *fc = get_fuse_conn(inode);
1331
1332         spin_lock(&fc->lock);
1333         __fuse_release_nowrite(inode);
1334         spin_unlock(&fc->lock);
1335 }
1336
1337 /*
1338  * Set attributes, and at the same time refresh them.
1339  *
1340  * Truncation is slightly complicated, because the 'truncate' request
1341  * may fail, in which case we don't want to touch the mapping.
1342  * vmtruncate() doesn't allow for this case, so do the rlimit checking
1343  * and the actual truncation by hand.
1344  */
1345 static int fuse_do_setattr(struct dentry *entry, struct iattr *attr,
1346                            struct file *file)
1347 {
1348         struct inode *inode = entry->d_inode;
1349         struct fuse_conn *fc = get_fuse_conn(inode);
1350         struct fuse_req *req;
1351         struct fuse_setattr_in inarg;
1352         struct fuse_attr_out outarg;
1353         bool is_truncate = false;
1354         loff_t oldsize;
1355         int err;
1356
1357         if (!fuse_allow_task(fc, current))
1358                 return -EACCES;
1359
1360         if (!(fc->flags & FUSE_DEFAULT_PERMISSIONS))
1361                 attr->ia_valid |= ATTR_FORCE;
1362
1363         err = inode_change_ok(inode, attr);
1364         if (err)
1365                 return err;
1366
1367         if (attr->ia_valid & ATTR_OPEN) {
1368                 if (fc->atomic_o_trunc)
1369                         return 0;
1370                 file = NULL;
1371         }
1372
1373         if (attr->ia_valid & ATTR_SIZE)
1374                 is_truncate = true;
1375
1376         req = fuse_get_req(fc);
1377         if (IS_ERR(req))
1378                 return PTR_ERR(req);
1379
1380         if (is_truncate)
1381                 fuse_set_nowrite(inode);
1382
1383         memset(&inarg, 0, sizeof(inarg));
1384         memset(&outarg, 0, sizeof(outarg));
1385         iattr_to_fattr(attr, &inarg);
1386         if (file) {
1387                 struct fuse_file *ff = file->private_data;
1388                 inarg.valid |= FATTR_FH;
1389                 inarg.fh = ff->fh;
1390         }
1391         if (attr->ia_valid & ATTR_SIZE) {
1392                 /* For mandatory locking in truncate */
1393                 inarg.valid |= FATTR_LOCKOWNER;
1394                 inarg.lock_owner = fuse_lock_owner_id(fc, current->files);
1395         }
1396         req->in.h.opcode = FUSE_SETATTR;
1397         req->in.h.nodeid = get_node_id(inode);
1398         req->in.numargs = 1;
1399         req->in.args[0].size = sizeof(inarg);
1400         req->in.args[0].value = &inarg;
1401         req->out.numargs = 1;
1402         if (fc->minor < 9)
1403                 req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
1404         else
1405                 req->out.args[0].size = sizeof(outarg);
1406         req->out.args[0].value = &outarg;
1407         fuse_request_send(fc, req);
1408         err = req->out.h.error;
1409         fuse_put_request(fc, req);
1410         if (err) {
1411                 if (err == -EINTR)
1412                         fuse_invalidate_attr(inode);
1413                 goto error;
1414         }
1415
1416         if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
1417                 make_bad_inode(inode);
1418                 err = -EIO;
1419                 goto error;
1420         }
1421
1422         spin_lock(&fc->lock);
1423         fuse_change_attributes_common(inode, &outarg.attr,
1424                                       attr_timeout(&outarg));
1425         oldsize = inode->i_size;
1426         i_size_write(inode, outarg.attr.size);
1427
1428         if (is_truncate) {
1429                 /* NOTE: this may release/reacquire fc->lock */
1430                 __fuse_release_nowrite(inode);
1431         }
1432         spin_unlock(&fc->lock);
1433
1434         /*
1435          * Only call invalidate_inode_pages2() after removing
1436          * FUSE_NOWRITE, otherwise fuse_launder_page() would deadlock.
1437          */
1438         if (S_ISREG(inode->i_mode) && oldsize != outarg.attr.size) {
1439                 truncate_pagecache(inode, oldsize, outarg.attr.size);
1440                 invalidate_inode_pages2(inode->i_mapping);
1441         }
1442
1443         return 0;
1444
1445 error:
1446         if (is_truncate)
1447                 fuse_release_nowrite(inode);
1448
1449         return err;
1450 }
1451
1452 static int fuse_setattr(struct dentry *entry, struct iattr *attr)
1453 {
1454         if (attr->ia_valid & ATTR_FILE)
1455                 return fuse_do_setattr(entry, attr, attr->ia_file);
1456         else
1457                 return fuse_do_setattr(entry, attr, NULL);
1458 }
1459
1460 static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
1461                         struct kstat *stat)
1462 {
1463         struct inode *inode = entry->d_inode;
1464         struct fuse_conn *fc = get_fuse_conn(inode);
1465
1466         if (!fuse_allow_task(fc, current))
1467                 return -EACCES;
1468
1469         return fuse_update_attributes(inode, stat, NULL, NULL);
1470 }
1471
1472 static int fuse_setxattr(struct dentry *entry, const char *name,
1473                          const void *value, size_t size, int flags)
1474 {
1475         struct inode *inode = entry->d_inode;
1476         struct fuse_conn *fc = get_fuse_conn(inode);
1477         struct fuse_req *req;
1478         struct fuse_setxattr_in inarg;
1479         int err;
1480
1481         if (fc->no_setxattr)
1482                 return -EOPNOTSUPP;
1483
1484         req = fuse_get_req(fc);
1485         if (IS_ERR(req))
1486                 return PTR_ERR(req);
1487
1488         memset(&inarg, 0, sizeof(inarg));
1489         inarg.size = size;
1490         inarg.flags = flags;
1491         req->in.h.opcode = FUSE_SETXATTR;
1492         req->in.h.nodeid = get_node_id(inode);
1493         req->in.numargs = 3;
1494         req->in.args[0].size = sizeof(inarg);
1495         req->in.args[0].value = &inarg;
1496         req->in.args[1].size = strlen(name) + 1;
1497         req->in.args[1].value = name;
1498         req->in.args[2].size = size;
1499         req->in.args[2].value = value;
1500         fuse_request_send(fc, req);
1501         err = req->out.h.error;
1502         fuse_put_request(fc, req);
1503         if (err == -ENOSYS) {
1504                 fc->no_setxattr = 1;
1505                 err = -EOPNOTSUPP;
1506         }
1507         return err;
1508 }
1509
1510 static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
1511                              void *value, size_t size)
1512 {
1513         struct inode *inode = entry->d_inode;
1514         struct fuse_conn *fc = get_fuse_conn(inode);
1515         struct fuse_req *req;
1516         struct fuse_getxattr_in inarg;
1517         struct fuse_getxattr_out outarg;
1518         ssize_t ret;
1519
1520         if (fc->no_getxattr)
1521                 return -EOPNOTSUPP;
1522
1523         req = fuse_get_req(fc);
1524         if (IS_ERR(req))
1525                 return PTR_ERR(req);
1526
1527         memset(&inarg, 0, sizeof(inarg));
1528         inarg.size = size;
1529         req->in.h.opcode = FUSE_GETXATTR;
1530         req->in.h.nodeid = get_node_id(inode);
1531         req->in.numargs = 2;
1532         req->in.args[0].size = sizeof(inarg);
1533         req->in.args[0].value = &inarg;
1534         req->in.args[1].size = strlen(name) + 1;
1535         req->in.args[1].value = name;
1536         /* This is really two different operations rolled into one */
1537         req->out.numargs = 1;
1538         if (size) {
1539                 req->out.argvar = 1;
1540                 req->out.args[0].size = size;
1541                 req->out.args[0].value = value;
1542         } else {
1543                 req->out.args[0].size = sizeof(outarg);
1544                 req->out.args[0].value = &outarg;
1545         }
1546         fuse_request_send(fc, req);
1547         ret = req->out.h.error;
1548         if (!ret)
1549                 ret = size ? req->out.args[0].size : outarg.size;
1550         else {
1551                 if (ret == -ENOSYS) {
1552                         fc->no_getxattr = 1;
1553                         ret = -EOPNOTSUPP;
1554                 }
1555         }
1556         fuse_put_request(fc, req);
1557         return ret;
1558 }
1559
1560 static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
1561 {
1562         struct inode *inode = entry->d_inode;
1563         struct fuse_conn *fc = get_fuse_conn(inode);
1564         struct fuse_req *req;
1565         struct fuse_getxattr_in inarg;
1566         struct fuse_getxattr_out outarg;
1567         ssize_t ret;
1568
1569         if (!fuse_allow_task(fc, current))
1570                 return -EACCES;
1571
1572         if (fc->no_listxattr)
1573                 return -EOPNOTSUPP;
1574
1575         req = fuse_get_req(fc);
1576         if (IS_ERR(req))
1577                 return PTR_ERR(req);
1578
1579         memset(&inarg, 0, sizeof(inarg));
1580         inarg.size = size;
1581         req->in.h.opcode = FUSE_LISTXATTR;
1582         req->in.h.nodeid = get_node_id(inode);
1583         req->in.numargs = 1;
1584         req->in.args[0].size = sizeof(inarg);
1585         req->in.args[0].value = &inarg;
1586         /* This is really two different operations rolled into one */
1587         req->out.numargs = 1;
1588         if (size) {
1589                 req->out.argvar = 1;
1590                 req->out.args[0].size = size;
1591                 req->out.args[0].value = list;
1592         } else {
1593                 req->out.args[0].size = sizeof(outarg);
1594                 req->out.args[0].value = &outarg;
1595         }
1596         fuse_request_send(fc, req);
1597         ret = req->out.h.error;
1598         if (!ret)
1599                 ret = size ? req->out.args[0].size : outarg.size;
1600         else {
1601                 if (ret == -ENOSYS) {
1602                         fc->no_listxattr = 1;
1603                         ret = -EOPNOTSUPP;
1604                 }
1605         }
1606         fuse_put_request(fc, req);
1607         return ret;
1608 }
1609
1610 static int fuse_removexattr(struct dentry *entry, const char *name)
1611 {
1612         struct inode *inode = entry->d_inode;
1613         struct fuse_conn *fc = get_fuse_conn(inode);
1614         struct fuse_req *req;
1615         int err;
1616
1617         if (fc->no_removexattr)
1618                 return -EOPNOTSUPP;
1619
1620         req = fuse_get_req(fc);
1621         if (IS_ERR(req))
1622                 return PTR_ERR(req);
1623
1624         req->in.h.opcode = FUSE_REMOVEXATTR;
1625         req->in.h.nodeid = get_node_id(inode);
1626         req->in.numargs = 1;
1627         req->in.args[0].size = strlen(name) + 1;
1628         req->in.args[0].value = name;
1629         fuse_request_send(fc, req);
1630         err = req->out.h.error;
1631         fuse_put_request(fc, req);
1632         if (err == -ENOSYS) {
1633                 fc->no_removexattr = 1;
1634                 err = -EOPNOTSUPP;
1635         }
1636         return err;
1637 }
1638
1639 static const struct inode_operations fuse_dir_inode_operations = {
1640         .lookup         = fuse_lookup,
1641         .mkdir          = fuse_mkdir,
1642         .symlink        = fuse_symlink,
1643         .unlink         = fuse_unlink,
1644         .rmdir          = fuse_rmdir,
1645         .rename         = fuse_rename,
1646         .link           = fuse_link,
1647         .setattr        = fuse_setattr,
1648         .create         = fuse_create,
1649         .mknod          = fuse_mknod,
1650         .permission     = fuse_permission,
1651         .getattr        = fuse_getattr,
1652         .setxattr       = fuse_setxattr,
1653         .getxattr       = fuse_getxattr,
1654         .listxattr      = fuse_listxattr,
1655         .removexattr    = fuse_removexattr,
1656 };
1657
1658 static const struct file_operations fuse_dir_operations = {
1659         .llseek         = generic_file_llseek,
1660         .read           = generic_read_dir,
1661         .readdir        = fuse_readdir,
1662         .open           = fuse_dir_open,
1663         .release        = fuse_dir_release,
1664         .fsync          = fuse_dir_fsync,
1665         .unlocked_ioctl = fuse_dir_ioctl,
1666         .compat_ioctl   = fuse_dir_compat_ioctl,
1667 };
1668
1669 static const struct inode_operations fuse_common_inode_operations = {
1670         .setattr        = fuse_setattr,
1671         .permission     = fuse_permission,
1672         .getattr        = fuse_getattr,
1673         .setxattr       = fuse_setxattr,
1674         .getxattr       = fuse_getxattr,
1675         .listxattr      = fuse_listxattr,
1676         .removexattr    = fuse_removexattr,
1677 };
1678
1679 static const struct inode_operations fuse_symlink_inode_operations = {
1680         .setattr        = fuse_setattr,
1681         .follow_link    = fuse_follow_link,
1682         .put_link       = fuse_put_link,
1683         .readlink       = generic_readlink,
1684         .getattr        = fuse_getattr,
1685         .setxattr       = fuse_setxattr,
1686         .getxattr       = fuse_getxattr,
1687         .listxattr      = fuse_listxattr,
1688         .removexattr    = fuse_removexattr,
1689 };
1690
1691 void fuse_init_common(struct inode *inode)
1692 {
1693         inode->i_op = &fuse_common_inode_operations;
1694 }
1695
1696 void fuse_init_dir(struct inode *inode)
1697 {
1698         inode->i_op = &fuse_dir_inode_operations;
1699         inode->i_fop = &fuse_dir_operations;
1700 }
1701
1702 void fuse_init_symlink(struct inode *inode)
1703 {
1704         inode->i_op = &fuse_symlink_inode_operations;
1705 }