linux/fs/fuse/dir.c
<<
>>
Prefs
   1/*
   2  FUSE: Filesystem in Userspace
   3  Copyright (C) 2001-2008  Miklos Szeredi <miklos@szeredi.hu>
   4
   5  This program can be distributed under the terms of the GNU GPL.
   6  See the file COPYING.
   7*/
   8
   9#include "fuse_i.h"
  10
  11#include <linux/pagemap.h>
  12#include <linux/file.h>
  13#include <linux/sched.h>
  14#include <linux/namei.h>
  15#include <linux/slab.h>
  16
  17#if BITS_PER_LONG >= 64
  18static inline void fuse_dentry_settime(struct dentry *entry, u64 time)
  19{
  20        entry->d_time = time;
  21}
  22
  23static inline u64 fuse_dentry_time(struct dentry *entry)
  24{
  25        return entry->d_time;
  26}
  27#else
  28/*
  29 * On 32 bit archs store the high 32 bits of time in d_fsdata
  30 */
  31static void fuse_dentry_settime(struct dentry *entry, u64 time)
  32{
  33        entry->d_time = time;
  34        entry->d_fsdata = (void *) (unsigned long) (time >> 32);
  35}
  36
  37static u64 fuse_dentry_time(struct dentry *entry)
  38{
  39        return (u64) entry->d_time +
  40                ((u64) (unsigned long) entry->d_fsdata << 32);
  41}
  42#endif
  43
  44/*
  45 * FUSE caches dentries and attributes with separate timeout.  The
  46 * time in jiffies until the dentry/attributes are valid is stored in
  47 * dentry->d_time and fuse_inode->i_time respectively.
  48 */
  49
  50/*
  51 * Calculate the time in jiffies until a dentry/attributes are valid
  52 */
  53static u64 time_to_jiffies(unsigned long sec, unsigned long nsec)
  54{
  55        if (sec || nsec) {
  56                struct timespec ts = {sec, nsec};
  57                return get_jiffies_64() + timespec_to_jiffies(&ts);
  58        } else
  59                return 0;
  60}
  61
  62/*
  63 * Set dentry and possibly attribute timeouts from the lookup/mk*
  64 * replies
  65 */
  66static void fuse_change_entry_timeout(struct dentry *entry,
  67                                      struct fuse_entry_out *o)
  68{
  69        fuse_dentry_settime(entry,
  70                time_to_jiffies(o->entry_valid, o->entry_valid_nsec));
  71}
  72
  73static u64 attr_timeout(struct fuse_attr_out *o)
  74{
  75        return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
  76}
  77
  78static u64 entry_attr_timeout(struct fuse_entry_out *o)
  79{
  80        return time_to_jiffies(o->attr_valid, o->attr_valid_nsec);
  81}
  82
  83/*
  84 * Mark the attributes as stale, so that at the next call to
  85 * ->getattr() they will be fetched from userspace
  86 */
  87void fuse_invalidate_attr(struct inode *inode)
  88{
  89        get_fuse_inode(inode)->i_time = 0;
  90}
  91
  92/*
  93 * Just mark the entry as stale, so that a next attempt to look it up
  94 * will result in a new lookup call to userspace
  95 *
  96 * This is called when a dentry is about to become negative and the
  97 * timeout is unknown (unlink, rmdir, rename and in some cases
  98 * lookup)
  99 */
 100void fuse_invalidate_entry_cache(struct dentry *entry)
 101{
 102        fuse_dentry_settime(entry, 0);
 103}
 104
 105/*
 106 * Same as fuse_invalidate_entry_cache(), but also try to remove the
 107 * dentry from the hash
 108 */
 109static void fuse_invalidate_entry(struct dentry *entry)
 110{
 111        d_invalidate(entry);
 112        fuse_invalidate_entry_cache(entry);
 113}
 114
 115static void fuse_lookup_init(struct fuse_conn *fc, struct fuse_req *req,
 116                             u64 nodeid, struct qstr *name,
 117                             struct fuse_entry_out *outarg)
 118{
 119        memset(outarg, 0, sizeof(struct fuse_entry_out));
 120        req->in.h.opcode = FUSE_LOOKUP;
 121        req->in.h.nodeid = nodeid;
 122        req->in.numargs = 1;
 123        req->in.args[0].size = name->len + 1;
 124        req->in.args[0].value = name->name;
 125        req->out.numargs = 1;
 126        if (fc->minor < 9)
 127                req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
 128        else
 129                req->out.args[0].size = sizeof(struct fuse_entry_out);
 130        req->out.args[0].value = outarg;
 131}
 132
 133u64 fuse_get_attr_version(struct fuse_conn *fc)
 134{
 135        u64 curr_version;
 136
 137        /*
 138         * The spin lock isn't actually needed on 64bit archs, but we
 139         * don't yet care too much about such optimizations.
 140         */
 141        spin_lock(&fc->lock);
 142        curr_version = fc->attr_version;
 143        spin_unlock(&fc->lock);
 144
 145        return curr_version;
 146}
 147
 148/*
 149 * Check whether the dentry is still valid
 150 *
 151 * If the entry validity timeout has expired and the dentry is
 152 * positive, try to redo the lookup.  If the lookup results in a
 153 * different inode, then let the VFS invalidate the dentry and redo
 154 * the lookup once more.  If the lookup results in the same inode,
 155 * then refresh the attributes, timeouts and mark the dentry valid.
 156 */
 157static int fuse_dentry_revalidate(struct dentry *entry, unsigned int flags)
 158{
 159        struct inode *inode;
 160
 161        inode = ACCESS_ONCE(entry->d_inode);
 162        if (inode && is_bad_inode(inode))
 163                return 0;
 164        else if (fuse_dentry_time(entry) < get_jiffies_64()) {
 165                int err;
 166                struct fuse_entry_out outarg;
 167                struct fuse_conn *fc;
 168                struct fuse_req *req;
 169                struct fuse_forget_link *forget;
 170                struct dentry *parent;
 171                u64 attr_version;
 172
 173                /* For negative dentries, always do a fresh lookup */
 174                if (!inode)
 175                        return 0;
 176
 177                if (flags & LOOKUP_RCU)
 178                        return -ECHILD;
 179
 180                fc = get_fuse_conn(inode);
 181                req = fuse_get_req(fc);
 182                if (IS_ERR(req))
 183                        return 0;
 184
 185                forget = fuse_alloc_forget();
 186                if (!forget) {
 187                        fuse_put_request(fc, req);
 188                        return 0;
 189                }
 190
 191                attr_version = fuse_get_attr_version(fc);
 192
 193                parent = dget_parent(entry);
 194                fuse_lookup_init(fc, req, get_node_id(parent->d_inode),
 195                                 &entry->d_name, &outarg);
 196                fuse_request_send(fc, req);
 197                dput(parent);
 198                err = req->out.h.error;
 199                fuse_put_request(fc, req);
 200                /* Zero nodeid is same as -ENOENT */
 201                if (!err && !outarg.nodeid)
 202                        err = -ENOENT;
 203                if (!err) {
 204                        struct fuse_inode *fi = get_fuse_inode(inode);
 205                        if (outarg.nodeid != get_node_id(inode)) {
 206                                fuse_queue_forget(fc, forget, outarg.nodeid, 1);
 207                                return 0;
 208                        }
 209                        spin_lock(&fc->lock);
 210                        fi->nlookup++;
 211                        spin_unlock(&fc->lock);
 212                }
 213                kfree(forget);
 214                if (err || (outarg.attr.mode ^ inode->i_mode) & S_IFMT)
 215                        return 0;
 216
 217                fuse_change_attributes(inode, &outarg.attr,
 218                                       entry_attr_timeout(&outarg),
 219                                       attr_version);
 220                fuse_change_entry_timeout(entry, &outarg);
 221        }
 222        return 1;
 223}
 224
 225static int invalid_nodeid(u64 nodeid)
 226{
 227        return !nodeid || nodeid == FUSE_ROOT_ID;
 228}
 229
 230const struct dentry_operations fuse_dentry_operations = {
 231        .d_revalidate   = fuse_dentry_revalidate,
 232};
 233
 234int fuse_valid_type(int m)
 235{
 236        return S_ISREG(m) || S_ISDIR(m) || S_ISLNK(m) || S_ISCHR(m) ||
 237                S_ISBLK(m) || S_ISFIFO(m) || S_ISSOCK(m);
 238}
 239
 240/*
 241 * Add a directory inode to a dentry, ensuring that no other dentry
 242 * refers to this inode.  Called with fc->inst_mutex.
 243 */
 244static struct dentry *fuse_d_add_directory(struct dentry *entry,
 245                                           struct inode *inode)
 246{
 247        struct dentry *alias = d_find_alias(inode);
 248        if (alias && !(alias->d_flags & DCACHE_DISCONNECTED)) {
 249                /* This tries to shrink the subtree below alias */
 250                fuse_invalidate_entry(alias);
 251                dput(alias);
 252                if (!hlist_empty(&inode->i_dentry))
 253                        return ERR_PTR(-EBUSY);
 254        } else {
 255                dput(alias);
 256        }
 257        return d_splice_alias(inode, entry);
 258}
 259
 260int fuse_lookup_name(struct super_block *sb, u64 nodeid, struct qstr *name,
 261                     struct fuse_entry_out *outarg, struct inode **inode)
 262{
 263        struct fuse_conn *fc = get_fuse_conn_super(sb);
 264        struct fuse_req *req;
 265        struct fuse_forget_link *forget;
 266        u64 attr_version;
 267        int err;
 268
 269        *inode = NULL;
 270        err = -ENAMETOOLONG;
 271        if (name->len > FUSE_NAME_MAX)
 272                goto out;
 273
 274        req = fuse_get_req(fc);
 275        err = PTR_ERR(req);
 276        if (IS_ERR(req))
 277                goto out;
 278
 279        forget = fuse_alloc_forget();
 280        err = -ENOMEM;
 281        if (!forget) {
 282                fuse_put_request(fc, req);
 283                goto out;
 284        }
 285
 286        attr_version = fuse_get_attr_version(fc);
 287
 288        fuse_lookup_init(fc, req, nodeid, name, outarg);
 289        fuse_request_send(fc, req);
 290        err = req->out.h.error;
 291        fuse_put_request(fc, req);
 292        /* Zero nodeid is same as -ENOENT, but with valid timeout */
 293        if (err || !outarg->nodeid)
 294                goto out_put_forget;
 295
 296        err = -EIO;
 297        if (!outarg->nodeid)
 298                goto out_put_forget;
 299        if (!fuse_valid_type(outarg->attr.mode))
 300                goto out_put_forget;
 301
 302        *inode = fuse_iget(sb, outarg->nodeid, outarg->generation,
 303                           &outarg->attr, entry_attr_timeout(outarg),
 304                           attr_version);
 305        err = -ENOMEM;
 306        if (!*inode) {
 307                fuse_queue_forget(fc, forget, outarg->nodeid, 1);
 308                goto out;
 309        }
 310        err = 0;
 311
 312 out_put_forget:
 313        kfree(forget);
 314 out:
 315        return err;
 316}
 317
 318static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
 319                                  unsigned int flags)
 320{
 321        int err;
 322        struct fuse_entry_out outarg;
 323        struct inode *inode;
 324        struct dentry *newent;
 325        struct fuse_conn *fc = get_fuse_conn(dir);
 326        bool outarg_valid = true;
 327
 328        err = fuse_lookup_name(dir->i_sb, get_node_id(dir), &entry->d_name,
 329                               &outarg, &inode);
 330        if (err == -ENOENT) {
 331                outarg_valid = false;
 332                err = 0;
 333        }
 334        if (err)
 335                goto out_err;
 336
 337        err = -EIO;
 338        if (inode && get_node_id(inode) == FUSE_ROOT_ID)
 339                goto out_iput;
 340
 341        if (inode && S_ISDIR(inode->i_mode)) {
 342                mutex_lock(&fc->inst_mutex);
 343                newent = fuse_d_add_directory(entry, inode);
 344                mutex_unlock(&fc->inst_mutex);
 345                err = PTR_ERR(newent);
 346                if (IS_ERR(newent))
 347                        goto out_iput;
 348        } else {
 349                newent = d_splice_alias(inode, entry);
 350        }
 351
 352        entry = newent ? newent : entry;
 353        if (outarg_valid)
 354                fuse_change_entry_timeout(entry, &outarg);
 355        else
 356                fuse_invalidate_entry_cache(entry);
 357
 358        return newent;
 359
 360 out_iput:
 361        iput(inode);
 362 out_err:
 363        return ERR_PTR(err);
 364}
 365
 366/*
 367 * Atomic create+open operation
 368 *
 369 * If the filesystem doesn't support this, then fall back to separate
 370 * 'mknod' + 'open' requests.
 371 */
 372static int fuse_create_open(struct inode *dir, struct dentry *entry,
 373                            struct file *file, unsigned flags,
 374                            umode_t mode, int *opened)
 375{
 376        int err;
 377        struct inode *inode;
 378        struct fuse_conn *fc = get_fuse_conn(dir);
 379        struct fuse_req *req;
 380        struct fuse_forget_link *forget;
 381        struct fuse_create_in inarg;
 382        struct fuse_open_out outopen;
 383        struct fuse_entry_out outentry;
 384        struct fuse_file *ff;
 385
 386        /* Userspace expects S_IFREG in create mode */
 387        BUG_ON((mode & S_IFMT) != S_IFREG);
 388
 389        forget = fuse_alloc_forget();
 390        err = -ENOMEM;
 391        if (!forget)
 392                goto out_err;
 393
 394        req = fuse_get_req(fc);
 395        err = PTR_ERR(req);
 396        if (IS_ERR(req))
 397                goto out_put_forget_req;
 398
 399        err = -ENOMEM;
 400        ff = fuse_file_alloc(fc);
 401        if (!ff)
 402                goto out_put_request;
 403
 404        if (!fc->dont_mask)
 405                mode &= ~current_umask();
 406
 407        flags &= ~O_NOCTTY;
 408        memset(&inarg, 0, sizeof(inarg));
 409        memset(&outentry, 0, sizeof(outentry));
 410        inarg.flags = flags;
 411        inarg.mode = mode;
 412        inarg.umask = current_umask();
 413        req->in.h.opcode = FUSE_CREATE;
 414        req->in.h.nodeid = get_node_id(dir);
 415        req->in.numargs = 2;
 416        req->in.args[0].size = fc->minor < 12 ? sizeof(struct fuse_open_in) :
 417                                                sizeof(inarg);
 418        req->in.args[0].value = &inarg;
 419        req->in.args[1].size = entry->d_name.len + 1;
 420        req->in.args[1].value = entry->d_name.name;
 421        req->out.numargs = 2;
 422        if (fc->minor < 9)
 423                req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
 424        else
 425                req->out.args[0].size = sizeof(outentry);
 426        req->out.args[0].value = &outentry;
 427        req->out.args[1].size = sizeof(outopen);
 428        req->out.args[1].value = &outopen;
 429        fuse_request_send(fc, req);
 430        err = req->out.h.error;
 431        if (err)
 432                goto out_free_ff;
 433
 434        err = -EIO;
 435        if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
 436                goto out_free_ff;
 437
 438        fuse_put_request(fc, req);
 439        ff->fh = outopen.fh;
 440        ff->nodeid = outentry.nodeid;
 441        ff->open_flags = outopen.open_flags;
 442        inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
 443                          &outentry.attr, entry_attr_timeout(&outentry), 0);
 444        if (!inode) {
 445                flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
 446                fuse_sync_release(ff, flags);
 447                fuse_queue_forget(fc, forget, outentry.nodeid, 1);
 448                err = -ENOMEM;
 449                goto out_err;
 450        }
 451        kfree(forget);
 452        d_instantiate(entry, inode);
 453        fuse_change_entry_timeout(entry, &outentry);
 454        fuse_invalidate_attr(dir);
 455        err = finish_open(file, entry, generic_file_open, opened);
 456        if (err) {
 457                fuse_sync_release(ff, flags);
 458        } else {
 459                file->private_data = fuse_file_get(ff);
 460                fuse_finish_open(inode, file);
 461        }
 462        return err;
 463
 464out_free_ff:
 465        fuse_file_free(ff);
 466out_put_request:
 467        fuse_put_request(fc, req);
 468out_put_forget_req:
 469        kfree(forget);
 470out_err:
 471        return err;
 472}
 473
 474static int fuse_mknod(struct inode *, struct dentry *, umode_t, dev_t);
 475static int fuse_atomic_open(struct inode *dir, struct dentry *entry,
 476                            struct file *file, unsigned flags,
 477                            umode_t mode, int *opened)
 478{
 479        int err;
 480        struct fuse_conn *fc = get_fuse_conn(dir);
 481        struct dentry *res = NULL;
 482
 483        if (d_unhashed(entry)) {
 484                res = fuse_lookup(dir, entry, 0);
 485                if (IS_ERR(res))
 486                        return PTR_ERR(res);
 487
 488                if (res)
 489                        entry = res;
 490        }
 491
 492        if (!(flags & O_CREAT) || entry->d_inode)
 493                goto no_open;
 494
 495        /* Only creates */
 496        *opened |= FILE_CREATED;
 497
 498        if (fc->no_create)
 499                goto mknod;
 500
 501        err = fuse_create_open(dir, entry, file, flags, mode, opened);
 502        if (err == -ENOSYS) {
 503                fc->no_create = 1;
 504                goto mknod;
 505        }
 506out_dput:
 507        dput(res);
 508        return err;
 509
 510mknod:
 511        err = fuse_mknod(dir, entry, mode, 0);
 512        if (err)
 513                goto out_dput;
 514no_open:
 515        return finish_no_open(file, res);
 516}
 517
 518/*
 519 * Code shared between mknod, mkdir, symlink and link
 520 */
 521static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
 522                            struct inode *dir, struct dentry *entry,
 523                            umode_t mode)
 524{
 525        struct fuse_entry_out outarg;
 526        struct inode *inode;
 527        int err;
 528        struct fuse_forget_link *forget;
 529
 530        forget = fuse_alloc_forget();
 531        if (!forget) {
 532                fuse_put_request(fc, req);
 533                return -ENOMEM;
 534        }
 535
 536        memset(&outarg, 0, sizeof(outarg));
 537        req->in.h.nodeid = get_node_id(dir);
 538        req->out.numargs = 1;
 539        if (fc->minor < 9)
 540                req->out.args[0].size = FUSE_COMPAT_ENTRY_OUT_SIZE;
 541        else
 542                req->out.args[0].size = sizeof(outarg);
 543        req->out.args[0].value = &outarg;
 544        fuse_request_send(fc, req);
 545        err = req->out.h.error;
 546        fuse_put_request(fc, req);
 547        if (err)
 548                goto out_put_forget_req;
 549
 550        err = -EIO;
 551        if (invalid_nodeid(outarg.nodeid))
 552                goto out_put_forget_req;
 553
 554        if ((outarg.attr.mode ^ mode) & S_IFMT)
 555                goto out_put_forget_req;
 556
 557        inode = fuse_iget(dir->i_sb, outarg.nodeid, outarg.generation,
 558                          &outarg.attr, entry_attr_timeout(&outarg), 0);
 559        if (!inode) {
 560                fuse_queue_forget(fc, forget, outarg.nodeid, 1);
 561                return -ENOMEM;
 562        }
 563        kfree(forget);
 564
 565        if (S_ISDIR(inode->i_mode)) {
 566                struct dentry *alias;
 567                mutex_lock(&fc->inst_mutex);
 568                alias = d_find_alias(inode);
 569                if (alias) {
 570                        /* New directory must have moved since mkdir */
 571                        mutex_unlock(&fc->inst_mutex);
 572                        dput(alias);
 573                        iput(inode);
 574                        return -EBUSY;
 575                }
 576                d_instantiate(entry, inode);
 577                mutex_unlock(&fc->inst_mutex);
 578        } else
 579                d_instantiate(entry, inode);
 580
 581        fuse_change_entry_timeout(entry, &outarg);
 582        fuse_invalidate_attr(dir);
 583        return 0;
 584
 585 out_put_forget_req:
 586        kfree(forget);
 587        return err;
 588}
 589
 590static int fuse_mknod(struct inode *dir, struct dentry *entry, umode_t mode,
 591                      dev_t rdev)
 592{
 593        struct fuse_mknod_in inarg;
 594        struct fuse_conn *fc = get_fuse_conn(dir);
 595        struct fuse_req *req = fuse_get_req(fc);
 596        if (IS_ERR(req))
 597                return PTR_ERR(req);
 598
 599        if (!fc->dont_mask)
 600                mode &= ~current_umask();
 601
 602        memset(&inarg, 0, sizeof(inarg));
 603        inarg.mode = mode;
 604        inarg.rdev = new_encode_dev(rdev);
 605        inarg.umask = current_umask();
 606        req->in.h.opcode = FUSE_MKNOD;
 607        req->in.numargs = 2;
 608        req->in.args[0].size = fc->minor < 12 ? FUSE_COMPAT_MKNOD_IN_SIZE :
 609                                                sizeof(inarg);
 610        req->in.args[0].value = &inarg;
 611        req->in.args[1].size = entry->d_name.len + 1;
 612        req->in.args[1].value = entry->d_name.name;
 613        return create_new_entry(fc, req, dir, entry, mode);
 614}
 615
 616static int fuse_create(struct inode *dir, struct dentry *entry, umode_t mode,
 617                       bool excl)
 618{
 619        return fuse_mknod(dir, entry, mode, 0);
 620}
 621
 622static int fuse_mkdir(struct inode *dir, struct dentry *entry, umode_t mode)
 623{
 624        struct fuse_mkdir_in inarg;
 625        struct fuse_conn *fc = get_fuse_conn(dir);
 626        struct fuse_req *req = fuse_get_req(fc);
 627        if (IS_ERR(req))
 628                return PTR_ERR(req);
 629
 630        if (!fc->dont_mask)
 631                mode &= ~current_umask();
 632
 633        memset(&inarg, 0, sizeof(inarg));
 634        inarg.mode = mode;
 635        inarg.umask = current_umask();
 636        req->in.h.opcode = FUSE_MKDIR;
 637        req->in.numargs = 2;
 638        req->in.args[0].size = sizeof(inarg);
 639        req->in.args[0].value = &inarg;
 640        req->in.args[1].size = entry->d_name.len + 1;
 641        req->in.args[1].value = entry->d_name.name;
 642        return create_new_entry(fc, req, dir, entry, S_IFDIR);
 643}
 644
 645static int fuse_symlink(struct inode *dir, struct dentry *entry,
 646                        const char *link)
 647{
 648        struct fuse_conn *fc = get_fuse_conn(dir);
 649        unsigned len = strlen(link) + 1;
 650        struct fuse_req *req = fuse_get_req(fc);
 651        if (IS_ERR(req))
 652                return PTR_ERR(req);
 653
 654        req->in.h.opcode = FUSE_SYMLINK;
 655        req->in.numargs = 2;
 656        req->in.args[0].size = entry->d_name.len + 1;
 657        req->in.args[0].value = entry->d_name.name;
 658        req->in.args[1].size = len;
 659        req->in.args[1].value = link;
 660        return create_new_entry(fc, req, dir, entry, S_IFLNK);
 661}
 662
 663static int fuse_unlink(struct inode *dir, struct dentry *entry)
 664{
 665        int err;
 666        struct fuse_conn *fc = get_fuse_conn(dir);
 667        struct fuse_req *req = fuse_get_req(fc);
 668        if (IS_ERR(req))
 669                return PTR_ERR(req);
 670
 671        req->in.h.opcode = FUSE_UNLINK;
 672        req->in.h.nodeid = get_node_id(dir);
 673        req->in.numargs = 1;
 674        req->in.args[0].size = entry->d_name.len + 1;
 675        req->in.args[0].value = entry->d_name.name;
 676        fuse_request_send(fc, req);
 677        err = req->out.h.error;
 678        fuse_put_request(fc, req);
 679        if (!err) {
 680                struct inode *inode = entry->d_inode;
 681                struct fuse_inode *fi = get_fuse_inode(inode);
 682
 683                spin_lock(&fc->lock);
 684                fi->attr_version = ++fc->attr_version;
 685                drop_nlink(inode);
 686                spin_unlock(&fc->lock);
 687                fuse_invalidate_attr(inode);
 688                fuse_invalidate_attr(dir);
 689                fuse_invalidate_entry_cache(entry);
 690        } else if (err == -EINTR)
 691                fuse_invalidate_entry(entry);
 692        return err;
 693}
 694
 695static int fuse_rmdir(struct inode *dir, struct dentry *entry)
 696{
 697        int err;
 698        struct fuse_conn *fc = get_fuse_conn(dir);
 699        struct fuse_req *req = fuse_get_req(fc);
 700        if (IS_ERR(req))
 701                return PTR_ERR(req);
 702
 703        req->in.h.opcode = FUSE_RMDIR;
 704        req->in.h.nodeid = get_node_id(dir);
 705        req->in.numargs = 1;
 706        req->in.args[0].size = entry->d_name.len + 1;
 707        req->in.args[0].value = entry->d_name.name;
 708        fuse_request_send(fc, req);
 709        err = req->out.h.error;
 710        fuse_put_request(fc, req);
 711        if (!err) {
 712                clear_nlink(entry->d_inode);
 713                fuse_invalidate_attr(dir);
 714                fuse_invalidate_entry_cache(entry);
 715        } else if (err == -EINTR)
 716                fuse_invalidate_entry(entry);
 717        return err;
 718}
 719
 720static int fuse_rename(struct inode *olddir, struct dentry *oldent,
 721                       struct inode *newdir, struct dentry *newent)
 722{
 723        int err;
 724        struct fuse_rename_in inarg;
 725        struct fuse_conn *fc = get_fuse_conn(olddir);
 726        struct fuse_req *req = fuse_get_req(fc);
 727
 728        if (IS_ERR(req))
 729                return PTR_ERR(req);
 730
 731        memset(&inarg, 0, sizeof(inarg));
 732        inarg.newdir = get_node_id(newdir);
 733        req->in.h.opcode = FUSE_RENAME;
 734        req->in.h.nodeid = get_node_id(olddir);
 735        req->in.numargs = 3;
 736        req->in.args[0].size = sizeof(inarg);
 737        req->in.args[0].value = &inarg;
 738        req->in.args[1].size = oldent->d_name.len + 1;
 739        req->in.args[1].value = oldent->d_name.name;
 740        req->in.args[2].size = newent->d_name.len + 1;
 741        req->in.args[2].value = newent->d_name.name;
 742        fuse_request_send(fc, req);
 743        err = req->out.h.error;
 744        fuse_put_request(fc, req);
 745        if (!err) {
 746                /* ctime changes */
 747                fuse_invalidate_attr(oldent->d_inode);
 748
 749                fuse_invalidate_attr(olddir);
 750                if (olddir != newdir)
 751                        fuse_invalidate_attr(newdir);
 752
 753                /* newent will end up negative */
 754                if (newent->d_inode) {
 755                        fuse_invalidate_attr(newent->d_inode);
 756                        fuse_invalidate_entry_cache(newent);
 757                }
 758        } else if (err == -EINTR) {
 759                /* If request was interrupted, DEITY only knows if the
 760                   rename actually took place.  If the invalidation
 761                   fails (e.g. some process has CWD under the renamed
 762                   directory), then there can be inconsistency between
 763                   the dcache and the real filesystem.  Tough luck. */
 764                fuse_invalidate_entry(oldent);
 765                if (newent->d_inode)
 766                        fuse_invalidate_entry(newent);
 767        }
 768
 769        return err;
 770}
 771
 772static int fuse_link(struct dentry *entry, struct inode *newdir,
 773                     struct dentry *newent)
 774{
 775        int err;
 776        struct fuse_link_in inarg;
 777        struct inode *inode = entry->d_inode;
 778        struct fuse_conn *fc = get_fuse_conn(inode);
 779        struct fuse_req *req = fuse_get_req(fc);
 780        if (IS_ERR(req))
 781                return PTR_ERR(req);
 782
 783        memset(&inarg, 0, sizeof(inarg));
 784        inarg.oldnodeid = get_node_id(inode);
 785        req->in.h.opcode = FUSE_LINK;
 786        req->in.numargs = 2;
 787        req->in.args[0].size = sizeof(inarg);
 788        req->in.args[0].value = &inarg;
 789        req->in.args[1].size = newent->d_name.len + 1;
 790        req->in.args[1].value = newent->d_name.name;
 791        err = create_new_entry(fc, req, newdir, newent, inode->i_mode);
 792        /* Contrary to "normal" filesystems it can happen that link
 793           makes two "logical" inodes point to the same "physical"
 794           inode.  We invalidate the attributes of the old one, so it
 795           will reflect changes in the backing inode (link count,
 796           etc.)
 797        */
 798        if (!err) {
 799                struct fuse_inode *fi = get_fuse_inode(inode);
 800
 801                spin_lock(&fc->lock);
 802                fi->attr_version = ++fc->attr_version;
 803                inc_nlink(inode);
 804                spin_unlock(&fc->lock);
 805                fuse_invalidate_attr(inode);
 806        } else if (err == -EINTR) {
 807                fuse_invalidate_attr(inode);
 808        }
 809        return err;
 810}
 811
 812static void fuse_fillattr(struct inode *inode, struct fuse_attr *attr,
 813                          struct kstat *stat)
 814{
 815        unsigned int blkbits;
 816
 817        stat->dev = inode->i_sb->s_dev;
 818        stat->ino = attr->ino;
 819        stat->mode = (inode->i_mode & S_IFMT) | (attr->mode & 07777);
 820        stat->nlink = attr->nlink;
 821        stat->uid = attr->uid;
 822        stat->gid = attr->gid;
 823        stat->rdev = inode->i_rdev;
 824        stat->atime.tv_sec = attr->atime;
 825        stat->atime.tv_nsec = attr->atimensec;
 826        stat->mtime.tv_sec = attr->mtime;
 827        stat->mtime.tv_nsec = attr->mtimensec;
 828        stat->ctime.tv_sec = attr->ctime;
 829        stat->ctime.tv_nsec = attr->ctimensec;
 830        stat->size = attr->size;
 831        stat->blocks = attr->blocks;
 832
 833        if (attr->blksize != 0)
 834                blkbits = ilog2(attr->blksize);
 835        else
 836                blkbits = inode->i_sb->s_blocksize_bits;
 837
 838        stat->blksize = 1 << blkbits;
 839}
 840
 841static int fuse_do_getattr(struct inode *inode, struct kstat *stat,
 842                           struct file *file)
 843{
 844        int err;
 845        struct fuse_getattr_in inarg;
 846        struct fuse_attr_out outarg;
 847        struct fuse_conn *fc = get_fuse_conn(inode);
 848        struct fuse_req *req;
 849        u64 attr_version;
 850
 851        req = fuse_get_req(fc);
 852        if (IS_ERR(req))
 853                return PTR_ERR(req);
 854
 855        attr_version = fuse_get_attr_version(fc);
 856
 857        memset(&inarg, 0, sizeof(inarg));
 858        memset(&outarg, 0, sizeof(outarg));
 859        /* Directories have separate file-handle space */
 860        if (file && S_ISREG(inode->i_mode)) {
 861                struct fuse_file *ff = file->private_data;
 862
 863                inarg.getattr_flags |= FUSE_GETATTR_FH;
 864                inarg.fh = ff->fh;
 865        }
 866        req->in.h.opcode = FUSE_GETATTR;
 867        req->in.h.nodeid = get_node_id(inode);
 868        req->in.numargs = 1;
 869        req->in.args[0].size = sizeof(inarg);
 870        req->in.args[0].value = &inarg;
 871        req->out.numargs = 1;
 872        if (fc->minor < 9)
 873                req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
 874        else
 875                req->out.args[0].size = sizeof(outarg);
 876        req->out.args[0].value = &outarg;
 877        fuse_request_send(fc, req);
 878        err = req->out.h.error;
 879        fuse_put_request(fc, req);
 880        if (!err) {
 881                if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
 882                        make_bad_inode(inode);
 883                        err = -EIO;
 884                } else {
 885                        fuse_change_attributes(inode, &outarg.attr,
 886                                               attr_timeout(&outarg),
 887                                               attr_version);
 888                        if (stat)
 889                                fuse_fillattr(inode, &outarg.attr, stat);
 890                }
 891        }
 892        return err;
 893}
 894
 895int fuse_update_attributes(struct inode *inode, struct kstat *stat,
 896                           struct file *file, bool *refreshed)
 897{
 898        struct fuse_inode *fi = get_fuse_inode(inode);
 899        int err;
 900        bool r;
 901
 902        if (fi->i_time < get_jiffies_64()) {
 903                r = true;
 904                err = fuse_do_getattr(inode, stat, file);
 905        } else {
 906                r = false;
 907                err = 0;
 908                if (stat) {
 909                        generic_fillattr(inode, stat);
 910                        stat->mode = fi->orig_i_mode;
 911                        stat->ino = fi->orig_ino;
 912                }
 913        }
 914
 915        if (refreshed != NULL)
 916                *refreshed = r;
 917
 918        return err;
 919}
 920
 921int fuse_reverse_inval_entry(struct super_block *sb, u64 parent_nodeid,
 922                             u64 child_nodeid, struct qstr *name)
 923{
 924        int err = -ENOTDIR;
 925        struct inode *parent;
 926        struct dentry *dir;
 927        struct dentry *entry;
 928
 929        parent = ilookup5(sb, parent_nodeid, fuse_inode_eq, &parent_nodeid);
 930        if (!parent)
 931                return -ENOENT;
 932
 933        mutex_lock(&parent->i_mutex);
 934        if (!S_ISDIR(parent->i_mode))
 935                goto unlock;
 936
 937        err = -ENOENT;
 938        dir = d_find_alias(parent);
 939        if (!dir)
 940                goto unlock;
 941
 942        entry = d_lookup(dir, name);
 943        dput(dir);
 944        if (!entry)
 945                goto unlock;
 946
 947        fuse_invalidate_attr(parent);
 948        fuse_invalidate_entry(entry);
 949
 950        if (child_nodeid != 0 && entry->d_inode) {
 951                mutex_lock(&entry->d_inode->i_mutex);
 952                if (get_node_id(entry->d_inode) != child_nodeid) {
 953                        err = -ENOENT;
 954                        goto badentry;
 955                }
 956                if (d_mountpoint(entry)) {
 957                        err = -EBUSY;
 958                        goto badentry;
 959                }
 960                if (S_ISDIR(entry->d_inode->i_mode)) {
 961                        shrink_dcache_parent(entry);
 962                        if (!simple_empty(entry)) {
 963                                err = -ENOTEMPTY;
 964                                goto badentry;
 965                        }
 966                        entry->d_inode->i_flags |= S_DEAD;
 967                }
 968                dont_mount(entry);
 969                clear_nlink(entry->d_inode);
 970                err = 0;
 971 badentry:
 972                mutex_unlock(&entry->d_inode->i_mutex);
 973                if (!err)
 974                        d_delete(entry);
 975        } else {
 976                err = 0;
 977        }
 978        dput(entry);
 979
 980 unlock:
 981        mutex_unlock(&parent->i_mutex);
 982        iput(parent);
 983        return err;
 984}
 985
 986/*
 987 * Calling into a user-controlled filesystem gives the filesystem
 988 * daemon ptrace-like capabilities over the requester process.  This
 989 * means, that the filesystem daemon is able to record the exact
 990 * filesystem operations performed, and can also control the behavior
 991 * of the requester process in otherwise impossible ways.  For example
 992 * it can delay the operation for arbitrary length of time allowing
 993 * DoS against the requester.
 994 *
 995 * For this reason only those processes can call into the filesystem,
 996 * for which the owner of the mount has ptrace privilege.  This
 997 * excludes processes started by other users, suid or sgid processes.
 998 */
 999int fuse_allow_task(struct fuse_conn *fc, struct task_struct *task)
