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