net/sunrpc/rpc_pipe.c

   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/config.h>
  12 #include <linux/module.h>
  13 #include <linux/slab.h>
  14 #include <linux/string.h>
  15 #include <linux/pagemap.h>
  16 #include <linux/mount.h>
  17 #include <linux/namei.h>
  18 #include <linux/dnotify.h>
  19 #include <linux/kernel.h>
  20
  21 #include <asm/ioctls.h>
  22 #include <linux/fs.h>
  23 #include <linux/poll.h>
  24 #include <linux/wait.h>
  25 #include <linux/seq_file.h>
  26
  27 #include <linux/sunrpc/clnt.h>
  28 #include <linux/workqueue.h>
  29 #include <linux/sunrpc/rpc_pipe_fs.h>
  30
  31 static struct vfsmount *rpc_mount __read_mostly;
  32 static int rpc_mount_count;
  33
  34 static struct file_system_type rpc_pipe_fs_type;
  35
  36
  37 static kmem_cache_t *rpc_inode_cachep __read_mostly;
  38
  39 #define RPC_UPCALL_TIMEOUT (30*HZ)
  40
  41 static void
  42 __rpc_purge_list(struct rpc_inode *rpci, struct list_head *head, int err)
  43 {
  44         struct rpc_pipe_msg *msg;
  45         void (*destroy_msg)(struct rpc_pipe_msg *);
  46
  47         destroy_msg = rpci->ops->destroy_msg;
  48         while (!list_empty(head)) {
  49                 msg = list_entry(head->next, struct rpc_pipe_msg, list);
  50                 list_del_init(&msg->list);
  51                 msg->errno = err;
  52                 destroy_msg(msg);
  53         }
  54 }
  55
  56 static void
  57 __rpc_purge_upcall(struct inode *inode, int err)
  58 {
  59         struct rpc_inode *rpci = RPC_I(inode);
  60
  61         __rpc_purge_list(rpci, &rpci->pipe, err);
  62         rpci->pipelen = 0;
  63         wake_up(&rpci->waitq);
  64 }
  65
  66 static void
  67 rpc_timeout_upcall_queue(void *data)
  68 {
  69         struct rpc_inode *rpci = (struct rpc_inode *)data;
  70         struct inode *inode = &rpci->vfs_inode;
  71
  72         mutex_lock(&inode->i_mutex);
  73         if (rpci->ops == NULL)
  74                 goto out;
  75         if (rpci->nreaders == 0 && !list_empty(&rpci->pipe))
  76                 __rpc_purge_upcall(inode, -ETIMEDOUT);
  77 out:
  78         mutex_unlock(&inode->i_mutex);
  79 }
  80
  81 int
  82 rpc_queue_upcall(struct inode *inode, struct rpc_pipe_msg *msg)
  83 {
  84         struct rpc_inode *rpci = RPC_I(inode);
  85         int res = -EPIPE;
  86
  87         mutex_lock(&inode->i_mutex);
  88         if (rpci->ops == NULL)
  89                 goto out;
  90         if (rpci->nreaders) {
  91                 list_add_tail(&msg->list, &rpci->pipe);
  92                 rpci->pipelen += msg->len;
  93                 res = 0;
  94         } else if (rpci->flags & RPC_PIPE_WAIT_FOR_OPEN) {
  95                 if (list_empty(&rpci->pipe))
  96                         schedule_delayed_work(&rpci->queue_timeout,
  97                                         RPC_UPCALL_TIMEOUT);
  98                 list_add_tail(&msg->list, &rpci->pipe);
  99                 rpci->pipelen += msg->len;
 100                 res = 0;
 101         }
 102 out:
 103         mutex_unlock(&inode->i_mutex);
 104         wake_up(&rpci->waitq);
 105         return res;
 106 }
 107
 108 static inline void
 109 rpc_inode_setowner(struct inode *inode, void *private)
 110 {
 111         RPC_I(inode)->private = private;
 112 }
 113
 114 static void
 115 rpc_close_pipes(struct inode *inode)
 116 {
 117         struct rpc_inode *rpci = RPC_I(inode);
 118
 119         mutex_lock(&inode->i_mutex);
 120         if (rpci->ops != NULL) {
 121                 rpci->nreaders = 0;
 122                 __rpc_purge_list(rpci, &rpci->in_upcall, -EPIPE);
 123                 __rpc_purge_upcall(inode, -EPIPE);
 124                 rpci->nwriters = 0;
 125                 if (rpci->ops->release_pipe)
 126                         rpci->ops->release_pipe(inode);
 127                 rpci->ops = NULL;
 128         }
 129         rpc_inode_setowner(inode, NULL);
 130         mutex_unlock(&inode->i_mutex);
 131         cancel_delayed_work(&rpci->queue_timeout);
 132         flush_scheduled_work();
 133 }
 134
 135 static struct inode *
 136 rpc_alloc_inode(struct super_block *sb)
 137 {
 138         struct rpc_inode *rpci;
 139         rpci = (struct rpc_inode *)kmem_cache_alloc(rpc_inode_cachep, SLAB_KERNEL);
 140         if (!rpci)
 141                 return NULL;
 142         return &rpci->vfs_inode;
 143 }
 144
 145 static void
 146 rpc_destroy_inode(struct inode *inode)
 147 {
 148         kmem_cache_free(rpc_inode_cachep, RPC_I(inode));
 149 }
 150
 151 static int
 152 rpc_pipe_open(struct inode *inode, struct file *filp)
 153 {
 154         struct rpc_inode *rpci = RPC_I(inode);
 155         int res = -ENXIO;
 156
 157         mutex_lock(&inode->i_mutex);
 158         if (rpci->ops != NULL) {
 159                 if (filp->f_mode & FMODE_READ)
 160                         rpci->nreaders ++;
 161                 if (filp->f_mode & FMODE_WRITE)
 162                         rpci->nwriters ++;
 163                 res = 0;
 164         }
 165         mutex_unlock(&inode->i_mutex);
 166         return res;
 167 }
 168
 169 static int
 170 rpc_pipe_release(struct inode *inode, struct file *filp)
 171 {
 172         struct rpc_inode *rpci = RPC_I(inode);
 173         struct rpc_pipe_msg *msg;
 174
 175         mutex_lock(&inode->i_mutex);
 176         if (rpci->ops == NULL)
 177                 goto out;
 178         msg = (struct rpc_pipe_msg *)filp->private_data;
 179         if (msg != NULL) {
 180                 msg->errno = -EAGAIN;
 181                 list_del_init(&msg->list);
 182                 rpci->ops->destroy_msg(msg);
 183         }
 184         if (filp->f_mode & FMODE_WRITE)
 185                 rpci->nwriters --;
 186         if (filp->f_mode & FMODE_READ)
 187                 rpci->nreaders --;
 188         if (!rpci->nreaders)
 189                 __rpc_purge_upcall(inode, -EAGAIN);
 190         if (rpci->ops->release_pipe)
 191                 rpci->ops->release_pipe(inode);
 192 out:
 193         mutex_unlock(&inode->i_mutex);
 194         return 0;
 195 }
 196
 197 static ssize_t
 198 rpc_pipe_read(struct file *filp, char __user *buf, size_t len, loff_t *offset)
 199 {
 200         struct inode *inode = filp->f_dentry->d_inode;
 201         struct rpc_inode *rpci = RPC_I(inode);
 202         struct rpc_pipe_msg *msg;
 203         int res = 0;
 204
 205         mutex_lock(&inode->i_mutex);
 206         if (rpci->ops == NULL) {
 207                 res = -EPIPE;
 208                 goto out_unlock;
 209         }
 210         msg = filp->private_data;
 211         if (msg == NULL) {
 212                 if (!list_empty(&rpci->pipe)) {
 213                         msg = list_entry(rpci->pipe.next,
 214                                         struct rpc_pipe_msg,
 215                                         list);
 216                         list_move(&msg->list, &rpci->in_upcall);
 217                         rpci->pipelen -= msg->len;
 218                         filp->private_data = msg;
 219                         msg->copied = 0;
 220                 }
 221                 if (msg == NULL)
 222                         goto out_unlock;
 223         }
 224         /* NOTE: it is up to the callback to update msg->copied */
 225         res = rpci->ops->upcall(filp, msg, buf, len);
 226         if (res < 0 || msg->len == msg->copied) {
 227                 filp->private_data = NULL;
 228                 list_del_init(&msg->list);
 229                 rpci->ops->destroy_msg(msg);
 230         }
 231 out_unlock:
 232         mutex_unlock(&inode->i_mutex);
 233         return res;
 234 }
 235
 236 static ssize_t
 237 rpc_pipe_write(struct file *filp, const char __user *buf, size_t len, loff_t *offset)
 238 {
 239         struct inode *inode = filp->f_dentry->d_inode;
 240         struct rpc_inode *rpci = RPC_I(inode);
 241         int res;
 242
 243         mutex_lock(&inode->i_mutex);
 244         res = -EPIPE;
 245         if (rpci->ops != NULL)
 246                 res = rpci->ops->downcall(filp, buf, len);
 247         mutex_unlock(&inode->i_mutex);
 248         return res;
 249 }
 250
 251 static unsigned int
 252 rpc_pipe_poll(struct file *filp, struct poll_table_struct *wait)
 253 {
 254         struct rpc_inode *rpci;
 255         unsigned int mask = 0;
 256
 257         rpci = RPC_I(filp->f_dentry->d_inode);
 258         poll_wait(filp, &rpci->waitq, wait);
 259
 260         mask = POLLOUT | POLLWRNORM;
 261         if (rpci->ops == NULL)
 262                 mask |= POLLERR | POLLHUP;
 263         if (!list_empty(&rpci->pipe))
 264                 mask |= POLLIN | POLLRDNORM;
 265         return mask;
 266 }
 267
 268 static int
 269 rpc_pipe_ioctl(struct inode *ino, struct file *filp,
 270                 unsigned int cmd, unsigned long arg)
 271 {
 272         struct rpc_inode *rpci = RPC_I(filp->f_dentry->d_inode);
 273         int len;
 274
 275         switch (cmd) {
 276         case FIONREAD:
 277                 if (rpci->ops == NULL)
 278                         return -EPIPE;
 279                 len = rpci->pipelen;
 280                 if (filp->private_data) {
 281                         struct rpc_pipe_msg *msg;
 282                         msg = (struct rpc_pipe_msg *)filp->private_data;
 283                         len += msg->len - msg->copied;
 284                 }
 285                 return put_user(len, (int __user *)arg);
 286         default:
 287                 return -EINVAL;
 288         }
 289 }
 290
 291 static struct file_operations rpc_pipe_fops = {
 292         .owner          = THIS_MODULE,
 293         .llseek         = no_llseek,
 294         .read           = rpc_pipe_read,
 295         .write          = rpc_pipe_write,
 296         .poll           = rpc_pipe_poll,
 297         .ioctl          = rpc_pipe_ioctl,
 298         .open           = rpc_pipe_open,
 299         .release        = rpc_pipe_release,
 300 };
 301
 302 static int
 303 rpc_show_info(struct seq_file *m, void *v)
 304 {
 305         struct rpc_clnt *clnt = m->private;
 306
 307         seq_printf(m, "RPC server: %s\n", clnt->cl_server);
 308         seq_printf(m, "service: %s (%d) version %d\n", clnt->cl_protname,
 309                         clnt->cl_prog, clnt->cl_vers);
 310         seq_printf(m, "address: %u.%u.%u.%u\n",
 311                         NIPQUAD(clnt->cl_xprt->addr.sin_addr.s_addr));
 312         seq_printf(m, "protocol: %s\n",
 313                         clnt->cl_xprt->prot == IPPROTO_UDP ? "udp" : "tcp");
 314         return 0;
 315 }
 316
 317 static int
 318 rpc_info_open(struct inode *inode, struct file *file)
 319 {
 320         struct rpc_clnt *clnt;
 321         int ret = single_open(file, rpc_show_info, NULL);
 322
 323         if (!ret) {
 324                 struct seq_file *m = file->private_data;
 325                 mutex_lock(&inode->i_mutex);
 326                 clnt = RPC_I(inode)->private;
 327                 if (clnt) {
 328                         atomic_inc(&clnt->cl_users);
 329                         m->private = clnt;
 330                 } else {
 331                         single_release(inode, file);
 332                         ret = -EINVAL;
 333                 }
 334                 mutex_unlock(&inode->i_mutex);
 335         }
 336         return ret;
 337 }
 338
 339 static int
 340 rpc_info_release(struct inode *inode, struct file *file)
 341 {
 342         struct seq_file *m = file->private_data;
 343         struct rpc_clnt *clnt = (struct rpc_clnt *)m->private;
 344
 345         if (clnt)
 346                 rpc_release_client(clnt);
 347         return single_release(inode, file);
 348 }
 349
 350 static struct file_operations rpc_info_operations = {
 351         .owner          = THIS_MODULE,
 352         .open           = rpc_info_open,
 353         .read           = seq_read,
 354         .llseek         = seq_lseek,
 355         .release        = rpc_info_release,
 356 };
 357
 358
 359 /*
 360  * We have a single directory with 1 node in it.
 361  */
 362 enum {
 363         RPCAUTH_Root = 1,
 364         RPCAUTH_lockd,
 365         RPCAUTH_mount,
 366         RPCAUTH_nfs,
 367         RPCAUTH_portmap,
 368         RPCAUTH_statd,
 369         RPCAUTH_RootEOF
 370 };
 371
 372 /*
 373  * Description of fs contents.
 374  */
 375 struct rpc_filelist {
 376         char *name;
 377         struct file_operations *i_fop;
 378         int mode;
 379 };
 380
 381 static struct rpc_filelist files[] = {
 382         [RPCAUTH_lockd] = {
 383                 .name = "lockd",
 384                 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
 385         },
 386         [RPCAUTH_mount] = {
 387                 .name = "mount",
 388                 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
 389         },
 390         [RPCAUTH_nfs] = {
 391                 .name = "nfs",
 392                 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
 393         },
 394         [RPCAUTH_portmap] = {
 395                 .name = "portmap",
 396                 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
 397         },
 398         [RPCAUTH_statd] = {
 399                 .name = "statd",
 400                 .mode = S_IFDIR | S_IRUGO | S_IXUGO,
 401         },
 402 };
 403
 404 enum {
 405         RPCAUTH_info = 2,
 406         RPCAUTH_EOF
 407 };
 408
 409 static struct rpc_filelist authfiles[] = {
 410         [RPCAUTH_info] = {
 411                 .name = "info",
 412                 .i_fop = &rpc_info_operations,
 413                 .mode = S_IFREG | S_IRUSR,
 414         },
 415 };
 416
 417 static int
 418 rpc_get_mount(void)
 419 {
 420         return simple_pin_fs("rpc_pipefs", &rpc_mount, &rpc_mount_count);
 421 }
 422
 423 static void
 424 rpc_put_mount(void)
 425 {
 426         simple_release_fs(&rpc_mount, &rpc_mount_count);
 427 }
 428
 429 static int
 430 rpc_lookup_parent(char *path, struct nameidata *nd)
 431 {
 432         if (path[0] == '\0')
 433                 return -ENOENT;
 434         if (rpc_get_mount()) {
 435                 printk(KERN_WARNING "%s: %s failed to mount "
 436                                "pseudofilesystem \n", __FILE__, __FUNCTION__);
 437                 return -ENODEV;
 438         }
 439         nd->mnt = mntget(rpc_mount);
 440         nd->dentry = dget(rpc_mount->mnt_root);
 441         nd->last_type = LAST_ROOT;
 442         nd->flags = LOOKUP_PARENT;
 443         nd->depth = 0;
 444
 445         if (path_walk(path, nd)) {
 446                 printk(KERN_WARNING "%s: %s failed to find path %s\n",
 447                                 __FILE__, __FUNCTION__, path);
 448                 rpc_put_mount();
 449                 return -ENOENT;
 450         }
 451         return 0;
 452 }
 453
 454 static void
 455 rpc_release_path(struct nameidata *nd)
 456 {
 457         path_release(nd);
 458         rpc_put_mount();
 459 }
 460
 461 static struct inode *
 462 rpc_get_inode(struct super_block *sb, int mode)
 463 {
 464         struct inode *inode = new_inode(sb);
 465         if (!inode)
 466                 return NULL;
 467         inode->i_mode = mode;
 468         inode->i_uid = inode->i_gid = 0;
 469         inode->i_blksize = PAGE_CACHE_SIZE;
 470         inode->i_blocks = 0;
 471         inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
 472         switch(mode & S_IFMT) {
 473                 case S_IFDIR:
 474                         inode->i_fop = &simple_dir_operations;
 475                         inode->i_op = &simple_dir_inode_operations;
 476                         inode->i_nlink++;
 477                 default:
 478                         break;
 479         }
 480         return inode;
 481 }
 482
 483 /*
 484  * FIXME: This probably has races.
 485  */
 486 static void
 487 rpc_depopulate(struct dentry *parent)
 488 {
 489         struct inode *dir = parent->d_inode;
 490         struct list_head *pos, *next;
 491         struct dentry *dentry, *dvec[10];
 492         int n = 0;
 493
 494         mutex_lock(&dir->i_mutex);
 495 repeat:
 496         spin_lock(&dcache_lock);
 497         list_for_each_safe(pos, next, &parent->d_subdirs) {
 498                 dentry = list_entry(pos, struct dentry, d_u.d_child);
 499                 spin_lock(&dentry->d_lock);
 500                 if (!d_unhashed(dentry)) {
 501                         dget_locked(dentry);
 502                         __d_drop(dentry);
 503                         spin_unlock(&dentry->d_lock);
 504                         dvec[n++] = dentry;
 505                         if (n == ARRAY_SIZE(dvec))
 506                                 break;
 507                 } else
 508                         spin_unlock(&dentry->d_lock);
 509         }
 510         spin_unlock(&dcache_lock);
 511         if (n) {
 512                 do {
 513                         dentry = dvec[--n];
 514                         if (dentry->d_inode) {
 515                                 rpc_close_pipes(dentry->d_inode);
 516                                 simple_unlink(dir, dentry);
 517                         }
 518                         dput(dentry);
 519                 } while (n);
 520                 goto repeat;
 521         }
 522         mutex_unlock(&dir->i_mutex);
 523 }
 524
 525 static int
 526 rpc_populate(struct dentry *parent,
 527                 struct rpc_filelist *files,
 528                 int start, int eof)
 529 {
 530         struct inode *inode, *dir = parent->d_inode;
 531         void *private = RPC_I(dir)->private;
 532         struct dentry *dentry;
 533         int mode, i;
 534
 535         mutex_lock(&dir->i_mutex);
 536         for (i = start; i < eof; i++) {
 537                 dentry = d_alloc_name(parent, files[i].name);
 538                 if (!dentry)
 539                         goto out_bad;
 540                 mode = files[i].mode;
 541                 inode = rpc_get_inode(dir->i_sb, mode);
 542                 if (!inode) {
 543                         dput(dentry);
 544                         goto out_bad;
 545                 }
 546                 inode->i_ino = i;
 547                 if (files[i].i_fop)
 548                         inode->i_fop = files[i].i_fop;
 549                 if (private)
 550                         rpc_inode_setowner(inode, private);
 551                 if (S_ISDIR(mode))
 552                         dir->i_nlink++;
 553                 d_add(dentry, inode);
 554         }
 555         mutex_unlock(&dir->i_mutex);
 556         return 0;
 557 out_bad:
 558         mutex_unlock(&dir->i_mutex);
 559         printk(KERN_WARNING "%s: %s failed to populate directory %s\n",
 560                         __FILE__, __FUNCTION__, parent->d_name.name);
 561         return -ENOMEM;
 562 }
 563
 564 static int
 565 __rpc_mkdir(struct inode *dir, struct dentry *dentry)
 566 {
 567         struct inode *inode;
 568
 569         inode = rpc_get_inode(dir->i_sb, S_IFDIR | S_IRUSR | S_IXUSR);
 570         if (!inode)
 571                 goto out_err;
 572         inode->i_ino = iunique(dir->i_sb, 100);
 573         d_instantiate(dentry, inode);
 574         dir->i_nlink++;
 575         inode_dir_notify(dir, DN_CREATE);
 576         rpc_get_mount();
 577         return 0;
 578 out_err:
 579         printk(KERN_WARNING "%s: %s failed to allocate inode for dentry %s\n",
 580                         __FILE__, __FUNCTION__, dentry->d_name.name);
 581         return -ENOMEM;
 582 }
 583
 584 static int
 585 __rpc_rmdir(struct inode *dir, struct dentry *dentry)
 586 {
 587         int error;
 588
 589         shrink_dcache_parent(dentry);
 590         if (dentry->d_inode)
 591                 rpc_close_pipes(dentry->d_inode);
 592         if ((error = simple_rmdir(dir, dentry)) != 0)
 593                 return error;
 594         if (!error) {
 595                 inode_dir_notify(dir, DN_DELETE);
 596                 d_drop(dentry);
 597                 rpc_put_mount();
 598         }
 599         return 0;
 600 }
 601
 602 static struct dentry *
 603 rpc_lookup_negative(char *path, struct nameidata *nd)
 604 {
 605         struct dentry *dentry;
 606         struct inode *dir;
 607         int error;
 608
 609         if ((error = rpc_lookup_parent(path, nd)) != 0)
 610                 return ERR_PTR(error);
 611         dir = nd->dentry->d_inode;
 612         mutex_lock(&dir->i_mutex);
 613         dentry = lookup_hash(nd);
 614         if (IS_ERR(dentry))
 615                 goto out_err;
 616         if (dentry->d_inode) {
 617                 dput(dentry);
 618                 dentry = ERR_PTR(-EEXIST);
 619                 goto out_err;
 620         }
 621         return dentry;
 622 out_err:
 623         mutex_unlock(&dir->i_mutex);
 624         rpc_release_path(nd);
 625         return dentry;
 626 }
 627
 628
 629 struct dentry *
 630 rpc_mkdir(char *path, struct rpc_clnt *rpc_client)
 631 {
 632         struct nameidata nd;
 633         struct dentry *dentry;
 634         struct inode *dir;
 635         int error;
 636
 637         dentry = rpc_lookup_negative(path, &nd);
 638         if (IS_ERR(dentry))
 639                 return dentry;
 640         dir = nd.dentry->d_inode;
 641         if ((error = __rpc_mkdir(dir, dentry)) != 0)
 642                 goto err_dput;
 643         RPC_I(dentry->d_inode)->private = rpc_client;
 644         error = rpc_populate(dentry, authfiles,
 645                         RPCAUTH_info, RPCAUTH_EOF);
 646         if (error)
 647                 goto err_depopulate;
 648 out:
 649         mutex_unlock(&dir->i_mutex);
 650         rpc_release_path(&nd);
 651         return dentry;
 652 err_depopulate:
 653         rpc_depopulate(dentry);
 654         __rpc_rmdir(dir, dentry);
 655 err_dput:
 656         dput(dentry);
 657         printk(KERN_WARNING "%s: %s() failed to create directory %s (errno = %d)\n",
 658                         __FILE__, __FUNCTION__, path, error);
 659         dentry = ERR_PTR(error);
 660         goto out;
 661 }
 662
 663 int
 664 rpc_rmdir(char *path)
 665 {
 666         struct nameidata nd;
 667         struct dentry *dentry;
 668         struct inode *dir;
 669         int error;
 670
 671         if ((error = rpc_lookup_parent(path, &nd)) != 0)
 672                 return error;
 673         dir = nd.dentry->d_inode;
 674         mutex_lock(&dir->i_mutex);
 675         dentry = lookup_hash(&nd);
 676         if (IS_ERR(dentry)) {
 677                 error = PTR_ERR(dentry);
 678                 goto out_release;
 679         }
 680         rpc_depopulate(dentry);
 681         error = __rpc_rmdir(dir, dentry);
 682         dput(dentry);
 683 out_release:
 684         mutex_unlock(&dir->i_mutex);
 685         rpc_release_path(&nd);
 686         return error;
 687 }
 688
 689 struct dentry *
 690 rpc_mkpipe(char *path, void *private, struct rpc_pipe_ops *ops, int flags)
 691 {
 692         struct nameidata nd;
 693         struct dentry *dentry;
 694         struct inode *dir, *inode;
 695         struct rpc_inode *rpci;
 696
 697         dentry = rpc_lookup_negative(path, &nd);
 698         if (IS_ERR(dentry))
 699                 return dentry;
 700         dir = nd.dentry->d_inode;
 701         inode = rpc_get_inode(dir->i_sb, S_IFSOCK | S_IRUSR | S_IWUSR);
 702         if (!inode)
 703                 goto err_dput;
 704         inode->i_ino = iunique(dir->i_sb, 100);
 705         inode->i_fop = &rpc_pipe_fops;
 706         d_instantiate(dentry, inode);
 707         rpci = RPC_I(inode);
 708         rpci->private = private;
 709         rpci->flags = flags;
 710         rpci->ops = ops;
 711         inode_dir_notify(dir, DN_CREATE);
 712 out:
 713         mutex_unlock(&dir->i_mutex);
 714         rpc_release_path(&nd);
 715         return dentry;
 716 err_dput:
 717         dput(dentry);
 718         dentry = ERR_PTR(-ENOMEM);
 719         printk(KERN_WARNING "%s: %s() failed to create pipe %s (errno = %d)\n",
 720                         __FILE__, __FUNCTION__, path, -ENOMEM);
 721         goto out;
 722 }
 723
 724 int
 725 rpc_unlink(char *path)
 726 {
 727         struct nameidata nd;
 728         struct dentry *dentry;
 729         struct inode *dir;
 730         int error;
 731
 732         if ((error = rpc_lookup_parent(path, &nd)) != 0)
 733                 return error;
 734         dir = nd.dentry->d_inode;
 735         mutex_lock(&dir->i_mutex);
 736         dentry = lookup_hash(&nd);
 737         if (IS_ERR(dentry)) {
 738                 error = PTR_ERR(dentry);
 739                 goto out_release;
 740         }
 741         d_drop(dentry);
 742         if (dentry->d_inode) {
 743                 rpc_close_pipes(dentry->d_inode);
 744                 error = simple_unlink(dir, dentry);
 745         }
 746         dput(dentry);
 747         inode_dir_notify(dir, DN_DELETE);
 748 out_release:
 749         mutex_unlock(&dir->i_mutex);
 750         rpc_release_path(&nd);
 751         return error;
 752 }
 753
 754 /*
 755  * populate the filesystem
 756  */
 757 static struct super_operations s_ops = {
 758         .alloc_inode    = rpc_alloc_inode,
 759         .destroy_inode  = rpc_destroy_inode,
 760         .statfs         = simple_statfs,
 761 };
 762
 763 #define RPCAUTH_GSSMAGIC 0x67596969
 764
 765 static int
 766 rpc_fill_super(struct super_block *sb, void *data, int silent)
 767 {
 768         struct inode *inode;
 769         struct dentry *root;
 770
 771         sb->s_blocksize = PAGE_CACHE_SIZE;
 772         sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
 773         sb->s_magic = RPCAUTH_GSSMAGIC;
 774         sb->s_op = &s_ops;
 775         sb->s_time_gran = 1;
 776
 777         inode = rpc_get_inode(sb, S_IFDIR | 0755);
 778         if (!inode)
 779                 return -ENOMEM;
 780         root = d_alloc_root(inode);
 781         if (!root) {
 782                 iput(inode);
 783                 return -ENOMEM;
 784         }
 785         if (rpc_populate(root, files, RPCAUTH_Root + 1, RPCAUTH_RootEOF))
 786                 goto out;
 787         sb->s_root = root;
 788         return 0;
 789 out:
 790         d_genocide(root);
 791         dput(root);
 792         return -ENOMEM;
 793 }
 794
 795 static struct super_block *
 796 rpc_get_sb(struct file_system_type *fs_type,
 797                 int flags, const char *dev_name, void *data)
 798 {
 799         return get_sb_single(fs_type, flags, data, rpc_fill_super);
 800 }
 801
 802 static struct file_system_type rpc_pipe_fs_type = {
 803         .owner          = THIS_MODULE,
 804         .name           = "rpc_pipefs",
 805         .get_sb         = rpc_get_sb,
 806         .kill_sb        = kill_litter_super,
 807 };
 808
 809 static void
 810 init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
 811 {
 812         struct rpc_inode *rpci = (struct rpc_inode *) foo;
 813
 814         if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
 815             SLAB_CTOR_CONSTRUCTOR) {
 816                 inode_init_once(&rpci->vfs_inode);
 817                 rpci->private = NULL;
 818                 rpci->nreaders = 0;
 819                 rpci->nwriters = 0;
 820                 INIT_LIST_HEAD(&rpci->in_upcall);
 821                 INIT_LIST_HEAD(&rpci->pipe);
 822                 rpci->pipelen = 0;
 823                 init_waitqueue_head(&rpci->waitq);
 824                 INIT_WORK(&rpci->queue_timeout, rpc_timeout_upcall_queue, rpci);
 825                 rpci->ops = NULL;
 826         }
 827 }
 828
 829 int register_rpc_pipefs(void)
 830 {
 831         rpc_inode_cachep = kmem_cache_create("rpc_inode_cache",
 832                                              sizeof(struct rpc_inode),
 833                                              0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT,
 834                                              init_once, NULL);
 835         if (!rpc_inode_cachep)
 836                 return -ENOMEM;
 837         register_filesystem(&rpc_pipe_fs_type);
 838         return 0;
 839 }
 840
 841 void unregister_rpc_pipefs(void)
 842 {
 843         if (kmem_cache_destroy(rpc_inode_cachep))
 844                 printk(KERN_WARNING "RPC: unable to free inode cache\n");
 845         unregister_filesystem(&rpc_pipe_fs_type);
 846 }