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_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 } 839