SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/fuse/dir.c

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