1000{
1001        const struct cred *cred;
1002        int ret;
1003
1004        if (fc->flags & FUSE_ALLOW_OTHER)
1005                return 1;
1006
1007        rcu_read_lock();
1008        ret = 0;
1009        cred = __task_cred(task);
1010        if (cred->euid == fc->user_id &&
1011            cred->suid == fc->user_id &&
1012            cred->uid  == fc->user_id &&
1013            cred->egid == fc->group_id &&
1014            cred->sgid == fc->group_id &&
1015            cred->gid  == fc->group_id)
1016                ret = 1;
1017        rcu_read_unlock();
1018
1019        return ret;
1020}
1021
1022static int fuse_access(struct inode *inode, int mask)
1023{
1024        struct fuse_conn *fc = get_fuse_conn(inode);
1025        struct fuse_req *req;
1026        struct fuse_access_in inarg;
1027        int err;
1028
1029        if (fc->no_access)
1030                return 0;
1031
1032        req = fuse_get_req(fc);
1033        if (IS_ERR(req))
1034                return PTR_ERR(req);
1035
1036        memset(&inarg, 0, sizeof(inarg));
1037        inarg.mask = mask & (MAY_READ | MAY_WRITE | MAY_EXEC);
1038        req->in.h.opcode = FUSE_ACCESS;
1039        req->in.h.nodeid = get_node_id(inode);
1040        req->in.numargs = 1;
1041        req->in.args[0].size = sizeof(inarg);
1042        req->in.args[0].value = &inarg;
1043        fuse_request_send(fc, req);
1044        err = req->out.h.error;
1045        fuse_put_request(fc, req);
1046        if (err == -ENOSYS) {
1047                fc->no_access = 1;
1048                err = 0;
1049        }
1050        return err;
1051}
1052
1053static int fuse_perm_getattr(struct inode *inode, int mask)
1054{
1055        if (mask & MAY_NOT_BLOCK)
1056                return -ECHILD;
1057
1058        return fuse_do_getattr(inode, NULL, NULL);
1059}
1060
1061/*
1062 * Check permission.  The two basic access models of FUSE are:
1063 *
1064 * 1) Local access checking ('default_permissions' mount option) based
1065 * on file mode.  This is the plain old disk filesystem permission
1066 * modell.
1067 *
1068 * 2) "Remote" access checking, where server is responsible for
1069 * checking permission in each inode operation.  An exception to this
1070 * is if ->permission() was invoked from sys_access() in which case an
1071 * access request is sent.  Execute permission is still checked
1072 * locally based on file mode.
1073 */
1074static int fuse_permission(struct inode *inode, int mask)
1075{
1076        struct fuse_conn *fc = get_fuse_conn(inode);
1077        bool refreshed = false;
1078        int err = 0;
1079
1080        if (!fuse_allow_task(fc, current))
1081                return -EACCES;
1082
1083        /*
1084         * If attributes are needed, refresh them before proceeding
1085         */
1086        if ((fc->flags & FUSE_DEFAULT_PERMISSIONS) ||
1087            ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))) {
1088                struct fuse_inode *fi = get_fuse_inode(inode);
1089
1090                if (fi->i_time < get_jiffies_64()) {
1091                        refreshed = true;
1092
1093                        err = fuse_perm_getattr(inode, mask);
1094                        if (err)
1095                                return err;
1096                }
1097        }
1098
1099        if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
1100                err = generic_permission(inode, mask);
1101
1102                /* If permission is denied, try to refresh file
1103                   attributes.  This is also needed, because the root
1104                   node will at first have no permissions */
1105                if (err == -EACCES && !refreshed) {
1106                        err = fuse_perm_getattr(inode, mask);
1107                        if (!err)
1108                                err = generic_permission(inode, mask);
1109                }
1110
1111                /* Note: the opposite of the above test does not
1112                   exist.  So if permissions are revoked this won't be
1113                   noticed immediately, only after the attribute
1114                   timeout has expired */
1115        } else if (mask & (MAY_ACCESS | MAY_CHDIR)) {
1116                if (mask & MAY_NOT_BLOCK)
1117                        return -ECHILD;
1118
1119                err = fuse_access(inode, mask);
1120        } else if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
1121                if (!(inode->i_mode & S_IXUGO)) {
1122                        if (refreshed)
1123                                return -EACCES;
1124
1125                        err = fuse_perm_getattr(inode, mask);
1126                        if (!err && !(inode->i_mode & S_IXUGO))
1127                                return -EACCES;
1128                }
1129        }
1130        return err;
1131}
1132
1133static int parse_dirfile(char *buf, size_t nbytes, struct file *file,
1134                         void *dstbuf, filldir_t filldir)
1135{
1136        while (nbytes >= FUSE_NAME_OFFSET) {
1137                struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
1138                size_t reclen = FUSE_DIRENT_SIZE(dirent);
1139                int over;
1140                if (!dirent->namelen || dirent->namelen > FUSE_NAME_MAX)
1141                        return -EIO;
1142                if (reclen > nbytes)
1143                        break;
1144
1145                over = filldir(dstbuf, dirent->name, dirent->namelen,
1146                               file->f_pos, dirent->ino, dirent->type);
1147                if (over)
1148                        break;
1149
1150                buf += reclen;
1151                nbytes -= reclen;
1152                file->f_pos = dirent->off;
1153        }
1154
1155        return 0;
1156}
1157
1158static int fuse_readdir(struct file *file, void *dstbuf, filldir_t filldir)
1159{
1160        int err;
1161        size_t nbytes;
1162        struct page *page;
1163        struct inode *inode = file->f_path.dentry->d_inode;
1164        struct fuse_conn *fc = get_fuse_conn(inode);
1165        struct fuse_req *req;
1166
1167        if (is_bad_inode(inode))
1168                return -EIO;
1169
1170        req = fuse_get_req(fc);
1171        if (IS_ERR(req))
1172                return PTR_ERR(req);
1173
1174        page = alloc_page(GFP_KERNEL);
1175        if (!page) {
1176                fuse_put_request(fc, req);
1177                return -ENOMEM;
1178        }
1179        req->out.argpages = 1;
1180        req->num_pages = 1;
1181        req->pages[0] = page;
1182        fuse_read_fill(req, file, file->f_pos, PAGE_SIZE, FUSE_READDIR);
1183        fuse_request_send(fc, req);
1184        nbytes = req->out.args[0].size;
1185        err = req->out.h.error;
1186        fuse_put_request(fc, req);
1187        if (!err)
1188                err = parse_dirfile(page_address(page), nbytes, file, dstbuf,
1189                                    filldir);
1190
1191        __free_page(page);
1192        fuse_invalidate_attr(inode); /* atime changed */
1193        return err;
1194}
1195
1196static char *read_link(struct dentry *dentry)
1197{
1198        struct inode *inode = dentry->d_inode;
1199        struct fuse_conn *fc = get_fuse_conn(inode);
1200        struct fuse_req *req = fuse_get_req(fc);
1201        char *link;
1202
1203        if (IS_ERR(req))
1204                return ERR_CAST(req);
1205
1206        link = (char *) __get_free_page(GFP_KERNEL);
1207        if (!link) {
1208                link = ERR_PTR(-ENOMEM);
1209                goto out;
1210        }
1211        req->in.h.opcode = FUSE_READLINK;
1212        req->in.h.nodeid = get_node_id(inode);
1213        req->out.argvar = 1;
1214        req->out.numargs = 1;
1215        req->out.args[0].size = PAGE_SIZE - 1;
1216        req->out.args[0].value = link;
1217        fuse_request_send(fc, req);
1218        if (req->out.h.error) {
1219                free_page((unsigned long) link);
1220                link = ERR_PTR(req->out.h.error);
1221        } else
1222                link[req->out.args[0].size] = '\0';
1223 out:
1224        fuse_put_request(fc, req);
1225        fuse_invalidate_attr(inode); /* atime changed */
1226        return link;
1227}
1228
1229static void free_link(char *link)
1230{
1231        if (!IS_ERR(link))
1232                free_page((unsigned long) link);
1233}
1234
1235static void *fuse_follow_link(struct dentry *dentry, struct nameidata *nd)
1236{
1237        nd_set_link(nd, read_link(dentry));
1238        return NULL;
1239}
1240
1241static void fuse_put_link(struct dentry *dentry, struct nameidata *nd, void *c)
1242{
1243        free_link(nd_get_link(nd));
1244}
1245
1246static int fuse_dir_open(struct inode *inode, struct file *file)
1247{
1248        return fuse_open_common(inode, file, true);
1249}
1250
1251static int fuse_dir_release(struct inode *inode, struct file *file)
1252{
1253        fuse_release_common(file, FUSE_RELEASEDIR);
1254
1255        return 0;
1256}
1257
1258static int fuse_dir_fsync(struct file *file, loff_t start, loff_t end,
1259                          int datasync)
1260{
1261        return fuse_fsync_common(file, start, end, datasync, 1);
1262}
1263
1264static long fuse_dir_ioctl(struct file *file, unsigned int cmd,
1265                            unsigned long arg)
1266{
1267        struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1268
1269        /* FUSE_IOCTL_DIR only supported for API version >= 7.18 */
1270        if (fc->minor < 18)
1271                return -ENOTTY;
1272
1273        return fuse_ioctl_common(file, cmd, arg, FUSE_IOCTL_DIR);
1274}
1275
1276static long fuse_dir_compat_ioctl(struct file *file, unsigned int cmd,
1277                                   unsigned long arg)
1278{
1279        struct fuse_conn *fc = get_fuse_conn(file->f_mapping->host);
1280
1281        if (fc->minor < 18)
1282                return -ENOTTY;
1283
1284        return fuse_ioctl_common(file, cmd, arg,
1285                                 FUSE_IOCTL_COMPAT | FUSE_IOCTL_DIR);
1286}
1287
1288static bool update_mtime(unsigned ivalid)
1289{
1290        /* Always update if mtime is explicitly set  */
1291        if (ivalid & ATTR_MTIME_SET)
1292                return true;
1293
1294        /* If it's an open(O_TRUNC) or an ftruncate(), don't update */
1295        if ((ivalid & ATTR_SIZE) && (ivalid & (ATTR_OPEN | ATTR_FILE)))
1296                return false;
1297
1298        /* In all other cases update */
1299        return true;
1300}
1301
1302static void iattr_to_fattr(struct iattr *iattr, struct fuse_setattr_in *arg)
1303{
1304        unsigned ivalid = iattr->ia_valid;
1305
1306        if (ivalid & ATTR_MODE)
1307                arg->valid |= FATTR_MODE,   arg->mode = iattr->ia_mode;
1308        if (ivalid & ATTR_UID)
1309                arg->valid |= FATTR_UID,    arg->uid = iattr->ia_uid;
1310        if (ivalid & ATTR_GID)
1311                arg->valid |= FATTR_GID,    arg->gid = iattr->ia_gid;
1312        if (ivalid & ATTR_SIZE)
1313                arg->valid |= FATTR_SIZE,   arg->size = iattr->ia_size;
1314        if (ivalid & ATTR_ATIME) {
1315                arg->valid |= FATTR_ATIME;
1316                arg->atime = iattr->ia_atime.tv_sec;
1317                arg->atimensec = iattr->ia_atime.tv_nsec;
1318                if (!(ivalid & ATTR_ATIME_SET))
1319                        arg->valid |= FATTR_ATIME_NOW;
1320        }
1321        if ((ivalid & ATTR_MTIME) && update_mtime(ivalid)) {
1322                arg->valid |= FATTR_MTIME;
1323                arg->mtime = iattr->ia_mtime.tv_sec;
1324                arg->mtimensec = iattr->ia_mtime.tv_nsec;
1325                if (!(ivalid & ATTR_MTIME_SET))
1326                        arg->valid |= FATTR_MTIME_NOW;
1327        }
1328}
1329
1330/*
1331 * Prevent concurrent writepages on inode
1332 *
1333 * This is done by adding a negative bias to the inode write counter
1334 * and waiting for all pending writes to finish.
1335 */
1336void fuse_set_nowrite(struct inode *inode)
1337{
1338        struct fuse_conn *fc = get_fuse_conn(inode);
1339        struct fuse_inode *fi = get_fuse_inode(inode);
1340
1341        BUG_ON(!mutex_is_locked(&inode->i_mutex));
1342
1343        spin_lock(&fc->lock);
1344        BUG_ON(fi->writectr < 0);
1345        fi->writectr += FUSE_NOWRITE;
1346        spin_unlock(&fc->lock);
1347        wait_event(fi->page_waitq, fi->writectr == FUSE_NOWRITE);
1348}
1349
1350/*
1351 * Allow writepages on inode
1352 *
1353 * Remove the bias from the writecounter and send any queued
1354 * writepages.
1355 */
1356static void __fuse_release_nowrite(struct inode *inode)
1357{
1358        struct fuse_inode *fi = get_fuse_inode(inode);
1359
1360        BUG_ON(fi->writectr != FUSE_NOWRITE);
1361        fi->writectr = 0;
1362        fuse_flush_writepages(inode);
1363}
1364
1365void fuse_release_nowrite(struct inode *inode)
1366{
1367        struct fuse_conn *fc = get_fuse_conn(inode);
1368
1369        spin_lock(&fc->lock);
1370        __fuse_release_nowrite(inode);
1371        spin_unlock(&fc->lock);
1372}
1373
1374/*
1375 * Set attributes, and at the same time refresh them.
1376 *
1377 * Truncation is slightly complicated, because the 'truncate' request
1378 * may fail, in which case we don't want to touch the mapping.
1379 * vmtruncate() doesn't allow for this case, so do the rlimit checking
1380 * and the actual truncation by hand.
1381 */
1382static int fuse_do_setattr(struct dentry *entry, struct iattr *attr,
1383                           struct file *file)
1384{
1385        struct inode *inode = entry->d_inode;
1386        struct fuse_conn *fc = get_fuse_conn(inode);
1387        struct fuse_req *req;
1388        struct fuse_setattr_in inarg;
1389        struct fuse_attr_out outarg;
1390        bool is_truncate = false;
1391        loff_t oldsize;
1392        int err;
1393
1394        if (!fuse_allow_task(fc, current))
1395                return -EACCES;
1396
1397        if (!(fc->flags & FUSE_DEFAULT_PERMISSIONS))
1398                attr->ia_valid |= ATTR_FORCE;
1399
1400        err = inode_change_ok(inode, attr);
1401        if (err)
1402                return err;
1403
1404        if (attr->ia_valid & ATTR_OPEN) {
1405                if (fc->atomic_o_trunc)
1406                        return 0;
1407                file = NULL;
1408        }
1409
1410        if (attr->ia_valid & ATTR_SIZE)
1411                is_truncate = true;
1412
1413        req = fuse_get_req(fc);
1414        if (IS_ERR(req))
1415                return PTR_ERR(req);
1416
1417        if (is_truncate)
1418                fuse_set_nowrite(inode);
1419
1420        memset(&inarg, 0, sizeof(inarg));
1421        memset(&outarg, 0, sizeof(outarg));
1422        iattr_to_fattr(attr, &inarg);
1423        if (file) {
1424                struct fuse_file *ff = file->private_data;
1425                inarg.valid |= FATTR_FH;
1426                inarg.fh = ff->fh;
1427        }
1428        if (attr->ia_valid & ATTR_SIZE) {
1429                /* For mandatory locking in truncate */
1430                inarg.valid |= FATTR_LOCKOWNER;
1431                inarg.lock_owner = fuse_lock_owner_id(fc, current->files);
1432        }
1433        req->in.h.opcode = FUSE_SETATTR;
1434        req->in.h.nodeid = get_node_id(inode);
1435        req->in.numargs = 1;
1436        req->in.args[0].size = sizeof(inarg);
1437        req->in.args[0].value = &inarg;
1438        req->out.numargs = 1;
1439        if (fc->minor < 9)
1440                req->out.args[0].size = FUSE_COMPAT_ATTR_OUT_SIZE;
1441        else
1442                req->out.args[0].size = sizeof(outarg);
1443        req->out.args[0].value = &outarg;
1444        fuse_request_send(fc, req);
1445        err = req->out.h.error;
1446        fuse_put_request(fc, req);
1447        if (err) {
1448                if (err == -EINTR)
1449                        fuse_invalidate_attr(inode);
1450                goto error;
1451        }
1452
1453        if ((inode->i_mode ^ outarg.attr.mode) & S_IFMT) {
1454                make_bad_inode(inode);
1455                err = -EIO;
1456                goto error;
1457        }
1458
1459        spin_lock(&fc->lock);
1460        fuse_change_attributes_common(inode, &outarg.attr,
1461                                      attr_timeout(&outarg));
1462        oldsize = inode->i_size;
1463        i_size_write(inode, outarg.attr.size);
1464
1465        if (is_truncate) {
1466                /* NOTE: this may release/reacquire fc->lock */
1467                __fuse_release_nowrite(inode);
1468        }
1469        spin_unlock(&fc->lock);
1470
1471        /*
1472         * Only call invalidate_inode_pages2() after removing
1473         * FUSE_NOWRITE, otherwise fuse_launder_page() would deadlock.
1474         */
1475        if (S_ISREG(inode->i_mode) && oldsize != outarg.attr.size) {
1476                truncate_pagecache(inode, oldsize, outarg.attr.size);
1477                invalidate_inode_pages2(inode->i_mapping);
1478        }
1479
1480        return 0;
1481
1482error:
1483        if (is_truncate)
1484                fuse_release_nowrite(inode);
1485
1486        return err;
1487}
1488
1489static int fuse_setattr(struct dentry *entry, struct iattr *attr)
1490{
1491        if (attr->ia_valid & ATTR_FILE)
1492                return fuse_do_setattr(entry, attr, attr->ia_file);
1493        else
1494                return fuse_do_setattr(entry, attr, NULL);
1495}
1496
1497static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry,
1498                        struct kstat *stat)
1499{
1500        struct inode *inode = entry->d_inode;
1501        struct fuse_conn *fc = get_fuse_conn(inode);
1502
1503        if (!fuse_allow_task(fc, current))
1504                return -EACCES;
1505
1506        return fuse_update_attributes(inode, stat, NULL, NULL);
1507}
1508
1509static int fuse_setxattr(struct dentry *entry, const char *name,
1510                         const void *value, size_t size, int flags)
1511{
1512        struct inode *inode = entry->d_inode;
1513        struct fuse_conn *fc = get_fuse_conn(inode);
1514        struct fuse_req *req;
1515        struct fuse_setxattr_in inarg;
1516        int err;
1517
1518        if (fc->no_setxattr)
1519                return -EOPNOTSUPP;
1520
1521        req = fuse_get_req(fc);
1522        if (IS_ERR(req))
1523                return PTR_ERR(req);
1524
1525        memset(&inarg, 0, sizeof(inarg));
1526        inarg.size = size;
1527        inarg.flags = flags;
1528        req->in.h.opcode = FUSE_SETXATTR;
1529        req->in.h.nodeid = get_node_id(inode);
1530        req->in.numargs = 3;
1531        req->in.args[0].size = sizeof(inarg);
1532        req->in.args[0].value = &inarg;
1533        req->in.args[1].size = strlen(name) + 1;
1534        req->in.args[1].value = name;
1535        req->in.args[2].size = size;
1536        req->in.args[2].value = value;
1537        fuse_request_send(fc, req);
1538        err = req->out.h.error;
1539        fuse_put_request(fc, req);
1540        if (err == -ENOSYS) {
1541                fc->no_setxattr = 1;
1542                err = -EOPNOTSUPP;
1543        }
1544        return err;
1545}
1546
1547static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
1548                             void *value, size_t size)
1549{
1550        struct inode *inode = entry->d_inode;
1551        struct fuse_conn *fc = get_fuse_conn(inode);
1552        struct fuse_req *req;
1553        struct fuse_getxattr_in inarg;
1554        struct fuse_getxattr_out outarg;
1555        ssize_t ret;
1556
1557        if (fc->no_getxattr)
1558                return -EOPNOTSUPP;
1559
1560        req = fuse_get_req(fc);
1561        if (IS_ERR(req))
1562                return PTR_ERR(req);
1563
1564        memset(&inarg, 0, sizeof(inarg));
1565        inarg.size = size;
1566        req->in.h.opcode = FUSE_GETXATTR;
1567        req->in.h.nodeid = get_node_id(inode);
1568        req->in.numargs = 2;
1569        req->in.args[0].size = sizeof(inarg);
1570        req->in.args[0].value = &inarg;
1571        req->in.args[1].size = strlen(name) + 1;
1572        req->in.args[1].value = name;
1573        /* This is really two different operations rolled into one */
1574        req->out.numargs = 1;
1575        if (size) {
1576                req->out.argvar = 1;
1577                req->out.args[0].size = size;
1578                req->out.args[0].value = value;
1579        } else {
1580                req->out.args[0].size = sizeof(outarg);
1581                req->out.args[0].value = &outarg;
1582        }
1583        fuse_request_send(fc, req);
1584        ret = req->out.h.error;
1585        if (!ret)
1586                ret = size ? req->out.args[0].size : outarg.size;
1587        else {
1588                if (ret == -ENOSYS) {
1589                        fc->no_getxattr = 1;
1590                        ret = -EOPNOTSUPP;
1591                }
1592        }
1593        fuse_put_request(fc, req);
1594        return ret;
1595}
1596
1597static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
1598{
1599        struct inode *inode = entry->d_inode;
1600        struct fuse_conn *fc = get_fuse_conn(inode);
1601        struct fuse_req *req;
1602        struct fuse_getxattr_in inarg;
1603        struct fuse_getxattr_out outarg;
1604        ssize_t ret;
1605
1606        if (!fuse_allow_task(fc, current))
1607                return -EACCES;
1608
1609        if (fc->no_listxattr)
1610                return -EOPNOTSUPP;
1611
1612        req = fuse_get_req(fc);
1613        if (IS_ERR(req))
1614                return PTR_ERR(req);
1615
1616        memset(&inarg, 0, sizeof(inarg));
1617        inarg.size = size;
1618        req->in.h.opcode = FUSE_LISTXATTR;
1619        req->in.h.nodeid = get_node_id(inode);
1620        req->in.numargs = 1;
1621        req->in.args[0].size = sizeof(inarg);
1622        req->in.args[0].value = &inarg;
1623        /* This is really two different operations rolled into one */
1624        req->out.numargs = 1;
1625        if (size) {
1626                req->out.argvar = 1;
1627                req->out.args[0].size = size;
1628                req->out.args[0].value = list;
1629        } else {
1630                req->out.args[0].size = sizeof(outarg);
1631                req->out.args[0].value = &outarg;
1632        }
1633        fuse_request_send(fc, req);
1634        ret = req->out.h.error;
1635        if (!ret)
1636                ret = size ? req->out.args[0].size : outarg.size;
1637        else {
1638                if (ret == -ENOSYS) {
1639                        fc->no_listxattr = 1;
1640                        ret = -EOPNOTSUPP;
1641                }
1642        }
1643        fuse_put_request(fc, req);
1644        return ret;
1645}
1646
1647static int fuse_removexattr(struct dentry *entry, const char *name)
1648{
1649        struct inode *inode = entry->d_inode;
1650        struct fuse_conn *fc = get_fuse_conn(inode);
1651        struct fuse_req *req;
1652        int err;
1653
1654        if (fc->no_removexattr)
1655                return -EOPNOTSUPP;
1656
1657        req = fuse_get_req(fc);
1658        if (IS_ERR(req))
1659                return PTR_ERR(req);
1660
1661        req->in.h.opcode = FUSE_REMOVEXATTR;
1662        req->in.h.nodeid = get_node_id(inode);
1663        req->in.numargs = 1;
1664        req->in.args[0].size = strlen(name) + 1;
1665        req->in.args[0].value = name;
1666        fuse_request_send(fc, req);
1667        err = req->out.h.error;
1668        fuse_put_request(fc, req);
1669        if (err == -ENOSYS) {
1670                fc->no_removexattr = 1;
1671                err = -EOPNOTSUPP;
1672        }
1673        return err;
1674}
1675
1676static const struct inode_operations fuse_dir_inode_operations = {
1677        .lookup         = fuse_lookup,
1678        .mkdir          = fuse_mkdir,
1679        .symlink        = fuse_symlink,
1680        .unlink         = fuse_unlink,
1681        .rmdir          = fuse_rmdir,
1682        .rename         = fuse_rename,
1683        .link           = fuse_link,
1684        .setattr        = fuse_setattr,
1685        .create         = fuse_create,
1686        .atomic_open    = fuse_atomic_open,
1687        .mknod          = fuse_mknod,
1688        .permission     = fuse_permission,
1689        .getattr        = fuse_getattr,
1690        .setxattr       = fuse_setxattr,
1691        .getxattr       = fuse_getxattr,
1692        .listxattr      = fuse_listxattr,
1693        .removexattr    = fuse_removexattr,
1694};
1695
1696static const struct file_operations fuse_dir_operations = {
1697        .llseek         = generic_file_llseek,
1698        .read           = generic_read_dir,
1699        .readdir        = fuse_readdir,
1700        .open           = fuse_dir_open,
1701        .release        = fuse_dir_release,
1702        .fsync          = fuse_dir_fsync,
1703        .unlocked_ioctl = fuse_dir_ioctl,
1704        .compat_ioctl   = fuse_dir_compat_ioctl,
1705};
1706
1707static const struct inode_operations fuse_common_inode_operations = {
1708        .setattr        = fuse_setattr,
1709        .permission     = fuse_permission,
1710        .getattr        = fuse_getattr,
1711        .setxattr       = fuse_setxattr,
1712        .getxattr       = fuse_getxattr,
1713        .listxattr      = fuse_listxattr,
1714        .removexattr    = fuse_removexattr,
1715};
1716
1717static const struct inode_operations fuse_symlink_inode_operations = {
1718        .setattr        = fuse_setattr,
1719        .follow_link    = fuse_follow_link,
1720        .put_link       = fuse_put_link,
1721        .readlink       = generic_readlink,
1722        .getattr        = fuse_getattr,
1723        .setxattr       = fuse_setxattr,
1724        .getxattr       = fuse_getxattr,
1725        .listxattr      = fuse_listxattr,
1726        .removexattr    = fuse_removexattr,
1727};
1728
1729void fuse_init_common(struct inode *inode)
1730{
1731        inode->i_op = &fuse_common_inode_operations;
1732}
1733
1734void fuse_init_dir(struct inode *inode)
1735{
1736        inode->i_op = &fuse_dir_inode_operations;
1737        inode->i_fop = &fuse_dir_operations;
1738}
1739
1740void fuse_init_symlink(struct inode *inode)
1741{
1742        inode->i_op = &fuse_symlink_inode_operations;
1743}
1744
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.