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