fs/fuse/dir.c

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