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