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