linux/net/sunrpc/rpc_pipe.c
<<
>>
Prefs
   1/*
   2 * net/sunrpc/rpc_pipe.c
   3 *
   4 * Userland/kernel interface for rpcauth_gss.
   5 * Code shamelessly plagiarized from fs/nfsd/nfsctl.c
   6 * and fs/sysfs/inode.c
   7 *
   8 * Copyright (c) 2002, Trond Myklebust <trond.myklebust@fys.uio.no>
   9 *
  10 */
  11#include <linux/module.h>
  12#include <linux/slab.h>
  13#include <linux/string.h>
  14#include <linux/pagemap.h>
  15#include <linux/mount.h>
  16#include <linux/namei.h>
  17#include <linux/fsnotify.h>
  18#include <linux/kernel.h>
  19
  20#include <asm/ioctls.h>
  21#include <linux/fs.h>
  22#include <linux/poll.h>
  23#include <linux/wait.h>
  24#include <linux/seq_file.h>
  25
  26#include <linux/sunrpc/clnt.h>
  27#include <linux/workqueue.h>
  28#include <linux/sunrpc/rpc_pipe_fs.h>
  29
  30static struct vfsmount *rpc_mount __read_mostly;
  31static int rpc_mount_count;
  32
  33static struct file_system_type rpc_pipe_fs_type;
  34
  35
  36static struct kmem_cache *rpc_inode_cachep __read_mostly;
  37
  38#define RPC_UPCALL_TIMEOUT (30*HZ)
  39
  40static void rpc_purge_list(struct rpc_inode *rpci, struct list_head *head,
  41                void (*destroy_msg)(struct rpc_pipe_msg *), int err)
  42{
  43        struct rpc_pipe_msg *msg;
  44
  45        if (list_empty(head))
  46                return;
  47        do {
  48                msg = list_entry(head->next, struct rpc_pipe_msg, list);
  49                list_del(&msg->list);
  50                msg->errno = err;
  51                destroy_msg(msg);
  52        } while (!list_empty(head));
  53        wake_up(&rpci->waitq);
  54}
  55
  56static void
  57rpc_timeout_upcall_queue(struct work_struct *work)
  58{
  59        LIST_HEAD(free_list);
  60        struct rpc_inode *rpci =
  61                container_of(work, struct rpc_inode, queue_timeout.work);
  62        struct inode *inode = &rpci->vfs_inode;
  63        void (*destroy_msg)(struct rpc_pipe_msg *);
  64
  65        spin_lock(&inode->i_lock);
  66        if (rpci->ops == NULL) {
  67                spin_unlock(&inode->i_lock);
  68                return;
  69        }
  70        destroy_msg = rpci->ops->destroy_msg;
  71        if (rpci->nreaders == 0) {
  72                list_splice_init(&rpci->pipe, &free_list);
  73                rpci->pipelen = 0;
  74        }
  75        spin_unlock(&inode->i_lock);
  76        rpc_purge_list(rpci, &free_list, destroy_msg, -ETIMEDOUT);
  77}
  78
  79/**
  80 * rpc_queue_upcall
  81 * @inode: inode of upcall pipe on which to queue given message
  82 * @msg: message to queue
  83 *
  84 * Call with an @inode created by rpc_mkpipe() to queue an upcall.
  85 * A userspace process may then later read the upcall by performing a
  86 * read on an open file for this inode.  It is up to the caller to
  87 * initialize the fields of @msg (other than @msg->list) appropriately.
  88 */
  89int
  90rpc_queue_upcall(struct inode *inode, struct rpc_pipe_msg *msg)
  91{
  92        struct rpc_inode *rpci = RPC_I(inode);
  93        int res = -EPIPE;
  94
  95        spin_lock(&inode->i_lock);
  96        if (rpci->ops == NULL)
  97                goto out;
  98        if (rpci->nreaders) {
  99                list_add_tail(&msg->list, &rpci->pipe);
 100                rpci->pipelen += msg->len;
 101                res = 0;
 102        } else if (rpci->flags & RPC_PIPE_WAIT_FOR_OPEN) {
 103                if (list_empty(&rpci->pipe))
 104                        queue_delayed_work(rpciod_workqueue,
 105                                        &rpci->queue_timeout,
 106                                        RPC_UPCALL_TIMEOUT);
 107                list_add_tail(&msg->list, &rpci->pipe);
 108                rpci->pipelen += msg->len;
 109                res = 0;
 110        }
 111out:
 112        spin_unlock(&inode->i_lock);
 113        wake_up(&rpci->waitq);
 114        return res;
 115}
 116EXPORT_SYMBOL_GPL(rpc_queue_upcall);
 117
 118static inline void
 119rpc_inode_setowner(struct inode *inode, void *private)
 120{
 121        RPC_I(inode)->private = private;
 122}
 123
 124static void
 125rpc_close_pipes(struct inode *inode)
 126{
 127        struct rpc_inode *rpci = RPC_I(inode);
 128        struct rpc_pipe_ops *ops;
 129        int need_release;
 130
 131        mutex_lock(&inode->i_mutex);
 132        ops = rpci->ops;
 133        if (ops != NULL) {
 134                LIST_HEAD(free_list);
 135                spin_lock(&inode->i_lock);
 136                need_release = rpci->nreaders != 0 || rpci->nwriters != 0;
 137                rpci->nreaders = 0;
 138                list_splice_init(&rpci->in_upcall, &free_list);
 139                list_splice_init(&rpci->pipe, &free_list);
 140                rpci->pipelen = 0;
 141                rpci->ops = NULL;
 142                spin_unlock(&inode->i_lock);
 143                rpc_purge_list(rpci, &free_list, ops->destroy_msg, -EPIPE);
 144                rpci->nwriters = 0;
 145                if (need_release && ops->release_pipe)
 146                        ops->release_pipe(inode);
 147                cancel_delayed_work_sync(&rpci->queue_timeout);
 148        }
 149        rpc_inode_setowner(inode, NULL);
 150        mutex_unlock(&inode->i_mutex);
 151}
 152
 153static struct inode *
 154rpc_alloc_inode(struct super_block *sb)
 155{
 156        struct rpc_inode *rpci;
 157        rpci = (struct rpc_inode *)kmem_cache_alloc(rpc_inode_cachep, GFP_KERNEL);
 158        if (!rpci)
 159                return NULL;
 160        return &rpci->vfs_inode;
 161}
 162
 163static void
 164rpc_destroy_inode(struct inode *inode)
 165{
 166        kmem_cache_free(rpc_inode_cachep, RPC_I(inode));
 167}
 168
 169static int
 170rpc_pipe_open(struct inode *inode, struct file *filp)
 171{
 172        struct rpc_inode *rpci = RPC_I(inode);
 173        int first_open;
 174        int res = -ENXIO;
 175
 176        mutex_lock(&inode->i_mutex);
 177        if (rpci->ops == NULL)
 178                goto out;
 179        first_open = rpci->nreaders == 0 && rpci->nwriters == 0;
 180        if (first_open && rpci->ops->open_pipe) {
 181                res = rpci->ops->open_pipe(inode);
 182                if (res)
 183                        goto out;
 184        }
 185        if (filp->f_mode & FMODE_READ)
 186                rpci->nreaders++;
 187        if (filp->f_mode & FMODE_WRITE)
 188                rpci->nwriters++;
 189        res = 0;
 190out:
 191        mutex_unlock(&inode->i_mutex);
 192        return res;
 193}
 194
 195static int
 196rpc_pipe_release(struct inode *inode, struct file *filp)
 197{
 198        struct rpc_inode *rpci = RPC_I(inode);
 199        struct rpc_pipe_msg *msg;
 200        int last_close;
 201
 202        mutex_lock(&inode->i_mutex);
 203        if (rpci->ops == NULL)
 204                goto out;
 205        msg = (struct rpc_pipe_msg *)filp->private_data;
 206        if (msg != NULL) {
 207                spin_lock(&inode->i_lock);
 208                msg->errno = -EAGAIN;
 209                list_del(&msg->list);
 210                spin_unlock(&inode->i_lock);
 211                rpci->ops->destroy_msg(msg);
 212        }
 213        if (filp->f_mode & FMODE_WRITE)
 214                rpci->nwriters --;
 215        if (filp->f_mode & FMODE_READ) {
 216                rpci->nreaders --;
 217                if (rpci->nreaders == 0) {
 218                        LIST_HEAD(free_list);
 219                        spin_lock(&inode->i_lock);
 220                        list_splice_init(&rpci->pipe, &free_list);
 221                        rpci->pipelen = 0;
 222                        spin_unlock(&inode->i_lock);
 223                        rpc_purge_list(rpci, &free_list,
 224                                        rpci->ops->destroy_msg, -EAGAIN);
 225                }
 226        }
 227        last_close = rpci->nwriters == 0 && rpci->nreaders == 0;
 228        if (last_close && rpci->ops->release_pipe)
 229                rpci->ops->release_pipe(inode);
 230out:
 231        mutex_unlock(&inode->i_mutex);
 232        return 0;
 233}
 234
 235static ssize_t
 236rpc_pipe_read(struct file *filp, char __user *buf, size_t len, loff_t *offset)
 237{
 238        struct inode *inode = filp->f_path.dentry->d_inode;
 239        struct rpc_inode *rpci = RPC_I(inode);
 240        struct rpc_pipe_msg *msg;
 241        int res = 0;
 242
 243        mutex_lock(&inode->i_mutex);
 244        if (rpci->ops == NULL) {
 245                res = -EPIPE;
 246                goto out_unlock;
 247        }
 248        msg = filp->private_data;
 249        if (msg == NULL) {
 250                spin_lock(&inode->i_lock);
 251                if (!list_empty(&rpci->pipe)) {
 252                        msg = list_entry(rpci->pipe.next,
 253                                        struct rpc_pipe_msg,
 254                                        list);
 255                        list_move(&msg->list, &rpci->in_upcall);
 256                        rpci->pipelen -= msg->len;
 257                        filp->private_data = msg;
 258                        msg->copied = 0;
 259                }
 260                spin_unlock(&inode->i_lock);
 261                if (msg == NULL)
 262                        goto out_unlock;
 263        }
 264        /* NOTE: it is up to the callback to update msg->copied */
 265        res = rpci->ops->upcall(filp, msg, buf, len);
 266        if (res < 0 || msg->len == msg->copied) {
 267                filp->private_data = NULL;
 268                spin_lock(&inode->i_lock);
 269                list_del(&msg->list);
 270                spin_unlock(&inode->i_lock);
 271                rpci->ops->destroy_msg(msg);
 272        }
 273out_unlock:
 274        mutex_unlock(&inode->i_mutex);
 275        return res;
 276}
 277
 278static ssize_t
 279rpc_pipe_write(struct file *filp, const char __user *buf, size_t len, loff_t *offset)
 280{
 281        struct inode *inode = filp->f_path.dentry->d_inode;
 282        struct rpc_inode *rpci = RPC_I(inode);
 283        int res;
 284
 285        mutex_lock(&inode->i_mutex);
 286        res = -EPIPE;
 287        if (rpci->ops != NULL)
 288                res = rpci->ops->downcall(filp, buf, len);
 289        mutex_unlock(&inode->i_mutex);
 290        return res;
 291}
 292
 293static unsigned int
 294rpc_pipe_poll(struct file *filp, struct poll_table_struct *wait)
 295{
 296        struct rpc_inode *rpci;
 297        unsigned int mask = 0;
 298
 299        rpci = RPC_I(filp->f_path.dentry->d_inode);
 300        poll_wait(filp, &rpci->waitq, wait);
 301
 302        mask = POLLOUT | POLLWRNORM;
 303        if (rpci->ops == NULL)
 304                mask |= POLLERR | POLLHUP;
 305        if (filp->private_data || !list_empty(&rpci->pipe))
 306                mask |= POLLIN | POLLRDNORM;
 307        return mask;
 308}
 309
 310static int
 311rpc_pipe_ioctl(struct inode *ino, struct file *filp,
 312                unsigned int cmd, unsigned long arg)
 313{
 314        struct rpc_inode *rpci = RPC_I(filp->f_path.dentry->d_inode);
 315        int len;
 316
 317        switch (cmd) {
 318        case FIONREAD:
 319                if (rpci->ops == NULL)
 320                        return -EPIPE;
 321                len = rpci->pipelen;
 322                if (filp->private_data) {
 323                        struct rpc_pipe_msg *msg;
 324                        msg = (struct rpc_pipe_msg *)filp->private_data;
 325                        len += msg->len - msg->copied;
 326                }
 327                return put_user(len, (int __user *)arg);
 328        default:
 329                return -EINVAL;
 330        }
 331}
 332
 333static const struct file_operations rpc_pipe_fops = {
 334        .owner          = THIS_MODULE,
 335        .llseek         = no_llseek,
 336        .read           = rpc_pipe_read,
 337        .write          = rpc_pipe_write,
 338        .poll           = rpc_pipe_poll,
 339        .ioctl          = rpc_pipe_ioctl,
 340        .open           = rpc_pipe_open,
 341        .release        = rpc_pipe_release,
 342};
 343
 344static int
 345rpc_show_info(struct seq_file *m, void *v)
 346{
 347        struct rpc_clnt *clnt = m->private;
 348
 349        seq_printf(m, "RPC server: %s\n", clnt->cl_server);
 350        seq_printf(m, "service: %s (%d) version %d\n", clnt->cl_protname,
 351                        clnt->cl_prog, clnt->cl_vers);
 352        seq_printf(m, "address: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_ADDR));
 353        seq_printf(m, "protocol: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PROTO));
 354        seq_printf(m, "port: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PORT));
 355        return 0;
 356}
 357
 358static int
 359rpc_info_open(struct inode *inode, struct file *file)
 360{
 361        struct rpc_clnt *clnt;
 362        int ret = single_open(file, rpc_show_info, NULL);
 363
 364        if (!ret) {
 365                struct seq_file *m = file->private_data;
 366                mutex_lock(&inode->i_mutex);
 367                clnt = RPC_I(inode)->private;
 368                if (clnt) {
 369                        kref_get(&clnt->cl_kref);
 370                        m->private = clnt;
 371                } else {
 372                        single_release(inode, file);
 373                        ret = -EINVAL;
 374                }
 375                mutex_unlock(&inode->i_mutex);
 376        }
 377        return ret;
 378}
 379
 380static int
 381rpc_info_release(struct inode *inode, struct file *file)
 382{
 383        struct seq_file *m = file->private_data;
 384        struct rpc_clnt *clnt = (struct rpc_clnt *)m->private;
 385
 386        if (clnt)
 387                rpc_release_client(clnt);
 388        return single_release(inode, file);
 389}
 390
 391static const struct file_operations rpc_info_operations = {
 392        .owner          = THIS_MODULE,
 393        .open           = rpc_info_open,
 394        .read           = seq_read,
 395        .llseek         = seq_lseek,
 396        .release        = rpc_info_release,
 397};
 398
 399
 400/*
 401 * We have a single directory with 1 node in it.
 402 */
 403enum {
 404        RPCAUTH_Root = 1,
 405        RPCAUTH_lockd,
 406        RPCAUTH_mount,
 407        RPCAUTH_nfs,
 408        RPCAUTH_portmap,
 409        RPCAUTH_statd,
 410        RPCAUTH_nfsd4_cb,
 411        RPCAUTH_RootEOF
 412};
 413
 414/*
 415 * Description of fs contents.
 416 */
 417struct rpc_filelist {
 418        char *name;
 419        const struct file_operations *i_fop;
 420        int mode;
 421};
 422
 423static struct rpc_filelist files[] = {
 424        [RPCAUTH_lockd] = {
 425                .name = "lockd",
 426                .mode = S_IFDIR | S_IRUGO | S_IXUGO,
 427        },
 428        [RPCAUTH_mount] = {
 429                .name = "mount",
 430                .mode = S_IFDIR | S_IRUGO | S_IXUGO,
 431        },
 432        [RPCAUTH_nfs] = {
 433                .name = "nfs",
 434                .mode = S_IFDIR | S_IRUGO | S_IXUGO,
 435        },
 436        [RPCAUTH_portmap] = {
 437                .name = "portmap",
 438                .mode = S_IFDIR | S_IRUGO | S_IXUGO,
 439        },
 440        [RPCAUTH_statd] = {
 441                .name = "statd",
 442                .mode = S_IFDIR | S_IRUGO | S_IXUGO,
 443        },
 444        [RPCAUTH_nfsd4_cb] = {
 445                .name = "nfsd4_cb",
 446                .mode = S_IFDIR | S_IRUGO | S_IXUGO,
 447        },
 448};
 449
 450enum {
 451        RPCAUTH_info = 2,
 452        RPCAUTH_EOF
 453};
 454
 455static struct rpc_filelist authfiles[] = {
 456        [RPCAUTH_info] = {
 457                .name = "info",
 458                .i_fop = &rpc_info_operations,
 459                .mode = S_IFREG | S_IRUSR,
 460        },
 461};
 462
 463struct vfsmount *rpc_get_mount(void)
 464{
 465        int err;
 466
 467        err = simple_pin_fs(&rpc_pipe_fs_type, &rpc_mount, &rpc_mount_count);
 468        if (err != 0)
 469                return ERR_PTR(err);
 470        return rpc_mount;
 471}
 472
 473void rpc_put_mount(void)
 474{
 475        simple_release_fs(&rpc_mount, &rpc_mount_count);
 476}
 477
 478static int rpc_delete_dentry(struct dentry *dentry)
 479{
 480        return 1;
 481}
 482
 483static const struct dentry_operations rpc_dentry_operations = {
 484        .d_delete = rpc_delete_dentry,
 485};
 486
 487static int
 488rpc_lookup_parent(char *path, struct nameidata *nd)
 489{
 490        struct vfsmount *mnt;
 491
 492        if (path[0] == '\0')
 493                return -ENOENT;
 494
 495        mnt = rpc_get_mount();
 496        if (IS_ERR(mnt)) {
 497                printk(KERN_WARNING "%s: %s failed to mount "
 498                               "pseudofilesystem \n", __FILE__, __func__);
 499                return PTR_ERR(mnt);
 500        }
 501
 502        if (vfs_path_lookup(mnt->mnt_root, mnt, path, LOOKUP_PARENT, nd)) {
 503                printk(KERN_WARNING "%s: %s failed to find path %s\n",
 504                                __FILE__, __func__, path);
 505                rpc_put_mount();
 506                return -ENOENT;
 507        }
 508        return 0;
 509}
 510
 511static void
 512rpc_release_path(struct nameidata *nd)
 513{
 514        path_put(&nd->path);
 515        rpc_put_mount();
 516}
 517
 518static struct inode *
 519rpc_get_inode(struct super_block *sb, int mode)
 520{
 521        struct inode *inode = new_inode(sb);
 522        if (!inode)
 523                return NULL;
 524        inode->i_mode = mode;
 525        inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
 526        switch(mode & S_IFMT) {
 527                case S_IFDIR:
 528                        inode->i_fop = &simple_dir_operations;
 529                        inode->i_op = &simple_dir_inode_operations;
 530                        inc_nlink(inode);
 531                default:
 532                        break;
 533        }
 534        return inode;
 535}
 536
 537/*
 538 * FIXME: This probably has races.
 539 */
 540static void rpc_depopulate(struct dentry *parent,
 541                           unsigned long start, unsigned long eof)
 542{
 543        struct inode *dir = parent->d_inode;
 544        struct list_head *pos, *next;
 545        struct dentry *dentry, *dvec[10];
 546        int n = 0;
 547
 548        mutex_lock_nested(&dir->i_mutex, I_MUTEX_CHILD);
 549repeat:
 550        spin_lock(&dcache_lock);
 551        list_for_each_safe(pos, next, &parent->d_subdirs) {
 552                dentry = list_entry(pos, struct dentry, d_u.d_child);
 553                if (!dentry->d_inode ||
 554                                dentry->d_inode->i_ino < start ||
 555                                dentry->d_inode->i_ino >= eof)
 556                        continue;
 557                spin_lock(&dentry->d_lock);
 558                if (!d_unhashed(dentry)) {
 559                        dget_locked(dentry);
 560                        __d_drop(dentry);
 561                        spin_unlock(&dentry->d_lock);
 562                        dvec[n++] = dentry;
 563                        if (n == ARRAY_SIZE(dvec))
 564                                break;
 565                } else
 566                        spin_unlock(&dentry->d_lock);
 567        }
 568        spin_unlock(&dcache_lock);
 569        if (n) {
 570                do {
 571                        dentry = dvec[--n];
 572                        if (S_ISREG(dentry->d_inode->i_mode))
 573                                simple_unlink(dir, dentry);
 574                        else if (S_ISDIR(dentry->d_inode->i_mode))
 575                                simple_rmdir(dir, dentry);
 576                        d_delete(dentry);
 577                        dput(dentry);
 578                } while (n);
 579                goto repeat;
 580        }
 581        mutex_unlock(&dir->i_mutex);
 582}
 583
 584static int
 585rpc_populate(struct dentry *parent,
 586                struct rpc_filelist *files,
 587                int start, int eof)
 588{
 589        struct inode *inode, *dir = parent->d_inode;
 590        void *private = RPC_I(dir)->private;
 591        struct dentry *dentry;
 592        int mode, i;
 593
 594        mutex_lock(&dir->i_mutex);
 595        for (i = start; i < eof; i++) {
 596                dentry = d_alloc_name(parent, files[i].name);
 597                if (!dentry)
 598                        goto out_bad;
 599                dentry->d_op = &rpc_dentry_operations;
 600                mode = files[i].mode;
 601                inode = rpc_get_inode(dir->i_sb, mode);
 602                if (!inode) {
 603                        dput(dentry);
 604                        goto out_bad;
 605                }
 606                inode->i_ino = i;
 607                if (files[i].i_fop)
 608                        inode->i_fop = files[i].i_fop;
 609                if (private)
 610                        rpc_inode_setowner(inode, private);
 611                if (S_ISDIR(mode))
 612                        inc_nlink(dir);
 613                d_add(dentry, inode);
 614                fsnotify_create(dir, dentry);
 615        }
 616        mutex_unlock(&dir->i_mutex);
 617        return 0;
 618out_bad:
 619        mutex_unlock(&dir->i_mutex);
 620        printk(KERN_WARNING "%s: %s failed to populate directory %s\n",
 621                        __FILE__, __func__, parent->d_name.name);
 622        return -ENOMEM;
 623}
 624
 625static int
 626__rpc_mkdir(struct inode *dir, struct dentry *dentry)
 627{
 628        struct inode *inode;
 629
 630        inode = rpc_get_inode(dir->i_sb, S_IFDIR | S_IRUGO | S_IXUGO);
 631        if (!inode)
 632                goto out_err;
 633        inode->i_ino = iunique(dir->i_sb, 100);
 634        d_instantiate(dentry, inode);
 635        inc_nlink(dir);
 636        fsnotify_mkdir(dir, dentry);
 637        return 0;
 638out_err:
 639        printk(KERN_WARNING "%s: %s failed to allocate inode for dentry %s\n",
 640                        __FILE__, __func__, dentry->d_name.name);
 641        return -ENOMEM;
 642}
 643
 644static int
 645__rpc_rmdir(struct inode *dir, struct dentry *dentry)
 646{
 647        int error;
 648        error = simple_rmdir(dir, dentry);
 649        if (!error)
 650                d_delete(dentry);
 651        return error;
 652}
 653
 654static struct dentry *
 655rpc_lookup_create(struct dentry *parent, const char *name, int len, int exclusive)
 656{
 657        struct inode *dir = parent->d_inode;
 658        struct dentry *dentry;
 659
 660        mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
 661        dentry = lookup_one_len(name, parent, len);
 662        if (IS_ERR(dentry))
 663                goto out_err;
 664        if (!dentry->d_inode)
 665                dentry->d_op = &rpc_dentry_operations;
 666        else if (exclusive) {
 667                dput(dentry);
 668                dentry = ERR_PTR(-EEXIST);
 669                goto out_err;
 670        }
 671        return dentry;
 672out_err:
 673        mutex_unlock(&dir->i_mutex);
 674        return dentry;
 675}
 676
 677static struct dentry *
 678rpc_lookup_negative(char *path, struct nameidata *nd)
 679{
 680        struct dentry *dentry;
 681        int error;
 682
 683        if ((error = rpc_lookup_parent(path, nd)) != 0)
 684                return ERR_PTR(error);
 685        dentry = rpc_lookup_create(nd->path.dentry, nd->last.name, nd->last.len,
 686                                   1);
 687        if (IS_ERR(dentry))
 688                rpc_release_path(nd);
 689        return dentry;
 690}
 691
 692/**
 693 * rpc_mkdir - Create a new directory in rpc_pipefs
 694 * @path: path from the rpc_pipefs root to the new directory
 695 * @rpc_client: rpc client to associate with this directory
 696 *
 697 * This creates a directory at the given @path associated with
 698 * @rpc_clnt, which will contain a file named "info" with some basic
 699 * information about the client, together with any "pipes" that may
 700 * later be created using rpc_mkpipe().
 701 */
 702struct dentry *
 703rpc_mkdir(char *path, struct rpc_clnt *rpc_client)
 704{
 705        struct nameidata nd;
 706        struct dentry *dentry;
 707        struct inode *dir;
 708        int error;
 709
 710        dentry = rpc_lookup_negative(path, &nd);
 711        if (IS_ERR(dentry))
 712                return dentry;
 713        dir = nd.path.dentry->d_inode;
 714        if ((error = __rpc_mkdir(dir, dentry)) != 0)
 715                goto err_dput;
 716        RPC_I(dentry->d_inode)->private = rpc_client;
 717        error = rpc_populate(dentry, authfiles,
 718                        RPCAUTH_info, RPCAUTH_EOF);
 719        if (error)
 720                goto err_depopulate;
 721        dget(dentry);
 722out:
 723        mutex_unlock(&dir->i_mutex);
 724        rpc_release_path(&nd);
 725        return dentry;
 726err_depopulate:
 727        rpc_depopulate(dentry, RPCAUTH_info, RPCAUTH_EOF);
 728        __rpc_rmdir(dir, dentry);
 729err_dput:
 730        dput(dentry);
 731        printk(KERN_WARNING "%s: %s() failed to create directory %s (errno = %d)\n",
 732                        __FILE__, __func__, path, error);
 733        dentry = ERR_PTR(error);
 734        goto out;
 735}
 736
 737/**
 738 * rpc_rmdir - Remove a directory created with rpc_mkdir()
 739 * @dentry: directory to remove
 740 */
 741int
 742rpc_rmdir(struct dentry *dentry)
 743{
 744        struct dentry *parent;
 745        struct inode *dir;
 746        int error;
 747
 748        parent = dget_parent(dentry);
 749        dir = parent->d_inode;
 750        mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
 751        rpc_depopulate(dentry, RPCAUTH_info, RPCAUTH_EOF);
 752        error = __rpc_rmdir(dir, dentry);
 753        dput(dentry);
 754        mutex_unlock(&dir->i_mutex);
 755        dput(parent);
 756        return error;
 757}
 758
 759/**
 760 * rpc_mkpipe - make an rpc_pipefs file for kernel<->userspace communication
 761 * @parent: dentry of directory to create new "pipe" in
 762 * @name: name of pipe
 763 * @private: private data to associate with the pipe, for the caller's use
 764 * @ops: operations defining the behavior of the pipe: upcall, downcall,
 765 *      release_pipe, open_pipe, and destroy_msg.
 766 * @flags: rpc_inode flags
 767 *
 768 * Data is made available for userspace to read by calls to
 769 * rpc_queue_upcall().  The actual reads will result in calls to
 770 * @ops->upcall, which will be called with the file pointer,
 771 * message, and userspace buffer to copy to.
 772 *
 773 * Writes can come at any time, and do not necessarily have to be
 774 * responses to upcalls.  They will result in calls to @msg->downcall.
 775 *
 776 * The @private argument passed here will be available to all these methods
 777 * from the file pointer, via RPC_I(file->f_dentry->d_inode)->private.
 778 */
 779struct dentry *
 780rpc_mkpipe(struct dentry *parent, const char *name, void *private, struct rpc_pipe_ops *ops, int flags)
 781{
 782        struct dentry *dentry;
 783        struct inode *dir, *inode;
 784        struct rpc_inode *rpci;
 785
 786        dentry = rpc_lookup_create(parent, name, strlen(name), 0);
 787        if (IS_ERR(dentry))
 788                return dentry;
 789        dir = parent->d_inode;
 790        if (dentry->d_inode) {
 791                rpci = RPC_I(dentry->d_inode);
 792                if (rpci->private != private ||
 793                                rpci->ops != ops ||
 794                                rpci->flags != flags) {
 795                        dput (dentry);
 796                        dentry = ERR_PTR(-EBUSY);
 797                }
 798                rpci->nkern_readwriters++;
 799                goto out;
 800        }
 801        inode = rpc_get_inode(dir->i_sb, S_IFIFO | S_IRUSR | S_IWUSR);
 802        if (!inode)
 803                goto err_dput;
 804        inode->i_ino = iunique(dir->i_sb, 100);
 805        inode->i_fop = &rpc_pipe_fops;
 806        d_instantiate(dentry, inode);
 807        rpci = RPC_I(inode);
 808        rpci->private = private;
 809        rpci->flags = flags;
 810        rpci->ops = ops;
 811        rpci->nkern_readwriters = 1;
 812        fsnotify_create(dir, dentry);
 813        dget(dentry);
 814out:
 815        mutex_unlock(&dir->i_mutex);
 816        return dentry;
 817err_dput:
 818        dput(dentry);
 819        dentry = ERR_PTR(-ENOMEM);
 820        printk(KERN_WARNING "%s: %s() failed to create pipe %s/%s (errno = %d)\n",
 821                        __FILE__, __func__, parent->d_name.name, name,
 822                        -ENOMEM);
 823        goto out;
 824}
 825EXPORT_SYMBOL_GPL(rpc_mkpipe);
 826
 827/**
 828 * rpc_unlink - remove a pipe
 829 * @dentry: dentry for the pipe, as returned from rpc_mkpipe
 830 *
 831 * After this call, lookups will no longer find the pipe, and any
 832 * attempts to read or write using preexisting opens of the pipe will
 833 * return -EPIPE.
 834 */
 835int
 836rpc_unlink(struct dentry *dentry)
 837{
 838        struct dentry *parent;
 839        struct inode *dir;
 840        int error = 0;
 841
 842        parent = dget_parent(dentry);
 843        dir = parent->d_inode;
 844        mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
 845        if (--RPC_I(dentry->d_inode)->nkern_readwriters == 0) {
 846                rpc_close_pipes(dentry->d_inode);
 847                error = simple_unlink(dir, dentry);
 848                if (!error)
 849                        d_delete(dentry);
 850        }
 851        dput(dentry);
 852        mutex_unlock(&dir->i_mutex);
 853        dput(parent);
 854        return error;
 855}
 856EXPORT_SYMBOL_GPL(rpc_unlink);
 857
 858/*
 859 * populate the filesystem
 860 */
 861static struct super_operations s_ops = {
 862        .alloc_inode    = rpc_alloc_inode,
 863        .destroy_inode  = rpc_destroy_inode,
 864        .statfs         = simple_statfs,
 865};
 866
 867#define RPCAUTH_GSSMAGIC 0x67596969
 868
 869static int
 870rpc_fill_super(struct super_block *sb, void *data, int silent)
 871{
 872        struct inode *inode;
 873        struct dentry *root;
 874
 875        sb->s_blocksize = PAGE_CACHE_SIZE;
 876        sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 877        sb->s_magic = RPCAUTH_GSSMAGIC;
 878        sb->s_op = &s_ops;
 879        sb->s_time_gran = 1;
 880
 881        inode = rpc_get_inode(sb, S_IFDIR | 0755);
 882        if (!inode)
 883                return -ENOMEM;
 884        root = d_alloc_root(inode);
 885        if (!root) {
 886                iput(inode);
 887                return -ENOMEM;
 888        }
 889        if (rpc_populate(root, files, RPCAUTH_Root + 1, RPCAUTH_RootEOF))
 890                goto out;
 891        sb->s_root = root;
 892        return 0;
 893out:
 894        d_genocide(root);
 895        dput(root);
 896        return -ENOMEM;
 897}
 898
 899static int
 900rpc_get_sb(struct file_system_type *fs_type,
 901                int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 902{
 903        return get_sb_single(fs_type, flags, data, rpc_fill_super, mnt);
 904}
 905
 906static struct file_system_type rpc_pipe_fs_type = {
 907        .owner          = THIS_MODULE,
 908        .name           = "rpc_pipefs",
 909        .get_sb         = rpc_get_sb,
 910        .kill_sb        = kill_litter_super,
 911};
 912
 913static void
 914init_once(void *foo)
 915{
 916        struct rpc_inode *rpci = (struct rpc_inode *) foo;
 917
 918        inode_init_once(&rpci->vfs_inode);
 919        rpci->private = NULL;
 920        rpci->nreaders = 0;
 921        rpci->nwriters = 0;
 922        INIT_LIST_HEAD(&rpci->in_upcall);
 923        INIT_LIST_HEAD(&rpci->in_downcall);
 924        INIT_LIST_HEAD(&rpci->pipe);
 925        rpci->pipelen = 0;
 926        init_waitqueue_head(&rpci->waitq);
 927        INIT_DELAYED_WORK(&rpci->queue_timeout,
 928                            rpc_timeout_upcall_queue);
 929        rpci->ops = NULL;
 930}
 931
 932int register_rpc_pipefs(void)
 933{
 934        int err;
 935
 936        rpc_inode_cachep = kmem_cache_create("rpc_inode_cache",
 937                                sizeof(struct rpc_inode),
 938                                0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
 939                                                SLAB_MEM_SPREAD),
 940                                init_once);
 941        if (!rpc_inode_cachep)
 942                return -ENOMEM;
 943        err = register_filesystem(&rpc_pipe_fs_type);
 944        if (err) {
 945                kmem_cache_destroy(rpc_inode_cachep);
 946                return err;
 947        }
 948
 949        return 0;
 950}
 951
 952void unregister_rpc_pipefs(void)
 953{
 954        kmem_cache_destroy(rpc_inode_cachep);
 955        unregister_filesystem(&rpc_pipe_fs_type);
 956}
 957