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