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