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