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 static inline unsigned long time_to_jiffies(unsigned long sec,
  18                                             unsigned long nsec)
  19 {
  20         struct timespec ts = {sec, nsec};
  21         return jiffies + timespec_to_jiffies(&ts);
  22 }
  23
  24 static void fuse_lookup_init(struct fuse_req *req, struct inode *dir,
  25                              struct dentry *entry,
  26                              struct fuse_entry_out *outarg)
  27 {
  28         req->in.h.opcode = FUSE_LOOKUP;
  29         req->in.h.nodeid = get_node_id(dir);
  30         req->inode = dir;
  31         req->in.numargs = 1;
  32         req->in.args[0].size = entry->d_name.len + 1;
  33         req->in.args[0].value = entry->d_name.name;
  34         req->out.numargs = 1;
  35         req->out.args[0].size = sizeof(struct fuse_entry_out);
  36         req->out.args[0].value = outarg;
  37 }
  38
  39 static int fuse_dentry_revalidate(struct dentry *entry, struct nameidata *nd)
  40 {
  41         if (!entry->d_inode || is_bad_inode(entry->d_inode))
  42                 return 0;
  43         else if (time_after(jiffies, entry->d_time)) {
  44                 int err;
  45                 struct fuse_entry_out outarg;
  46                 struct inode *inode = entry->d_inode;
  47                 struct fuse_inode *fi = get_fuse_inode(inode);
  48                 struct fuse_conn *fc = get_fuse_conn(inode);
  49                 struct fuse_req *req = fuse_get_request_nonint(fc);
  50                 if (!req)
  51                         return 0;
  52
  53                 fuse_lookup_init(req, entry->d_parent->d_inode, entry, &outarg);
  54                 request_send_nonint(fc, req);
  55                 err = req->out.h.error;
  56                 if (!err) {
  57                         if (outarg.nodeid != get_node_id(inode)) {
  58                                 fuse_send_forget(fc, req, outarg.nodeid, 1);
  59                                 return 0;
  60                         }
  61                         fi->nlookup ++;
  62                 }
  63                 fuse_put_request(fc, req);
  64                 if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
  65                         return 0;
  66
  67                 fuse_change_attributes(inode, &outarg.attr);
  68                 entry->d_time = time_to_jiffies(outarg.entry_valid,
  69                                                 outarg.entry_valid_nsec);
  70                 fi->i_time = time_to_jiffies(outarg.attr_valid,
  71                                              outarg.attr_valid_nsec);
  72         }
  73         return 1;
  74 }
  75
  76 static struct dentry_operations fuse_dentry_operations = {
  77         .d_revalidate   = fuse_dentry_revalidate,
  78 };
  79
  80 static int fuse_lookup_iget(struct inode *dir, struct dentry *entry,
  81                             struct inode **inodep)
  82 {
  83         int err;
  84         struct fuse_entry_out outarg;
  85         struct inode *inode = NULL;
  86         struct fuse_conn *fc = get_fuse_conn(dir);
  87         struct fuse_req *req;
  88
  89         if (entry->d_name.len > FUSE_NAME_MAX)
  90                 return -ENAMETOOLONG;
  91
  92         req = fuse_get_request(fc);
  93         if (!req)
  94                 return -ERESTARTNOINTR;
  95
  96         fuse_lookup_init(req, dir, entry, &outarg);
  97         request_send(fc, req);
  98         err = req->out.h.error;
  99         if (!err) {
 100                 inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
 101                                   &outarg.attr);
 102                 if (!inode) {
 103                         fuse_send_forget(fc, req, outarg.nodeid, 1);
 104                         return -ENOMEM;
 105                 }
 106         }
 107         fuse_put_request(fc, req);
 108         if (err && err != -ENOENT)
 109                 return err;
 110
 111         if (inode) {
 112                 struct fuse_inode *fi = get_fuse_inode(inode);
 113                 entry->d_time = time_to_jiffies(outarg.entry_valid,
 114                                                 outarg.entry_valid_nsec);
 115                 fi->i_time = time_to_jiffies(outarg.attr_valid,
 116                                              outarg.attr_valid_nsec);
 117         }
 118
 119         entry->d_op = &fuse_dentry_operations;
 120         *inodep = inode;
 121         return 0;
 122 }
 123
 124 void fuse_invalidate_attr(struct inode *inode)
 125 {
 126         get_fuse_inode(inode)->i_time = jiffies - 1;
 127 }
 128
 129 static void fuse_invalidate_entry(struct dentry *entry)
 130 {
 131         d_invalidate(entry);
 132         entry->d_time = jiffies - 1;
 133 }
 134
 135 static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
 136                             struct inode *dir, struct dentry *entry,
 137                             int mode)
 138 {
 139         struct fuse_entry_out outarg;
 140         struct inode *inode;
 141         struct fuse_inode *fi;
 142         int err;
 143
 144         req->in.h.nodeid = get_node_id(dir);
 145         req->inode = dir;
 146         req->out.numargs = 1;
 147         req->out.args[0].size = sizeof(outarg);
 148         req->out.args[0].value = &outarg;
 149         request_send(fc, req);
 150         err = req->out.h.error;
 151         if (err) {
 152                 fuse_put_request(fc, req);
 153                 return err;
 154         }
 155         inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
 156                           &outarg.attr);
 157         if (!inode) {
 158                 fuse_send_forget(fc, req, outarg.nodeid, 1);
 159                 return -ENOMEM;
 160         }
 161         fuse_put_request(fc, req);
 162
 163         /* Don't allow userspace to do really stupid things... */
 164         if ((inode->i_mode ^ mode) & S_IFMT) {
 165                 iput(inode);
 166                 return -EIO;
 167         }
 168
 169         entry->d_time = time_to_jiffies(outarg.entry_valid,
 170                                         outarg.entry_valid_nsec);
 171
 172         fi = get_fuse_inode(inode);
 173         fi->i_time = time_to_jiffies(outarg.attr_valid,
 174                                      outarg.attr_valid_nsec);
 175
 176         d_instantiate(entry, inode);
 177         fuse_invalidate_attr(dir);
 178         return 0;
 179 }
 180
 181 static int fuse_mknod(struct inode *dir, struct dentry *entry, int mode,
 182                       dev_t rdev)
 183 {
 184         struct fuse_mknod_in inarg;
 185         struct fuse_conn *fc = get_fuse_conn(dir);
 186         struct fuse_req *req = fuse_get_request(fc);
 187         if (!req)
 188                 return -ERESTARTNOINTR;
 189
 190         memset(&inarg, 0, sizeof(inarg));
 191         inarg.mode = mode;
 192         inarg.rdev = new_encode_dev(rdev);
 193         req->in.h.opcode = FUSE_MKNOD;
 194         req->in.numargs = 2;
 195         req->in.args[0].size = sizeof(inarg);
 196         req->in.args[0].value = &inarg;
 197         req->in.args[1].size = entry->d_name.len + 1;
 198         req->in.args[1].value = entry->d_name.name;
 199         return create_new_entry(fc, req, dir, entry, mode);
 200 }
 201
 202 static int fuse_create(struct inode *dir, struct dentry *entry, int mode,
 203                        struct nameidata *nd)
 204 {
 205         return fuse_mknod(dir, entry, mode, 0);
 206 }
 207
 208 static int fuse_mkdir(struct inode *dir, struct dentry *entry, int mode)
 209 {
 210         struct fuse_mkdir_in inarg;
 211         struct fuse_conn *fc = get_fuse_conn(dir);
 212         struct fuse_req *req = fuse_get_request(fc);
 213         if (!req)
 214                 return -ERESTARTNOINTR;
 215
 216         memset(&inarg, 0, sizeof(inarg));
 217         inarg.mode = mode;
 218         req->in.h.opcode = FUSE_MKDIR;
 219         req->in.numargs = 2;
 220         req->in.args[0].size = sizeof(inarg);
 221         req->in.args[0].value = &inarg;
 222         req->in.args[1].size = entry->d_name.len + 1;
 223         req->in.args[1].value = entry->d_name.name;
 224         return create_new_entry(fc, req, dir, entry, S_IFDIR);
 225 }
 226
 227 static int fuse_symlink(struct inode *dir, struct dentry *entry,
 228                         const char *link)
 229 {
 230         struct fuse_conn *fc = get_fuse_conn(dir);
 231         unsigned len = strlen(link) + 1;
 232         struct fuse_req *req;
 233
 234         if (len > FUSE_SYMLINK_MAX)
 235                 return -ENAMETOOLONG;
 236
 237         req = fuse_get_request(fc);
 238         if (!req)
 239                 return -ERESTARTNOINTR;
 240
 241         req->in.h.opcode = FUSE_SYMLINK;
 242         req->in.numargs = 2;
 243         req->in.args[0].size = entry->d_name.len + 1;
 244         req->in.args[0].value = entry->d_name.name;
 245         req->in.args[1].size = len;
 246         req->in.args[1].value = link;
 247         return create_new_entry(fc, req, dir, entry, S_IFLNK);
 248 }
 249
 250 static int fuse_unlink(struct inode *dir, struct dentry *entry)
 251 {
 252         int err;
 253         struct fuse_conn *fc = get_fuse_conn(dir);
 254         struct fuse_req *req = fuse_get_request(fc);
 255         if (!req)
 256                 return -ERESTARTNOINTR;
 257
 258         req->in.h.opcode = FUSE_UNLINK;
 259         req->in.h.nodeid = get_node_id(dir);
 260         req->inode = dir;
 261         req->in.numargs = 1;
 262         req->in.args[0].size = entry->d_name.len + 1;
 263         req->in.args[0].value = entry->d_name.name;
 264         request_send(fc, req);
 265         err = req->out.h.error;
 266         fuse_put_request(fc, req);
 267         if (!err) {
 268                 struct inode *inode = entry->d_inode;
 269
 270                 /* Set nlink to zero so the inode can be cleared, if
 271                    the inode does have more links this will be
 272                    discovered at the next lookup/getattr */
 273                 inode->i_nlink = 0;
 274                 fuse_invalidate_attr(inode);
 275                 fuse_invalidate_attr(dir);
 276         } else if (err == -EINTR)
 277                 fuse_invalidate_entry(entry);
 278         return err;
 279 }
 280
 281 static int fuse_rmdir(struct inode *dir, struct dentry *entry)
 282 {
 283         int err;
 284         struct fuse_conn *fc = get_fuse_conn(dir);
 285         struct fuse_req *req = fuse_get_request(fc);
 286         if (!req)
 287                 return -ERESTARTNOINTR;
 288
 289         req->in.h.opcode = FUSE_RMDIR;
 290         req->in.h.nodeid = get_node_id(dir);
 291         req->inode = dir;
 292         req->in.numargs = 1;
 293         req->in.args[0].size = entry->d_name.len + 1;
 294         req->in.args[0].value = entry->d_name.name;
 295         request_send(fc, req);
 296         err = req->out.h.error;
 297         fuse_put_request(fc, req);
 298         if (!err) {
 299                 entry->d_inode->i_nlink = 0;
 300                 fuse_invalidate_attr(dir);
 301         } else if (err == -EINTR)
 302                 fuse_invalidate_entry(entry);
 303         return err;
 304 }
 305
 306 static int fuse_rename(struct inode *olddir, struct dentry *oldent,
 307                        struct inode *newdir, struct dentry *newent)
 308 {
 309         int err;
 310         struct fuse_rename_in inarg;
 311         struct fuse_conn *fc = get_fuse_conn(olddir);
 312         struct fuse_req *req = fuse_get_request(fc);
 313         if (!req)
 314                 return -ERESTARTNOINTR;
 315
 316         memset(&inarg, 0, sizeof(inarg));
 317         inarg.newdir = get_node_id(newdir);
 318         req->in.h.opcode = FUSE_RENAME;
 319         req->in.h.nodeid = get_node_id(olddir);
 320         req->inode = olddir;
 321         req->inode2 = newdir;
 322         req->in.numargs = 3;
 323         req->in.args[0].size = sizeof(inarg);
 324         req->in.args[0].value = &inarg;
 325         req->in.args[1].size = oldent->d_name.len + 1;
 326         req->in.args[1].value = oldent->d_name.name;
 327         req->in.args[2].size = newent->d_name.len + 1;
 328         req->in.args[2].value = newent->d_name.name;
 329         request_send(fc, req);
 330         err = req->out.h.error;
 331         fuse_put_request(fc, req);
 332         if (!err) {
 333                 fuse_invalidate_attr(olddir);
 334                 if (olddir != newdir)
 335                         fuse_invalidate_attr(newdir);
 336         } else if (err == -EINTR) {
 337                 /* If request was interrupted, DEITY only knows if the
 338                    rename actually took place.  If the invalidation
 339                    fails (e.g. some process has CWD under the renamed
 340                    directory), then there can be inconsistency between
 341                    the dcache and the real filesystem.  Tough luck. */
 342                 fuse_invalidate_entry(oldent);
 343                 if (newent->d_inode)
 344                         fuse_invalidate_entry(newent);
 345         }
 346
 347         return err;
 348 }
 349
 350 static int fuse_link(struct dentry *entry, struct inode *newdir,
 351                      struct dentry *newent)
 352 {
 353         int err;
 354         struct fuse_link_in inarg;
 355         struct inode *inode = entry->d_inode;
 356         struct fuse_conn *fc = get_fuse_conn(inode);
 357         struct fuse_req *req = fuse_get_request(fc);
 358         if (!req)
 359                 return -ERESTARTNOINTR;
 360
 361         memset(&inarg, 0, sizeof(inarg));
 362         inarg.oldnodeid = get_node_id(inode);
 363         req->in.h.opcode = FUSE_LINK;
 364         req->inode2 = inode;
 365         req->in.numargs = 2;
 366         req->in.args[0].size = sizeof(inarg);
 367         req->in.args[0].value = &inarg;
 368         req->in.args[1].size = newent->d_name.len + 1;
 369         req->in.args[1].value = newent->d_name.name;
 370         err = create_new_entry(fc, req, newdir, newent, inode->i_mode);
 371         /* Contrary to "normal" filesystems it can happen that link
 372            makes two "logical" inodes point to the same "physical"
 373            inode.  We invalidate the attributes of the old one, so it
 374            will reflect changes in the backing inode (link count,
 375            etc.)
 376         */
 377         if (!err || err == -EINTR)
 378                 fuse_invalidate_attr(inode);
 379         return err;
 380 }
 381
 382 int fuse_do_getattr(struct inode *inode)
 383 {
 384         int err;
 385         struct fuse_attr_out arg;
 386         struct fuse_conn *fc = get_fuse_conn(inode);
 387         struct fuse_req *req = fuse_get_request(fc);
 388         if (!req)
 389                 return -ERESTARTNOINTR;
 390
 391         req->in.h.opcode = FUSE_GETATTR;
 392         req->in.h.nodeid = get_node_id(inode);
 393         req->inode = inode;
 394         req->out.numargs = 1;
 395         req->out.args[0].size = sizeof(arg);
 396         req->out.args[0].value = &arg;
 397         request_send(fc, req);
 398         err = req->out.h.error;
 399         fuse_put_request(fc, req);
 400         if (!err) {
 401                 if ((inode->i_mode ^ arg.attr.mode) & S_IFMT) {
 402                         make_bad_inode(inode);
 403                         err = -EIO;
 404                 } else {
 405                         struct fuse_inode *fi = get_fuse_inode(inode);
 406                         fuse_change_attributes(inode, &arg.attr);
 407                         fi->i_time = time_to_jiffies(arg.attr_valid,
 408                                                      arg.attr_valid_nsec);
 409                 }
 410         }
 411         return err;
 412 }
 413
 414 static int fuse_revalidate(struct dentry *entry)
 415 {
 416         struct inode *inode = entry->d_inode;
 417         struct fuse_inode *fi = get_fuse_inode(inode);
 418         struct fuse_conn *fc = get_fuse_conn(inode);
 419
 420         if (get_node_id(inode) == FUSE_ROOT_ID) {
 421                 if (current->fsuid != fc->user_id)
 422                         return -EACCES;
 423         } else if (time_before_eq(jiffies, fi->i_time))
 424                 return 0;
 425
 426         return fuse_do_getattr(inode);
 427 }
 428
 429 static int fuse_permission(struct inode *inode, int mask, struct nameidata *nd)
 430 {
 431         struct fuse_conn *fc = get_fuse_conn(inode);
 432
 433         if (current->fsuid != fc->user_id)
 434                 return -EACCES;
 435         else {
 436                 int mode = inode->i_mode;
 437                 if ((mask & MAY_WRITE) && IS_RDONLY(inode) &&
 438                     (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
 439                         return -EROFS;
 440                 if ((mask & MAY_EXEC) && !S_ISDIR(mode) && !(mode & S_IXUGO))
 441                         return -EACCES;
 442                 return 0;
 443         }
 444 }
 445
 446 static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
 447                          void *dstbuf, filldir_t filldir)
 448 {
 449         while (nbytes >= FUSE_NAME_OFFSET) {
 450                 struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
 451                 size_t reclen = FUSE_DIRENT_SIZE(dirent);
 452                 int over;
 453                 if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
 454                         return -EIO;
 455                 if (reclen > nbytes)
 456                         break;
 457
 458                 over = filldir(dstbuf, dirent->name, dirent->namelen,
 459                                file->f_pos, dirent->ino, dirent->type);
 460                 if (over)
 461                         break;
 462
 463                 buf += reclen;
 464                 nbytes -= reclen;
 465                 file->f_pos = dirent->off;
 466         }
 467
 468         return 0;
 469 }
 470
 471 static int fuse_checkdir(struct file *cfile, struct file *file)
 472 {
 473         struct inode *inode;
 474         if (!cfile)
 475                 return -EIO;
 476         inode = cfile->f_dentry->d_inode;
 477         if (!S_ISREG(inode->i_mode)) {
 478                 fput(cfile);
 479                 return -EIO;
 480         }
 481
 482         file->private_data = cfile;
 483         return 0;
 484 }
 485
 486 static int fuse_getdir(struct file *file)
 487 {
 488         struct inode *inode = file->f_dentry->d_inode;
 489         struct fuse_conn *fc = get_fuse_conn(inode);
 490         struct fuse_req *req = fuse_get_request(fc);
 491         struct fuse_getdir_out_i outarg;
 492         int err;
 493
 494         if (!req)
 495                 return -ERESTARTNOINTR;
 496
 497         req->in.h.opcode = FUSE_GETDIR;
 498         req->in.h.nodeid = get_node_id(inode);
 499         req->inode = inode;
 500         req->out.numargs = 1;
 501         req->out.args[0].size = sizeof(struct fuse_getdir_out);
 502         req->out.args[0].value = &outarg;
 503         request_send(fc, req);
 504         err = req->out.h.error;
 505         fuse_put_request(fc, req);
 506         if (!err)
 507                 err = fuse_checkdir(outarg.file, file);
 508         return err;
 509 }
 510
 511 static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
 512 {
 513         struct file *cfile = file->private_data;
 514         char *buf;
 515         int ret;
 516
 517         if (!cfile) {
 518                 ret = fuse_getdir(file);
 519                 if (ret)
 520                         return ret;
 521
 522                 cfile = file->private_data;
 523         }
 524
 525         buf = (char *) __get_free_page(GFP_KERNEL);
 526         if (!buf)
 527                 return -ENOMEM;
 528
 529         ret = kernel_read(cfile, file->f_pos, buf, PAGE_SIZE);
 530         if (ret > 0)
 531                 ret = parse_dirfile(buf, ret, file, dstbuf, filldir);
 532
 533         free_page((unsigned long) buf);
 534         return ret;
 535 }
 536
 537 static char *read_link(struct dentry *dentry)
 538 {
 539         struct inode *inode = dentry->d_inode;
 540         struct fuse_conn *fc = get_fuse_conn(inode);
 541         struct fuse_req *req = fuse_get_request(fc);
 542         char *link;
 543
 544         if (!req)
 545                 return ERR_PTR(-ERESTARTNOINTR);
 546
 547         link = (char *) __get_free_page(GFP_KERNEL);
 548         if (!link) {
 549                 link = ERR_PTR(-ENOMEM);
 550                 goto out;
 551         }
 552         req->in.h.opcode = FUSE_READLINK;
 553         req->in.h.nodeid = get_node_id(inode);
 554         req->inode = inode;
 555         req->out.argvar = 1;
 556         req->out.numargs = 1;
 557         req->out.args[0].size = PAGE_SIZE - 1;
 558         req->out.args[0].value = link;
 559         request_send(fc, req);
 560         if (req->out.h.error) {
 561                 free_page((unsigned long) link);
 562                 link = ERR_PTR(req->out.h.error);
 563         } else
 564                 link[req->out.args[0].size] = '\0';
 565  out:
 566         fuse_put_request(fc, req);
 567         return link;
 568 }
 569
 570 static void free_link(char *link)
 571 {
 572         if (!IS_ERR(link))
 573                 free_page((unsigned long) link);
 574 }
 575
 576 static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
 577 {
 578         nd_set_link(nd, read_link(dentry));
 579         return NULL;
 580 }
 581
 582 static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
 583 {
 584         free_link(nd_get_link(nd));
 585 }
 586
 587 static int fuse_dir_open(struct inode *inode, struct file *file)
 588 {
 589         file->private_data = NULL;
 590         return 0;
 591 }
 592
 593 static int fuse_dir_release(struct inode *inode, struct file *file)
 594 {
 595         struct file *cfile = file->private_data;
 596
 597         if (cfile)
 598                 fput(cfile);
 599
 600         return 0;
 601 }
 602
 603 static unsigned iattr_to_fattr(struct iattr *iattr, struct fuse_attr *fattr)
 604 {
 605         unsigned ivalid = iattr->ia_valid;
 606         unsigned fvalid = 0;
 607
 608         memset(fattr, 0, sizeof(*fattr));
 609
 610         if (ivalid & ATTR_MODE)
 611                 fvalid |= FATTR_MODE,   fattr->mode = iattr->ia_mode;
 612         if (ivalid & ATTR_UID)
 613                 fvalid |= FATTR_UID,    fattr->uid = iattr->ia_uid;
 614         if (ivalid & ATTR_GID)
 615                 fvalid |= FATTR_GID,    fattr->gid = iattr->ia_gid;
 616         if (ivalid & ATTR_SIZE)
 617                 fvalid |= FATTR_SIZE,   fattr->size = iattr->ia_size;
 618         /* You can only _set_ these together (they may change by themselves) */
 619         if ((ivalid & (ATTR_ATIME | ATTR_MTIME)) == (ATTR_ATIME | ATTR_MTIME)) {
 620                 fvalid |= FATTR_ATIME | FATTR_MTIME;
 621                 fattr->atime = iattr->ia_atime.tv_sec;
 622                 fattr->mtime = iattr->ia_mtime.tv_sec;
 623         }
 624
 625         return fvalid;
 626 }
 627
 628 static int fuse_setattr(struct dentry *entry, struct iattr *attr)
 629 {
 630         struct inode *inode = entry->d_inode;
 631         struct fuse_conn *fc = get_fuse_conn(inode);
 632         struct fuse_inode *fi = get_fuse_inode(inode);
 633         struct fuse_req *req;
 634         struct fuse_setattr_in inarg;
 635         struct fuse_attr_out outarg;
 636         int err;
 637         int is_truncate = 0;
 638
 639         if (attr->ia_valid & ATTR_SIZE) {
 640                 unsigned long limit;
 641                 is_truncate = 1;
 642                 limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
 643                 if (limit != RLIM_INFINITY && attr->ia_size > (loff_t) limit) {
 644                         send_sig(SIGXFSZ, current, 0);
 645                         return -EFBIG;
 646                 }
 647         }
 648
 649         req = fuse_get_request(fc);
 650         if (!req)
 651                 return -ERESTARTNOINTR;
 652
 653         memset(&inarg, 0, sizeof(inarg));
 654         inarg.valid = iattr_to_fattr(attr, &inarg.attr);
 655         req->in.h.opcode = FUSE_SETATTR;
 656         req->in.h.nodeid = get_node_id(inode);
 657         req->inode = inode;
 658         req->in.numargs = 1;
 659         req->in.args[0].size = sizeof(inarg);
 660         req->in.args[0].value = &inarg;
 661         req->out.numargs = 1;
 662         req->out.args[0].size = sizeof(outarg);
 663         req->out.args[0].value = &outarg;
 664         request_send(fc, req);
 665         err = req->out.h.error;
 666         fuse_put_request(fc, req);
 667         if (!err) {
 668                 if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
 669                         make_bad_inode(inode);
 670                         err = -EIO;
 671                 } else {
 672                         if (is_truncate) {
 673                                 loff_t origsize = i_size_read(inode);
 674                                 i_size_write(inode, outarg.attr.size);
 675                                 if (origsize > outarg.attr.size)
 676                                         vmtruncate(inode, outarg.attr.size);
 677                         }
 678                         fuse_change_attributes(inode, &outarg.attr);
 679                         fi->i_time = time_to_jiffies(outarg.attr_valid,
 680                                                      outarg.attr_valid_nsec);
 681                 }
 682         } else if (err == -EINTR)
 683                 fuse_invalidate_attr(inode);
 684
 685         return err;
 686 }
 687
 688 static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
 689                         struct kstat *stat)
 690 {
 691         struct inode *inode = entry->d_inode;
 692         int err = fuse_revalidate(entry);
 693         if (!err)
 694                 generic_fillattr(inode, stat);
 695
 696         return err;
 697 }
 698
 699 static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
 700                                   struct nameidata *nd)
 701 {
 702         struct inode *inode;
 703         int err = fuse_lookup_iget(dir, entry, &inode);
 704         if (err)
 705                 return ERR_PTR(err);
 706         if (inode && S_ISDIR(inode->i_mode)) {
 707                 /* Don't allow creating an alias to a directory  */
 708                 struct dentry *alias = d_find_alias(inode);
 709                 if (alias && !(alias->d_flags & DCACHE_DISCONNECTED)) {
 710                         dput(alias);
 711                         iput(inode);
 712                         return ERR_PTR(-EIO);
 713                 }
 714         }
 715         return d_splice_alias(inode, entry);
 716 }
 717
 718 static struct inode_operations fuse_dir_inode_operations = {
 719         .lookup         = fuse_lookup,
 720         .mkdir          = fuse_mkdir,
 721         .symlink        = fuse_symlink,
 722         .unlink         = fuse_unlink,
 723         .rmdir          = fuse_rmdir,
 724         .rename         = fuse_rename,
 725         .link           = fuse_link,
 726         .setattr        = fuse_setattr,
 727         .create         = fuse_create,
 728         .mknod          = fuse_mknod,
 729         .permission     = fuse_permission,
 730         .getattr        = fuse_getattr,
 731 };
 732
 733 static struct file_operations fuse_dir_operations = {
 734         .llseek         = generic_file_llseek,
 735         .read           = generic_read_dir,
 736         .readdir        = fuse_readdir,
 737         .open           = fuse_dir_open,
 738         .release        = fuse_dir_release,
 739 };
 740
 741 static struct inode_operations fuse_common_inode_operations = {
 742         .setattr        = fuse_setattr,
 743         .permission     = fuse_permission,
 744         .getattr        = fuse_getattr,
 745 };
 746
 747 static struct inode_operations fuse_symlink_inode_operations = {
 748         .setattr        = fuse_setattr,
 749         .follow_link    = fuse_follow_link,
 750         .put_link       = fuse_put_link,
 751         .readlink       = generic_readlink,
 752         .getattr        = fuse_getattr,
 753 };
 754
 755 void fuse_init_common(struct inode *inode)
 756 {
 757         inode->i_op = &fuse_common_inode_operations;
 758 }
 759
 760 void fuse_init_dir(struct inode *inode)
 761 {
 762         inode->i_op = &fuse_dir_inode_operations;
 763         inode->i_fop = &fuse_dir_operations;
 764 }
 765
 766 void fuse_init_symlink(struct inode *inode)
 767 {
 768         inode->i_op = &fuse_symlink_inode_operations;
 769 }