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-2006  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 static 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_req *req, struct inode *dir,
 116                              struct dentry *entry,
 117                              struct fuse_entry_out *outarg)
 118 {
 119         req->in.h.opcode = FUSE_LOOKUP;
 120         req->in.h.nodeid = get_node_id(dir);
 121         req->in.numargs = 1;
 122         req->in.args[0].size = entry->d_name.len + 1;
 123         req->in.args[0].value = entry->d_name.name;
 124         req->out.numargs = 1;
 125         req->out.args[0].size = sizeof(struct fuse_entry_out);
 126         req->out.args[0].value = outarg;
 127 }
 128
 129 /*
 130  * Check whether the dentry is still valid
 131  *
 132  * If the entry validity timeout has expired and the dentry is
 133  * positive, try to redo the lookup.  If the lookup results in a
 134  * different inode, then let the VFS invalidate the dentry and redo
 135  * the lookup once more.  If the lookup results in the same inode,
 136  * then refresh the attributes, timeouts and mark the dentry valid.
 137  */
 138 static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
 139 {
 140         struct inode *inode = entry->d_inode;
 141
 142         if (inode && is_bad_inode(inode))
 143                 return 0;
 144         else if (fuse_dentry_time(entry) < get_jiffies_64()) {
 145                 int err;
 146                 struct fuse_entry_out outarg;
 147                 struct fuse_conn *fc;
 148                 struct fuse_req *req;
 149                 struct fuse_req *forget_req;
 150                 struct dentry *parent;
 151                 u64 attr_version;
 152
 153                 /* For negative dentries, always do a fresh lookup */
 154                 if (!inode)
 155                         return 0;
 156
 157                 fc = get_fuse_conn(inode);
 158                 req = fuse_get_req(fc);
 159                 if (IS_ERR(req))
 160                         return 0;
 161
 162                 forget_req = fuse_get_req(fc);
 163                 if (IS_ERR(forget_req)) {
 164                         fuse_put_request(fc, req);
 165                         return 0;
 166                 }
 167
 168                 spin_lock(&fc->lock);
 169                 attr_version = fc->attr_version;
 170                 spin_unlock(&fc->lock);
 171
 172                 parent = dget_parent(entry);
 173                 fuse_lookup_init(req, parent->d_inode, entry, &outarg);
 174                 request_send(fc, req);
 175                 dput(parent);
 176                 err = req->out.h.error;
 177                 fuse_put_request(fc, req);
 178                 /* Zero nodeid is same as -ENOENT */
 179                 if (!err && !outarg.nodeid)
 180                         err = -ENOENT;
 181                 if (!err) {
 182                         struct fuse_inode *fi = get_fuse_inode(inode);
 183                         if (outarg.nodeid != get_node_id(inode)) {
 184                                 fuse_send_forget(fc, forget_req,
 185                                                  outarg.nodeid, 1);
 186                                 return 0;
 187                         }
 188                         spin_lock(&fc->lock);
 189                         fi->nlookup ++;
 190                         spin_unlock(&fc->lock);
 191                 }
 192                 fuse_put_request(fc, forget_req);
 193                 if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
 194                         return 0;
 195
 196                 fuse_change_attributes(inode, &outarg.attr,
 197                                        entry_attr_timeout(&outarg),
 198                                        attr_version);
 199                 fuse_change_entry_timeout(entry, &outarg);
 200         }
 201         return 1;
 202 }
 203
 204 static int invalid_nodeid(u64 nodeid)
 205 {
 206         return !nodeid || nodeid == FUSE_ROOT_ID;
 207 }
 208
 209 static struct dentry_operations fuse_dentry_operations = {
 210         .d_revalidate   = fuse_dentry_revalidate,
 211 };
 212
 213 int fuse_valid_type(int m)
 214 {
 215         return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
 216                 S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
 217 }
 218
 219 /*
 220  * Add a directory inode to a dentry, ensuring that no other dentry
 221  * refers to this inode.  Called with fc->inst_mutex.
 222  */
 223 static int fuse_d_add_directory(struct dentry *entry, struct inode *inode)
 224 {
 225         struct dentry *alias = d_find_alias(inode);
 226         if (alias) {
 227                 /* This tries to shrink the subtree below alias */
 228                 fuse_invalidate_entry(alias);
 229                 dput(alias);
 230                 if (!list_empty(&inode->i_dentry))
 231                         return -EBUSY;
 232         }
 233         d_add(entry, inode);
 234         return 0;
 235 }
 236
 237 static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
 238                                   struct nameidata *nd)
 239 {
 240         int err;
 241         struct fuse_entry_out outarg;
 242         struct inode *inode = NULL;
 243         struct fuse_conn *fc = get_fuse_conn(dir);
 244         struct fuse_req *req;
 245         struct fuse_req *forget_req;
 246         u64 attr_version;
 247
 248         if (entry->d_name.len > FUSE_NAME_MAX)
 249                 return ERR_PTR(-ENAMETOOLONG);
 250
 251         req = fuse_get_req(fc);
 252         if (IS_ERR(req))
 253                 return ERR_PTR(PTR_ERR(req));
 254
 255         forget_req = fuse_get_req(fc);
 256         if (IS_ERR(forget_req)) {
 257                 fuse_put_request(fc, req);
 258                 return ERR_PTR(PTR_ERR(forget_req));
 259         }
 260
 261         spin_lock(&fc->lock);
 262         attr_version = fc->attr_version;
 263         spin_unlock(&fc->lock);
 264
 265         fuse_lookup_init(req, dir, entry, &outarg);
 266         request_send(fc, req);
 267         err = req->out.h.error;
 268         fuse_put_request(fc, req);
 269         /* Zero nodeid is same as -ENOENT, but with valid timeout */
 270         if (!err && outarg.nodeid &&
 271             (invalid_nodeid(outarg.nodeid) ||
 272              !fuse_valid_type(outarg.attr.mode)))
 273                 err = -EIO;
 274         if (!err && outarg.nodeid) {
 275                 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
 276                                   &outarg.attr, entry_attr_timeout(&outarg),
 277                                   attr_version);
 278                 if (!inode) {
 279                         fuse_send_forget(fc, forget_req, outarg.nodeid, 1);
 280                         return ERR_PTR(-ENOMEM);
 281                 }
 282         }
 283         fuse_put_request(fc, forget_req);
 284         if (err && err != -ENOENT)
 285                 return ERR_PTR(err);
 286
 287         if (inode && S_ISDIR(inode->i_mode)) {
 288                 mutex_lock(&fc->inst_mutex);
 289                 err = fuse_d_add_directory(entry, inode);
 290                 mutex_unlock(&fc->inst_mutex);
 291                 if (err) {
 292                         iput(inode);
 293                         return ERR_PTR(err);
 294                 }
 295         } else
 296                 d_add(entry, inode);
 297
 298         entry->d_op = &fuse_dentry_operations;
 299         if (!err)
 300                 fuse_change_entry_timeout(entry, &outarg);
 301         else
 302                 fuse_invalidate_entry_cache(entry);
 303         return NULL;
 304 }
 305
 306 /*
 307  * Synchronous release for the case when something goes wrong in CREATE_OPEN
 308  */
 309 static void fuse_sync_release(struct fuse_conn *fc, struct fuse_file *ff,
 310                               u64 nodeid, int flags)
 311 {
 312         fuse_release_fill(ff, nodeid, flags, FUSE_RELEASE);
 313         ff->reserved_req->force = 1;
 314         request_send(fc, ff->reserved_req);
 315         fuse_put_request(fc, ff->reserved_req);
 316         kfree(ff);
 317 }
 318
 319 /*
 320  * Atomic create+open operation
 321  *
 322  * If the filesystem doesn't support this, then fall back to separate
 323  * 'mknod' + 'open' requests.
 324  */
 325 static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
 326                             struct nameidata *nd)
 327 {
 328         int err;
 329         struct inode *inode;
 330         struct fuse_conn *fc = get_fuse_conn(dir);
 331         struct fuse_req *req;
 332         struct fuse_req *forget_req;
 333         struct fuse_open_in inarg;
 334         struct fuse_open_out outopen;
 335         struct fuse_entry_out outentry;
 336         struct fuse_file *ff;
 337         struct file *file;
 338         int flags = nd->intent.open.flags - 1;
 339
 340         if (fc->no_create)
 341                 return -ENOSYS;
 342
 343         forget_req = fuse_get_req(fc);
 344         if (IS_ERR(forget_req))
 345                 return PTR_ERR(forget_req);
 346
 347         req = fuse_get_req(fc);
 348         err = PTR_ERR(req);
 349         if (IS_ERR(req))
 350                 goto out_put_forget_req;
 351
 352         err = -ENOMEM;
 353         ff = fuse_file_alloc();
 354         if (!ff)
 355                 goto out_put_request;
 356
 357         flags &= ~O_NOCTTY;
 358         memset(&inarg, 0, sizeof(inarg));
 359         inarg.flags = flags;
 360         inarg.mode = mode;
 361         req->in.h.opcode = FUSE_CREATE;
 362         req->in.h.nodeid = get_node_id(dir);
 363         req->in.numargs = 2;
 364         req->in.args[0].size = sizeof(inarg);
 365         req->in.args[0].value = &inarg;
 366         req->in.args[1].size = entry->d_name.len + 1;
 367         req->in.args[1].value = entry->d_name.name;
 368         req->out.numargs = 2;
 369         req->out.args[0].size = sizeof(outentry);
 370         req->out.args[0].value = &outentry;
 371         req->out.args[1].size = sizeof(outopen);
 372         req->out.args[1].value = &outopen;
 373         request_send(fc, req);
 374         err = req->out.h.error;
 375         if (err) {
 376                 if (err == -ENOSYS)
 377                         fc->no_create = 1;
 378                 goto out_free_ff;
 379         }
 380
 381         err = -EIO;
 382         if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
 383                 goto out_free_ff;
 384
 385         fuse_put_request(fc, req);
 386         inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
 387                           &outentry.attr, entry_attr_timeout(&outentry), 0);
 388         if (!inode) {
 389                 flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
 390                 ff->fh = outopen.fh;
 391                 fuse_sync_release(fc, ff, outentry.nodeid, flags);
 392                 fuse_send_forget(fc, forget_req, outentry.nodeid, 1);
 393                 return -ENOMEM;
 394         }
 395         fuse_put_request(fc, forget_req);
 396         d_instantiate(entry, inode);
 397         fuse_change_entry_timeout(entry, &outentry);
 398         file = lookup_instantiate_filp(nd, entry, generic_file_open);
 399         if (IS_ERR(file)) {
 400                 ff->fh = outopen.fh;
 401                 fuse_sync_release(fc, ff, outentry.nodeid, flags);
 402                 return PTR_ERR(file);
 403         }
 404         fuse_finish_open(inode, file, ff, &outopen);
 405         return 0;
 406
 407  out_free_ff:
 408         fuse_file_free(ff);
 409  out_put_request:
 410         fuse_put_request(fc, req);
 411  out_put_forget_req:
 412         fuse_put_request(fc, forget_req);
 413         return err;
 414 }
 415
 416 /*
 417  * Code shared between mknod, mkdir, symlink and link
 418  */
 419 static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
 420                             struct inode *dir, struct dentry *entry,
 421                             int mode)
 422 {
 423         struct fuse_entry_out outarg;
 424         struct inode *inode;
 425         int err;
 426         struct fuse_req *forget_req;
 427
 428         forget_req = fuse_get_req(fc);
 429         if (IS_ERR(forget_req)) {
 430                 fuse_put_request(fc, req);
 431                 return PTR_ERR(forget_req);
 432         }
 433
 434         req->in.h.nodeid = get_node_id(dir);
 435         req->out.numargs = 1;
 436         req->out.args[0].size = sizeof(outarg);
 437         req->out.args[0].value = &outarg;
 438         request_send(fc, req);
 439         err = req->out.h.error;
 440         fuse_put_request(fc, req);
 441         if (err)
 442                 goto out_put_forget_req;
 443
 444         err = -EIO;
 445         if (invalid_nodeid(outarg.nodeid))
 446                 goto out_put_forget_req;
 447
 448         if ((outarg.attr.mode ^ mode) & S_IFMT)
 449                 goto out_put_forget_req;
 450
 451         inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
 452                           &outarg.attr, entry_attr_timeout(&outarg), 0);
 453         if (!inode) {
 454                 fuse_send_forget(fc, forget_req, outarg.nodeid, 1);
 455                 return -ENOMEM;
 456         }
 457         fuse_put_request(fc, forget_req);
 458
 459         if (S_ISDIR(inode->i_mode)) {
 460                 struct dentry *alias;
 461                 mutex_lock(&fc->inst_mutex);
 462                 alias = d_find_alias(inode);
 463                 if (alias) {
 464                         /* New directory must have moved since mkdir */
 465                         mutex_unlock(&fc->inst_mutex);
 466                         dput(alias);
 467                         iput(inode);
 468                         return -EBUSY;
 469                 }
 470                 d_instantiate(entry, inode);
 471                 mutex_unlock(&fc->inst_mutex);
 472         } else
 473                 d_instantiate(entry, inode);
 474
 475         fuse_change_entry_timeout(entry, &outarg);
 476         fuse_invalidate_attr(dir);
 477         return 0;
 478
 479  out_put_forget_req:
 480         fuse_put_request(fc, forget_req);
 481         return err;
 482 }
 483
 484 static int fuse_mknod(struct inode *dir, struct dentry *entry, int mode,
 485                       dev_t rdev)
 486 {
 487         struct fuse_mknod_in inarg;
 488         struct fuse_conn *fc = get_fuse_conn(dir);
 489         struct fuse_req *req = fuse_get_req(fc);
 490         if (IS_ERR(req))
 491                 return PTR_ERR(req);
 492
 493         memset(&inarg, 0, sizeof(inarg));
 494         inarg.mode = mode;
 495         inarg.rdev = new_encode_dev(rdev);
 496         req->in.h.opcode = FUSE_MKNOD;
 497         req->in.numargs = 2;
 498         req->in.args[0].size = sizeof(inarg);
 499         req->in.args[0].value = &inarg;
 500         req->in.args[1].size = entry->d_name.len + 1;
 501         req->in.args[1].value = entry->d_name.name;
 502         return create_new_entry(fc, req, dir, entry, mode);
 503 }
 504
 505 static int fuse_create(struct inode *dir, struct dentry *entry, int mode,
 506                        struct nameidata *nd)
 507 {
 508         if (nd && (nd->flags & LOOKUP_OPEN)) {
 509                 int err = fuse_create_open(dir, entry, mode, nd);
 510                 if (err != -ENOSYS)
 511                         return err;
 512                 /* Fall back on mknod */
 513         }
 514         return fuse_mknod(dir, entry, mode, 0);
 515 }
 516
 517 static int fuse_mkdir(struct inode *dir, struct dentry *entry, int mode)
 518 {
 519         struct fuse_mkdir_in inarg;
 520         struct fuse_conn *fc = get_fuse_conn(dir);
 521         struct fuse_req *req = fuse_get_req(fc);
 522         if (IS_ERR(req))
 523                 return PTR_ERR(req);
 524
 525         memset(&inarg, 0, sizeof(inarg));
 526         inarg.mode = mode;
 527         req->in.h.opcode = FUSE_MKDIR;
 528         req->in.numargs = 2;
 529         req->in.args[0].size = sizeof(inarg);
 530         req->in.args[0].value = &inarg;
 531         req->in.args[1].size = entry->d_name.len + 1;
 532         req->in.args[1].value = entry->d_name.name;
 533         return create_new_entry(fc, req, dir, entry, S_IFDIR);
 534 }
 535
 536 static int fuse_symlink(struct inode *dir, struct dentry *entry,
 537                         const char *link)
 538 {
 539         struct fuse_conn *fc = get_fuse_conn(dir);
 540         unsigned len = strlen(link) + 1;
 541         struct fuse_req *req = fuse_get_req(fc);
 542         if (IS_ERR(req))
 543                 return PTR_ERR(req);
 544
 545         req->in.h.opcode = FUSE_SYMLINK;
 546         req->in.numargs = 2;
 547         req->in.args[0].size = entry->d_name.len + 1;
 548         req->in.args[0].value = entry->d_name.name;
 549         req->in.args[1].size = len;
 550         req->in.args[1].value = link;
 551         return create_new_entry(fc, req, dir, entry, S_IFLNK);
 552 }
 553
 554 static int fuse_unlink(struct inode *dir, struct dentry *entry)
 555 {
 556         int err;
 557         struct fuse_conn *fc = get_fuse_conn(dir);
 558         struct fuse_req *req = fuse_get_req(fc);
 559         if (IS_ERR(req))
 560                 return PTR_ERR(req);
 561
 562         req->in.h.opcode = FUSE_UNLINK;
 563         req->in.h.nodeid = get_node_id(dir);
 564         req->in.numargs = 1;
 565         req->in.args[0].size = entry->d_name.len + 1;
 566         req->in.args[0].value = entry->d_name.name;
 567         request_send(fc, req);
 568         err = req->out.h.error;
 569         fuse_put_request(fc, req);
 570         if (!err) {
 571                 struct inode *inode = entry->d_inode;
 572
 573                 /* Set nlink to zero so the inode can be cleared, if
 574                    the inode does have more links this will be
 575                    discovered at the next lookup/getattr */
 576                 clear_nlink(inode);
 577                 fuse_invalidate_attr(inode);
 578                 fuse_invalidate_attr(dir);
 579                 fuse_invalidate_entry_cache(entry);
 580         } else if (err == -EINTR)
 581                 fuse_invalidate_entry(entry);
 582         return err;
 583 }
 584
 585 static int fuse_rmdir(struct inode *dir, struct dentry *entry)
 586 {
 587         int err;
 588         struct fuse_conn *fc = get_fuse_conn(dir);
 589         struct fuse_req *req = fuse_get_req(fc);
 590         if (IS_ERR(req))
 591                 return PTR_ERR(req);
 592
 593         req->in.h.opcode = FUSE_RMDIR;
 594         req->in.h.nodeid = get_node_id(dir);
 595         req->in.numargs = 1;
 596         req->in.args[0].size = entry->d_name.len + 1;
 597         req->in.args[0].value = entry->d_name.name;
 598         request_send(fc, req);
 599         err = req->out.h.error;
 600         fuse_put_request(fc, req);
 601         if (!err) {
 602                 clear_nlink(entry->d_inode);
 603                 fuse_invalidate_attr(dir);
 604                 fuse_invalidate_entry_cache(entry);
 605         } else if (err == -EINTR)
 606                 fuse_invalidate_entry(entry);
 607         return err;
 608 }
 609
 610 static int fuse_rename(struct inode *olddir, struct dentry *oldent,
 611                        struct inode *newdir, struct dentry *newent)
 612 {
 613         int err;
 614         struct fuse_rename_in inarg;
 615         struct fuse_conn *fc = get_fuse_conn(olddir);
 616         struct fuse_req *req = fuse_get_req(fc);
 617         if (IS_ERR(req))
 618                 return PTR_ERR(req);
 619
 620         memset(&inarg, 0, sizeof(inarg));
 621         inarg.newdir = get_node_id(newdir);
 622         req->in.h.opcode = FUSE_RENAME;
 623         req->in.h.nodeid = get_node_id(olddir);
 624         req->in.numargs = 3;
 625         req->in.args[0].size = sizeof(inarg);
 626         req->in.args[0].value = &inarg;
 627         req->in.args[1].size = oldent->d_name.len + 1;
 628         req->in.args[1].value = oldent->d_name.name;
 629         req->in.args[2].size = newent->d_name.len + 1;
 630         req->in.args[2].value = newent->d_name.name;
 631         request_send(fc, req);
 632         err = req->out.h.error;
 633         fuse_put_request(fc, req);
 634         if (!err) {
 635                 fuse_invalidate_attr(olddir);
 636                 if (olddir != newdir)
 637                         fuse_invalidate_attr(newdir);
 638
 639                 /* newent will end up negative */
 640                 if (newent->d_inode)
 641                         fuse_invalidate_entry_cache(newent);
 642         } else if (err == -EINTR) {
 643                 /* If request was interrupted, DEITY only knows if the
 644                    rename actually took place.  If the invalidation
 645                    fails (e.g. some process has CWD under the renamed
 646                    directory), then there can be inconsistency between
 647                    the dcache and the real filesystem.  Tough luck. */
 648                 fuse_invalidate_entry(oldent);
 649                 if (newent->d_inode)
 650                         fuse_invalidate_entry(newent);
 651         }
 652
 653         return err;
 654 }
 655
 656 static int fuse_link(struct dentry *entry, struct inode *newdir,
 657                      struct dentry *newent)
 658 {
 659         int err;
 660         struct fuse_link_in inarg;
 661         struct inode *inode = entry->d_inode;
 662         struct fuse_conn *fc = get_fuse_conn(inode);
 663         struct fuse_req *req = fuse_get_req(fc);
 664         if (IS_ERR(req))
 665                 return PTR_ERR(req);
 666
 667         memset(&inarg, 0, sizeof(inarg));
 668         inarg.oldnodeid = get_node_id(inode);
 669         req->in.h.opcode = FUSE_LINK;
 670         req->in.numargs = 2;
 671         req->in.args[0].size = sizeof(inarg);
 672         req->in.args[0].value = &inarg;
 673         req->in.args[1].size = newent->d_name.len + 1;
 674         req->in.args[1].value = newent->d_name.name;
 675         err = create_new_entry(fc, req, newdir, newent, inode->i_mode);
 676         /* Contrary to "normal" filesystems it can happen that link
 677            makes two "logical" inodes point to the same "physical"
 678            inode.  We invalidate the attributes of the old one, so it
 679            will reflect changes in the backing inode (link count,
 680            etc.)
 681         */
 682         if (!err || err == -EINTR)
 683                 fuse_invalidate_attr(inode);
 684         return err;
 685 }
 686
 687 static void fuse_fillattr(struct inode *inode, struct fuse_attr *attr,
 688                           struct kstat *stat)
 689 {
 690         stat->dev = inode->i_sb->s_dev;
 691         stat->ino = attr->ino;
 692         stat->mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
 693         stat->nlink = attr->nlink;
 694         stat->uid = attr->uid;
 695         stat->gid = attr->gid;
 696         stat->rdev = inode->i_rdev;
 697         stat->atime.tv_sec = attr->atime;
 698         stat->atime.tv_nsec = attr->atimensec;
 699         stat->mtime.tv_sec = attr->mtime;
 700         stat->mtime.tv_nsec = attr->mtimensec;
 701         stat->ctime.tv_sec = attr->ctime;
 702         stat->ctime.tv_nsec = attr->ctimensec;
 703         stat->size = attr->size;
 704         stat->blocks = attr->blocks;
 705         stat->blksize = (1 << inode->i_blkbits);
 706 }
 707
 708 static int fuse_do_getattr(struct inode *inode, struct kstat *stat)
 709 {
 710         int err;
 711         struct fuse_attr_out arg;
 712         struct fuse_conn *fc = get_fuse_conn(inode);
 713         struct fuse_req *req;
 714         u64 attr_version;
 715
 716         req = fuse_get_req(fc);
 717         if (IS_ERR(req))
 718                 return PTR_ERR(req);
 719
 720         spin_lock(&fc->lock);
 721         attr_version = fc->attr_version;
 722         spin_unlock(&fc->lock);
 723
 724         req->in.h.opcode = FUSE_GETATTR;
 725         req->in.h.nodeid = get_node_id(inode);
 726         req->out.numargs = 1;
 727         req->out.args[0].size = sizeof(arg);
 728         req->out.args[0].value = &arg;
 729         request_send(fc, req);
 730         err = req->out.h.error;
 731         fuse_put_request(fc, req);
 732         if (!err) {
 733                 if ((inode->i_mode ^ arg.attr.mode) & S_IFMT) {
 734                         make_bad_inode(inode);
 735                         err = -EIO;
 736                 } else {
 737                         fuse_change_attributes(inode, &arg.attr,
 738                                                attr_timeout(&arg),
 739                                                attr_version);
 740                         if (stat)
 741                                 fuse_fillattr(inode, &arg.attr, stat);
 742                 }
 743         }
 744         return err;
 745 }
 746
 747 /*
 748  * Calling into a user-controlled filesystem gives the filesystem
 749  * daemon ptrace-like capabilities over the requester process.  This
 750  * means, that the filesystem daemon is able to record the exact
 751  * filesystem operations performed, and can also control the behavior
 752  * of the requester process in otherwise impossible ways.  For example
 753  * it can delay the operation for arbitrary length of time allowing
 754  * DoS against the requester.
 755  *
 756  * For this reason only those processes can call into the filesystem,
 757  * for which the owner of the mount has ptrace privilege.  This
 758  * excludes processes started by other users, suid or sgid processes.
 759  */
 760 int fuse_allow_task(struct fuse_conn *fc, struct task_struct *task)
 761 {
 762         if (fc->flags & FUSE_ALLOW_OTHER)
 763                 return 1;
 764
 765         if (task->euid == fc->user_id &&
 766             task->suid == fc->user_id &&
 767             task->uid == fc->user_id &&
 768             task->egid == fc->group_id &&
 769             task->sgid == fc->group_id &&
 770             task->gid == fc->group_id)
 771                 return 1;
 772
 773         return 0;
 774 }
 775
 776 static int fuse_access(struct inode *inode, int mask)
 777 {
 778         struct fuse_conn *fc = get_fuse_conn(inode);
 779         struct fuse_req *req;
 780         struct fuse_access_in inarg;
 781         int err;
 782
 783         if (fc->no_access)
 784                 return 0;
 785
 786         req = fuse_get_req(fc);
 787         if (IS_ERR(req))
 788                 return PTR_ERR(req);
 789
 790         memset(&inarg, 0, sizeof(inarg));
 791         inarg.mask = mask;
 792         req->in.h.opcode = FUSE_ACCESS;
 793         req->in.h.nodeid = get_node_id(inode);
 794         req->in.numargs = 1;
 795         req->in.args[0].size = sizeof(inarg);
 796         req->in.args[0].value = &inarg;
 797         request_send(fc, req);
 798         err = req->out.h.error;
 799         fuse_put_request(fc, req);
 800         if (err == -ENOSYS) {
 801                 fc->no_access = 1;
 802                 err = 0;
 803         }
 804         return err;
 805 }
 806
 807 /*
 808  * Check permission.  The two basic access models of FUSE are:
 809  *
 810  * 1) Local access checking ('default_permissions' mount option) based
 811  * on file mode.  This is the plain old disk filesystem permission
 812  * modell.
 813  *
 814  * 2) "Remote" access checking, where server is responsible for
 815  * checking permission in each inode operation.  An exception to this
 816  * is if ->permission() was invoked from sys_access() in which case an
 817  * access request is sent.  Execute permission is still checked
 818  * locally based on file mode.
 819  */
 820 static int fuse_permission(struct inode *inode, int mask, struct nameidata *nd)
 821 {
 822         struct fuse_conn *fc = get_fuse_conn(inode);
 823         bool refreshed = false;
 824         int err = 0;
 825
 826         if (!fuse_allow_task(fc, current))
 827                 return -EACCES;
 828
 829         /*
 830          * If attributes are needed, refresh them before proceeding
 831          */
 832         if ((fc->flags & FUSE_DEFAULT_PERMISSIONS) ||
 833             ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
 834                 struct fuse_inode *fi = get_fuse_inode(inode);
 835                 if (fi->i_time < get_jiffies_64()) {
 836                         err = fuse_do_getattr(inode, NULL);
 837                         if (err)
 838                                 return err;
 839
 840                         refreshed = true;
 841                 }
 842         }
 843
 844         if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
 845                 int err = generic_permission(inode, mask, NULL);
 846
 847                 /* If permission is denied, try to refresh file
 848                    attributes.  This is also needed, because the root
 849                    node will at first have no permissions */
 850                 if (err == -EACCES && !refreshed) {
 851                         err = fuse_do_getattr(inode, NULL);
 852                         if (!err)
 853                                 err = generic_permission(inode, mask, NULL);
 854                 }
 855
 856                 /* Note: the opposite of the above test does not
 857                    exist.  So if permissions are revoked this won't be
 858                    noticed immediately, only after the attribute
 859                    timeout has expired */
 860         } else if (nd && (nd->flags & (LOOKUP_ACCESS | LOOKUP_CHDIR))) {
 861                 err = fuse_access(inode, mask);
 862         } else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
 863                 if (!(inode->i_mode & S_IXUGO)) {
 864                         if (refreshed)
 865                                 return -EACCES;
 866
 867                         err = fuse_do_getattr(inode, NULL);
 868                         if (!err && !(inode->i_mode & S_IXUGO))
 869                                 return -EACCES;
 870                 }
 871         }
 872         return err;
 873 }
 874
 875 static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
 876                          void *dstbuf, filldir_t filldir)
 877 {
 878         while (nbytes >= FUSE_NAME_OFFSET) {
 879                 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
 880                 size_t reclen = FUSE_DIRENT_SIZE(dirent);
 881                 int over;
 882                 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
 883                         return -EIO;
 884                 if (reclen > nbytes)
 885                         break;
 886
 887                 over = filldir(dstbuf, dirent->name, dirent->namelen,
 888                                file->f_pos, dirent->ino, dirent->type);
 889                 if (over)
 890                         break;
 891
 892                 buf += reclen;
 893                 nbytes -= reclen;
 894                 file->f_pos = dirent->off;
 895         }
 896
 897         return 0;
 898 }
 899
 900 static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
 901 {
 902         int err;
 903         size_t nbytes;
 904         struct page *page;
 905         struct inode *inode = file->f_path.dentry->d_inode;
 906         struct fuse_conn *fc = get_fuse_conn(inode);
 907         struct fuse_file *ff = file->private_data;
 908         struct fuse_req *req;
 909
 910         if (is_bad_inode(inode))
 911                 return -EIO;
 912
 913         req = fuse_get_req(fc);
 914         if (IS_ERR(req))
 915                 return PTR_ERR(req);
 916
 917         page = alloc_page(GFP_KERNEL);
 918         if (!page) {
 919                 fuse_put_request(fc, req);
 920                 return -ENOMEM;
 921         }
 922         req->num_pages = 1;
 923         req->pages[0] = page;
 924         fuse_read_fill(req, ff, inode, file->f_pos, PAGE_SIZE, FUSE_READDIR);
 925         request_send(fc, req);
 926         nbytes = req->out.args[0].size;
 927         err = req->out.h.error;
 928         fuse_put_request(fc, req);
 929         if (!err)
 930                 err = parse_dirfile(page_address(page), nbytes, file, dstbuf,
 931                                     filldir);
 932
 933         __free_page(page);
 934         fuse_invalidate_attr(inode); /* atime changed */
 935         return err;
 936 }
 937
 938 static char *read_link(struct dentry *dentry)
 939 {
 940         struct inode *inode = dentry->d_inode;
 941         struct fuse_conn *fc = get_fuse_conn(inode);
 942         struct fuse_req *req = fuse_get_req(fc);
 943         char *link;
 944
 945         if (IS_ERR(req))
 946                 return ERR_PTR(PTR_ERR(req));
 947
 948         link = (char *) __get_free_page(GFP_KERNEL);
 949         if (!link) {
 950                 link = ERR_PTR(-ENOMEM);
 951                 goto out;
 952         }
 953         req->in.h.opcode = FUSE_READLINK;
 954         req->in.h.nodeid = get_node_id(inode);
 955         req->out.argvar = 1;
 956         req->out.numargs = 1;
 957         req->out.args[0].size = PAGE_SIZE - 1;
 958         req->out.args[0].value = link;
 959         request_send(fc, req);
 960         if (req->out.h.error) {
 961                 free_page((unsigned long) link);
 962                 link = ERR_PTR(req->out.h.error);
 963         } else
 964                 link[req->out.args[0].size] = '\0';
 965  out:
 966         fuse_put_request(fc, req);
 967         fuse_invalidate_attr(inode); /* atime changed */
 968         return link;
 969 }
 970
 971 static void free_link(char *link)
 972 {
 973         if (!IS_ERR(link))
 974                 free_page((unsigned long) link);
 975 }
 976
 977 static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
 978 {
 979         nd_set_link(nd, read_link(dentry));
 980         return NULL;
 981 }
 982
 983 static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
 984 {
 985         free_link(nd_get_link(nd));
 986 }
 987
 988 static int fuse_dir_open(struct inode *inode, struct file *file)
 989 {
 990         return fuse_open_common(inode, file, 1);
 991 }
 992
 993 static int fuse_dir_release(struct inode *inode, struct file *file)
 994 {
 995         return fuse_release_common(inode, file, 1);
 996 }
 997
 998 static int fuse_dir_fsync(struct file *file, struct dentry *de, int datasync)
 999 {
1000         /* nfsd can call this with no file */
1001         return file ? fuse_fsync_common(file, de, datasync, 1) : 0;
1002 }
1003
1004 static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg)
1005 {
1006         unsigned ivalid = iattr->ia_valid;
1007
1008         if (ivalid & ATTR_MODE)
1009                 arg->valid |= FATTR_MODE,   arg->mode = iattr->ia_mode;
1010         if (ivalid & ATTR_UID)
1011                 arg->valid |= FATTR_UID,    arg->uid = iattr->ia_uid;
1012         if (ivalid & ATTR_GID)
1013                 arg->valid |= FATTR_GID,    arg->gid = iattr->ia_gid;
1014         if (ivalid & ATTR_SIZE)
1015                 arg->valid |= FATTR_SIZE,   arg->size = iattr->ia_size;
1016         /* You can only _set_ these together (they may change by themselves) */
1017         if ((ivalid & (ATTR_ATIME | ATTR_MTIME)) == (ATTR_ATIME | ATTR_MTIME)) {
1018                 arg->valid |= FATTR_ATIME | FATTR_MTIME;
1019                 arg->atime = iattr->ia_atime.tv_sec;
1020                 arg->mtime = iattr->ia_mtime.tv_sec;
1021         }
1022         if (ivalid & ATTR_FILE) {
1023                 struct fuse_file *ff = iattr->ia_file->private_data;
1024                 arg->valid |= FATTR_FH;
1025                 arg->fh = ff->fh;
1026         }
1027 }
1028
1029 /*
1030  * Set attributes, and at the same time refresh them.
1031  *
1032  * Truncation is slightly complicated, because the 'truncate' request
1033  * may fail, in which case we don't want to touch the mapping.
1034  * vmtruncate() doesn't allow for this case, so do the rlimit checking
1035  * and the actual truncation by hand.
1036  */
1037 static int fuse_setattr(struct dentry *entry, struct iattr *attr)
1038 {
1039         struct inode *inode = entry->d_inode;
1040         struct fuse_conn *fc = get_fuse_conn(inode);
1041         struct fuse_req *req;
1042         struct fuse_setattr_in inarg;
1043         struct fuse_attr_out outarg;
1044         int err;
1045
1046         if (!fuse_allow_task(fc, current))
1047                 return -EACCES;
1048
1049         if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
1050                 err = inode_change_ok(inode, attr);
1051                 if (err)
1052                         return err;
1053         }
1054
1055         if (attr->ia_valid & ATTR_SIZE) {
1056                 unsigned long limit;
1057                 if (IS_SWAPFILE(inode))
1058                         return -ETXTBSY;
1059                 limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
1060                 if (limit != RLIM_INFINITY && attr->ia_size > (loff_t) limit) {
1061                         send_sig(SIGXFSZ, current, 0);
1062                         return -EFBIG;
1063                 }
1064         }
1065
1066         req = fuse_get_req(fc);
1067         if (IS_ERR(req))
1068                 return PTR_ERR(req);
1069
1070         memset(&inarg, 0, sizeof(inarg));
1071         iattr_to_fattr(attr, &inarg);
1072         req->in.h.opcode = FUSE_SETATTR;
1073         req->in.h.nodeid = get_node_id(inode);
1074         req->in.numargs = 1;
1075         req->in.args[0].size = sizeof(inarg);
1076         req->in.args[0].value = &inarg;
1077         req->out.numargs = 1;
1078         req->out.args[0].size = sizeof(outarg);
1079         req->out.args[0].value = &outarg;
1080         request_send(fc, req);
1081         err = req->out.h.error;
1082         fuse_put_request(fc, req);
1083         if (err) {
1084                 if (err == -EINTR)
1085                         fuse_invalidate_attr(inode);
1086                 return err;
1087         }
1088
1089         if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
1090                 make_bad_inode(inode);
1091                 return -EIO;
1092         }
1093
1094         fuse_change_attributes(inode, &outarg.attr, attr_timeout(&outarg), 0);
1095         return 0;
1096 }
1097
1098 static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
1099                         struct kstat *stat)
1100 {
1101         struct inode *inode = entry->d_inode;
1102         struct fuse_inode *fi = get_fuse_inode(inode);
1103         struct fuse_conn *fc = get_fuse_conn(inode);
1104         int err;
1105
1106         if (!fuse_allow_task(fc, current))
1107                 return -EACCES;
1108
1109         if (fi->i_time < get_jiffies_64())
1110                 err = fuse_do_getattr(inode, stat);
1111         else {
1112                 err = 0;
1113                 generic_fillattr(inode, stat);
1114                 stat->mode = fi->orig_i_mode;
1115         }
1116
1117         return err;
1118 }
1119
1120 static int fuse_setxattr(struct dentry *entry, const char *name,
1121                          const void *value, size_t size, int flags)
1122 {
1123         struct inode *inode = entry->d_inode;
1124         struct fuse_conn *fc = get_fuse_conn(inode);
1125         struct fuse_req *req;
1126         struct fuse_setxattr_in inarg;
1127         int err;
1128
1129         if (fc->no_setxattr)
1130                 return -EOPNOTSUPP;
1131
1132         req = fuse_get_req(fc);
1133         if (IS_ERR(req))
1134                 return PTR_ERR(req);
1135
1136         memset(&inarg, 0, sizeof(inarg));
1137         inarg.size = size;
1138         inarg.flags = flags;
1139         req->in.h.opcode = FUSE_SETXATTR;
1140         req->in.h.nodeid = get_node_id(inode);
1141         req->in.numargs = 3;
1142         req->in.args[0].size = sizeof(inarg);
1143         req->in.args[0].value = &inarg;
1144         req->in.args[1].size = strlen(name) + 1;
1145         req->in.args[1].value = name;
1146         req->in.args[2].size = size;
1147         req->in.args[2].value = value;
1148         request_send(fc, req);
1149         err = req->out.h.error;
1150         fuse_put_request(fc, req);
1151         if (err == -ENOSYS) {
1152                 fc->no_setxattr = 1;
1153                 err = -EOPNOTSUPP;
1154         }
1155         return err;
1156 }
1157
1158 static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
1159                              void *value, size_t size)
1160 {
1161         struct inode *inode = entry->d_inode;
1162         struct fuse_conn *fc = get_fuse_conn(inode);
1163         struct fuse_req *req;
1164         struct fuse_getxattr_in inarg;
1165         struct fuse_getxattr_out outarg;
1166         ssize_t ret;
1167
1168         if (fc->no_getxattr)
1169                 return -EOPNOTSUPP;
1170
1171         req = fuse_get_req(fc);
1172         if (IS_ERR(req))
1173                 return PTR_ERR(req);
1174
1175         memset(&inarg, 0, sizeof(inarg));
1176         inarg.size = size;
1177         req->in.h.opcode = FUSE_GETXATTR;
1178         req->in.h.nodeid = get_node_id(inode);
1179         req->in.numargs = 2;
1180         req->in.args[0].size = sizeof(inarg);
1181         req->in.args[0].value = &inarg;
1182         req->in.args[1].size = strlen(name) + 1;
1183         req->in.args[1].value = name;
1184         /* This is really two different operations rolled into one */
1185         req->out.numargs = 1;
1186         if (size) {
1187                 req->out.argvar = 1;
1188                 req->out.args[0].size = size;
1189                 req->out.args[0].value = value;
1190         } else {
1191                 req->out.args[0].size = sizeof(outarg);
1192                 req->out.args[0].value = &outarg;
1193         }
1194         request_send(fc, req);
1195         ret = req->out.h.error;
1196         if (!ret)
1197                 ret = size ? req->out.args[0].size : outarg.size;
1198         else {
1199                 if (ret == -ENOSYS) {
1200                         fc->no_getxattr = 1;
1201                         ret = -EOPNOTSUPP;
1202                 }
1203         }
1204         fuse_put_request(fc, req);
1205         return ret;
1206 }
1207
1208 static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
1209 {
1210         struct inode *inode = entry->d_inode;
1211         struct fuse_conn *fc = get_fuse_conn(inode);
1212         struct fuse_req *req;
1213         struct fuse_getxattr_in inarg;
1214         struct fuse_getxattr_out outarg;
1215         ssize_t ret;
1216
1217         if (!fuse_allow_task(fc, current))
1218                 return -EACCES;
1219
1220         if (fc->no_listxattr)
1221                 return -EOPNOTSUPP;
1222
1223         req = fuse_get_req(fc);
1224         if (IS_ERR(req))
1225                 return PTR_ERR(req);
1226
1227         memset(&inarg, 0, sizeof(inarg));
1228         inarg.size = size;
1229         req->in.h.opcode = FUSE_LISTXATTR;
1230         req->in.h.nodeid = get_node_id(inode);
1231         req->in.numargs = 1;
1232         req->in.args[0].size = sizeof(inarg);
1233         req->in.args[0].value = &inarg;
1234         /* This is really two different operations rolled into one */
1235         req->out.numargs = 1;
1236         if (size) {
1237                 req->out.argvar = 1;
1238                 req->out.args[0].size = size;
1239                 req->out.args[0].value = list;
1240         } else {
1241                 req->out.args[0].size = sizeof(outarg);
1242                 req->out.args[0].value = &outarg;
1243         }
1244         request_send(fc, req);
1245         ret = req->out.h.error;
1246         if (!ret)
1247                 ret = size ? req->out.args[0].size : outarg.size;
1248         else {
1249                 if (ret == -ENOSYS) {
1250                         fc->no_listxattr = 1;
1251                         ret = -EOPNOTSUPP;
1252                 }
1253         }
1254         fuse_put_request(fc, req);
1255         return ret;
1256 }
1257
1258 static int fuse_removexattr(struct dentry *entry, const char *name)
1259 {
1260         struct inode *inode = entry->d_inode;
1261         struct fuse_conn *fc = get_fuse_conn(inode);
1262         struct fuse_req *req;
1263         int err;
1264
1265         if (fc->no_removexattr)
1266                 return -EOPNOTSUPP;
1267
1268         req = fuse_get_req(fc);
1269         if (IS_ERR(req))
1270                 return PTR_ERR(req);
1271
1272         req->in.h.opcode = FUSE_REMOVEXATTR;
1273         req->in.h.nodeid = get_node_id(inode);
1274         req->in.numargs = 1;
1275         req->in.args[0].size = strlen(name) + 1;
1276         req->in.args[0].value = name;
1277         request_send(fc, req);
1278         err = req->out.h.error;
1279         fuse_put_request(fc, req);
1280         if (err == -ENOSYS) {
1281                 fc->no_removexattr = 1;
1282                 err = -EOPNOTSUPP;
1283         }
1284         return err;
1285 }
1286
1287 static const struct inode_operations fuse_dir_inode_operations = {
1288         .lookup         = fuse_lookup,
1289         .mkdir          = fuse_mkdir,
1290         .symlink        = fuse_symlink,
1291         .unlink         = fuse_unlink,
1292         .rmdir          = fuse_rmdir,
1293         .rename         = fuse_rename,
1294         .link           = fuse_link,
1295         .setattr        = fuse_setattr,
1296         .create         = fuse_create,
1297         .mknod          = fuse_mknod,
1298         .permission     = fuse_permission,
1299         .getattr        = fuse_getattr,
1300         .setxattr       = fuse_setxattr,
1301         .getxattr       = fuse_getxattr,
1302         .listxattr      = fuse_listxattr,
1303         .removexattr    = fuse_removexattr,
1304 };
1305
1306 static const struct file_operations fuse_dir_operations = {
1307         .llseek         = generic_file_llseek,
1308         .read           = generic_read_dir,
1309         .readdir        = fuse_readdir,
1310         .open           = fuse_dir_open,
1311         .release        = fuse_dir_release,
1312         .fsync          = fuse_dir_fsync,
1313 };
1314
1315 static const struct inode_operations fuse_common_inode_operations = {
1316         .setattr        = fuse_setattr,
1317         .permission     = fuse_permission,
1318         .getattr        = fuse_getattr,
1319         .setxattr       = fuse_setxattr,
1320         .getxattr       = fuse_getxattr,
1321         .listxattr      = fuse_listxattr,
1322         .removexattr    = fuse_removexattr,
1323 };
1324
1325 static const struct inode_operations fuse_symlink_inode_operations = {
1326         .setattr        = fuse_setattr,
1327         .follow_link    = fuse_follow_link,
1328         .put_link       = fuse_put_link,
1329         .readlink       = generic_readlink,
1330         .getattr        = fuse_getattr,
1331         .setxattr       = fuse_setxattr,
1332         .getxattr       = fuse_getxattr,
1333         .listxattr      = fuse_listxattr,
1334         .removexattr    = fuse_removexattr,
1335 };
1336
1337 void fuse_init_common(struct inode *inode)
1338 {
1339         inode->i_op = &fuse_common_inode_operations;
1340 }
1341
1342 void fuse_init_dir(struct inode *inode)
1343 {
1344         inode->i_op = &fuse_dir_inode_operations;
1345         inode->i_fop = &fuse_dir_operations;
1346 }
1347
1348 void fuse_init_symlink(struct inode *inode)
1349 {
1350         inode->i_op = &fuse_symlink_inode_operations;
1351 }