1 /* 2 * net/sunrpc/rpc_pipe.c 3 * 4 * Userland/kernel interface for rpcauth_gss. 5 * Code shamelessly plagiarized from fs/nfsd/nfsctl.c 6 * and fs/sysfs/inode.c 7 * 8 * Copyright (c) 2002, Trond Myklebust <trond.myklebust@fys.uio.no> 9 * 10 */ 11 #include <linux/module.h> 12 #include <linux/slab.h> 13 #include <linux/string.h> 14 #include <linux/pagemap.h> 15 #include <linux/mount.h> 16 #include <linux/namei.h> 17 #include <linux/fsnotify.h> 18 #include <linux/kernel.h> 19 #include <linux/rcupdate.h> 20 #include <linux/utsname.h> 21 22 #include <asm/ioctls.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 #include <linux/sunrpc/cache.h> 31 #include <linux/nsproxy.h> 32 #include <linux/notifier.h> 33 34 #include "netns.h" 35 #include "sunrpc.h" 36 37 #define RPCDBG_FACILITY RPCDBG_DEBUG 38 39 #define NET_NAME(net) ((net == &init_net) ? " (init_net)" : "") 40 41 static struct file_system_type rpc_pipe_fs_type; 42 static const struct rpc_pipe_ops gssd_dummy_pipe_ops; 43 44 static struct kmem_cache *rpc_inode_cachep __read_mostly; 45 46 #define RPC_UPCALL_TIMEOUT (30*HZ) 47 48 static BLOCKING_NOTIFIER_HEAD(rpc_pipefs_notifier_list); 49 50 int rpc_pipefs_notifier_register(struct notifier_block *nb) 51 { 52 return blocking_notifier_chain_cond_register(&rpc_pipefs_notifier_list, nb); 53 } 54 EXPORT_SYMBOL_GPL(rpc_pipefs_notifier_register); 55 56 void rpc_pipefs_notifier_unregister(struct notifier_block *nb) 57 { 58 blocking_notifier_chain_unregister(&rpc_pipefs_notifier_list, nb); 59 } 60 EXPORT_SYMBOL_GPL(rpc_pipefs_notifier_unregister); 61 62 static void rpc_purge_list(wait_queue_head_t *waitq, struct list_head *head, 63 void (*destroy_msg)(struct rpc_pipe_msg *), int err) 64 { 65 struct rpc_pipe_msg *msg; 66 67 if (list_empty(head)) 68 return; 69 do { 70 msg = list_entry(head->next, struct rpc_pipe_msg, list); 71 list_del_init(&msg->list); 72 msg->errno = err; 73 destroy_msg(msg); 74 } while (!list_empty(head)); 75 76 if (waitq) 77 wake_up(waitq); 78 } 79 80 static void 81 rpc_timeout_upcall_queue(struct work_struct *work) 82 { 83 LIST_HEAD(free_list); 84 struct rpc_pipe *pipe = 85 container_of(work, struct rpc_pipe, queue_timeout.work); 86 void (*destroy_msg)(struct rpc_pipe_msg *); 87 struct dentry *dentry; 88 89 spin_lock(&pipe->lock); 90 destroy_msg = pipe->ops->destroy_msg; 91 if (pipe->nreaders == 0) { 92 list_splice_init(&pipe->pipe, &free_list); 93 pipe->pipelen = 0; 94 } 95 dentry = dget(pipe->dentry); 96 spin_unlock(&pipe->lock); 97 rpc_purge_list(dentry ? &RPC_I(d_inode(dentry))->waitq : NULL, 98 &free_list, destroy_msg, -ETIMEDOUT); 99 dput(dentry); 100 } 101 102 ssize_t rpc_pipe_generic_upcall(struct file *filp, struct rpc_pipe_msg *msg, 103 char __user *dst, size_t buflen) 104 { 105 char *data = (char *)msg->data + msg->copied; 106 size_t mlen = min(msg->len - msg->copied, buflen); 107 unsigned long left; 108 109 left = copy_to_user(dst, data, mlen); 110 if (left == mlen) { 111 msg->errno = -EFAULT; 112 return -EFAULT; 113 } 114 115 mlen -= left; 116 msg->copied += mlen; 117 msg->errno = 0; 118 return mlen; 119 } 120 EXPORT_SYMBOL_GPL(rpc_pipe_generic_upcall); 121 122 /** 123 * rpc_queue_upcall - queue an upcall message to userspace 124 * @pipe: upcall pipe on which to queue given message 125 * @msg: message to queue 126 * 127 * Call with an @inode created by rpc_mkpipe() to queue an upcall. 128 * A userspace process may then later read the upcall by performing a 129 * read on an open file for this inode. It is up to the caller to 130 * initialize the fields of @msg (other than @msg->list) appropriately. 131 */ 132 int 133 rpc_queue_upcall(struct rpc_pipe *pipe, struct rpc_pipe_msg *msg) 134 { 135 int res = -EPIPE; 136 struct dentry *dentry; 137 138 spin_lock(&pipe->lock); 139 if (pipe->nreaders) { 140 list_add_tail(&msg->list, &pipe->pipe); 141 pipe->pipelen += msg->len; 142 res = 0; 143 } else if (pipe->flags & RPC_PIPE_WAIT_FOR_OPEN) { 144 if (list_empty(&pipe->pipe)) 145 queue_delayed_work(rpciod_workqueue, 146 &pipe->queue_timeout, 147 RPC_UPCALL_TIMEOUT); 148 list_add_tail(&msg->list, &pipe->pipe); 149 pipe->pipelen += msg->len; 150 res = 0; 151 } 152 dentry = dget(pipe->dentry); 153 spin_unlock(&pipe->lock); 154 if (dentry) { 155 wake_up(&RPC_I(d_inode(dentry))->waitq); 156 dput(dentry); 157 } 158 return res; 159 } 160 EXPORT_SYMBOL_GPL(rpc_queue_upcall); 161 162 static inline void 163 rpc_inode_setowner(struct inode *inode, void *private) 164 { 165 RPC_I(inode)->private = private; 166 } 167 168 static void 169 rpc_close_pipes(struct inode *inode) 170 { 171 struct rpc_pipe *pipe = RPC_I(inode)->pipe; 172 int need_release; 173 LIST_HEAD(free_list); 174 175 mutex_lock(&inode->i_mutex); 176 spin_lock(&pipe->lock); 177 need_release = pipe->nreaders != 0 || pipe->nwriters != 0; 178 pipe->nreaders = 0; 179 list_splice_init(&pipe->in_upcall, &free_list); 180 list_splice_init(&pipe->pipe, &free_list); 181 pipe->pipelen = 0; 182 pipe->dentry = NULL; 183 spin_unlock(&pipe->lock); 184 rpc_purge_list(&RPC_I(inode)->waitq, &free_list, pipe->ops->destroy_msg, -EPIPE); 185 pipe->nwriters = 0; 186 if (need_release && pipe->ops->release_pipe) 187 pipe->ops->release_pipe(inode); 188 cancel_delayed_work_sync(&pipe->queue_timeout); 189 rpc_inode_setowner(inode, NULL); 190 RPC_I(inode)->pipe = NULL; 191 mutex_unlock(&inode->i_mutex); 192 } 193 194 static struct inode * 195 rpc_alloc_inode(struct super_block *sb) 196 { 197 struct rpc_inode *rpci; 198 rpci = kmem_cache_alloc(rpc_inode_cachep, GFP_KERNEL); 199 if (!rpci) 200 return NULL; 201 return &rpci->vfs_inode; 202 } 203 204 static void 205 rpc_i_callback(struct rcu_head *head) 206 { 207 struct inode *inode = container_of(head, struct inode, i_rcu); 208 kmem_cache_free(rpc_inode_cachep, RPC_I(inode)); 209 } 210 211 static void 212 rpc_destroy_inode(struct inode *inode) 213 { 214 call_rcu(&inode->i_rcu, rpc_i_callback); 215 } 216 217 static int 218 rpc_pipe_open(struct inode *inode, struct file *filp) 219 { 220 struct rpc_pipe *pipe; 221 int first_open; 222 int res = -ENXIO; 223 224 mutex_lock(&inode->i_mutex); 225 pipe = RPC_I(inode)->pipe; 226 if (pipe == NULL) 227 goto out; 228 first_open = pipe->nreaders == 0 && pipe->nwriters == 0; 229 if (first_open && pipe->ops->open_pipe) { 230 res = pipe->ops->open_pipe(inode); 231 if (res) 232 goto out; 233 } 234 if (filp->f_mode & FMODE_READ) 235 pipe->nreaders++; 236 if (filp->f_mode & FMODE_WRITE) 237 pipe->nwriters++; 238 res = 0; 239 out: 240 mutex_unlock(&inode->i_mutex); 241 return res; 242 } 243 244 static int 245 rpc_pipe_release(struct inode *inode, struct file *filp) 246 { 247 struct rpc_pipe *pipe; 248 struct rpc_pipe_msg *msg; 249 int last_close; 250 251 mutex_lock(&inode->i_mutex); 252 pipe = RPC_I(inode)->pipe; 253 if (pipe == NULL) 254 goto out; 255 msg = filp->private_data; 256 if (msg != NULL) { 257 spin_lock(&pipe->lock); 258 msg->errno = -EAGAIN; 259 list_del_init(&msg->list); 260 spin_unlock(&pipe->lock); 261 pipe->ops->destroy_msg(msg); 262 } 263 if (filp->f_mode & FMODE_WRITE) 264 pipe->nwriters --; 265 if (filp->f_mode & FMODE_READ) { 266 pipe->nreaders --; 267 if (pipe->nreaders == 0) { 268 LIST_HEAD(free_list); 269 spin_lock(&pipe->lock); 270 list_splice_init(&pipe->pipe, &free_list); 271 pipe->pipelen = 0; 272 spin_unlock(&pipe->lock); 273 rpc_purge_list(&RPC_I(inode)->waitq, &free_list, 274 pipe->ops->destroy_msg, -EAGAIN); 275 } 276 } 277 last_close = pipe->nwriters == 0 && pipe->nreaders == 0; 278 if (last_close && pipe->ops->release_pipe) 279 pipe->ops->release_pipe(inode); 280 out: 281 mutex_unlock(&inode->i_mutex); 282 return 0; 283 } 284 285 static ssize_t 286 rpc_pipe_read(struct file *filp, char __user *buf, size_t len, loff_t *offset) 287 { 288 struct inode *inode = file_inode(filp); 289 struct rpc_pipe *pipe; 290 struct rpc_pipe_msg *msg; 291 int res = 0; 292 293 mutex_lock(&inode->i_mutex); 294 pipe = RPC_I(inode)->pipe; 295 if (pipe == NULL) { 296 res = -EPIPE; 297 goto out_unlock; 298 } 299 msg = filp->private_data; 300 if (msg == NULL) { 301 spin_lock(&pipe->lock); 302 if (!list_empty(&pipe->pipe)) { 303 msg = list_entry(pipe->pipe.next, 304 struct rpc_pipe_msg, 305 list); 306 list_move(&msg->list, &pipe->in_upcall); 307 pipe->pipelen -= msg->len; 308 filp->private_data = msg; 309 msg->copied = 0; 310 } 311 spin_unlock(&pipe->lock); 312 if (msg == NULL) 313 goto out_unlock; 314 } 315 /* NOTE: it is up to the callback to update msg->copied */ 316 res = pipe->ops->upcall(filp, msg, buf, len); 317 if (res < 0 || msg->len == msg->copied) { 318 filp->private_data = NULL; 319 spin_lock(&pipe->lock); 320 list_del_init(&msg->list); 321 spin_unlock(&pipe->lock); 322 pipe->ops->destroy_msg(msg); 323 } 324 out_unlock: 325 mutex_unlock(&inode->i_mutex); 326 return res; 327 } 328 329 static ssize_t 330 rpc_pipe_write(struct file *filp, const char __user *buf, size_t len, loff_t *offset) 331 { 332 struct inode *inode = file_inode(filp); 333 int res; 334 335 mutex_lock(&inode->i_mutex); 336 res = -EPIPE; 337 if (RPC_I(inode)->pipe != NULL) 338 res = RPC_I(inode)->pipe->ops->downcall(filp, buf, len); 339 mutex_unlock(&inode->i_mutex); 340 return res; 341 } 342 343 static unsigned int 344 rpc_pipe_poll(struct file *filp, struct poll_table_struct *wait) 345 { 346 struct inode *inode = file_inode(filp); 347 struct rpc_inode *rpci = RPC_I(inode); 348 unsigned int mask = POLLOUT | POLLWRNORM; 349 350 poll_wait(filp, &rpci->waitq, wait); 351 352 mutex_lock(&inode->i_mutex); 353 if (rpci->pipe == NULL) 354 mask |= POLLERR | POLLHUP; 355 else if (filp->private_data || !list_empty(&rpci->pipe->pipe)) 356 mask |= POLLIN | POLLRDNORM; 357 mutex_unlock(&inode->i_mutex); 358 return mask; 359 } 360 361 static long 362 rpc_pipe_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 363 { 364 struct inode *inode = file_inode(filp); 365 struct rpc_pipe *pipe; 366 int len; 367 368 switch (cmd) { 369 case FIONREAD: 370 mutex_lock(&inode->i_mutex); 371 pipe = RPC_I(inode)->pipe; 372 if (pipe == NULL) { 373 mutex_unlock(&inode->i_mutex); 374 return -EPIPE; 375 } 376 spin_lock(&pipe->lock); 377 len = pipe->pipelen; 378 if (filp->private_data) { 379 struct rpc_pipe_msg *msg; 380 msg = filp->private_data; 381 len += msg->len - msg->copied; 382 } 383 spin_unlock(&pipe->lock); 384 mutex_unlock(&inode->i_mutex); 385 return put_user(len, (int __user *)arg); 386 default: 387 return -EINVAL; 388 } 389 } 390 391 static const struct file_operations rpc_pipe_fops = { 392 .owner = THIS_MODULE, 393 .llseek = no_llseek, 394 .read = rpc_pipe_read, 395 .write = rpc_pipe_write, 396 .poll = rpc_pipe_poll, 397 .unlocked_ioctl = rpc_pipe_ioctl, 398 .open = rpc_pipe_open, 399 .release = rpc_pipe_release, 400 }; 401 402 static int 403 rpc_show_info(struct seq_file *m, void *v) 404 { 405 struct rpc_clnt *clnt = m->private; 406 407 rcu_read_lock(); 408 seq_printf(m, "RPC server: %s\n", 409 rcu_dereference(clnt->cl_xprt)->servername); 410 seq_printf(m, "service: %s (%d) version %d\n", clnt->cl_program->name, 411 clnt->cl_prog, clnt->cl_vers); 412 seq_printf(m, "address: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_ADDR)); 413 seq_printf(m, "protocol: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PROTO)); 414 seq_printf(m, "port: %s\n", rpc_peeraddr2str(clnt, RPC_DISPLAY_PORT)); 415 rcu_read_unlock(); 416 return 0; 417 } 418 419 static int 420 rpc_info_open(struct inode *inode, struct file *file) 421 { 422 struct rpc_clnt *clnt = NULL; 423 int ret = single_open(file, rpc_show_info, NULL); 424 425 if (!ret) { 426 struct seq_file *m = file->private_data; 427 428 spin_lock(&file->f_path.dentry->d_lock); 429 if (!d_unhashed(file->f_path.dentry)) 430 clnt = RPC_I(inode)->private; 431 if (clnt != NULL && atomic_inc_not_zero(&clnt->cl_count)) { 432 spin_unlock(&file->f_path.dentry->d_lock); 433 m->private = clnt; 434 } else { 435 spin_unlock(&file->f_path.dentry->d_lock); 436 single_release(inode, file); 437 ret = -EINVAL; 438 } 439 } 440 return ret; 441 } 442 443 static int 444 rpc_info_release(struct inode *inode, struct file *file) 445 { 446 struct seq_file *m = file->private_data; 447 struct rpc_clnt *clnt = (struct rpc_clnt *)m->private; 448 449 if (clnt) 450 rpc_release_client(clnt); 451 return single_release(inode, file); 452 } 453 454 static const struct file_operations rpc_info_operations = { 455 .owner = THIS_MODULE, 456 .open = rpc_info_open, 457 .read = seq_read, 458 .llseek = seq_lseek, 459 .release = rpc_info_release, 460 }; 461 462 463 /* 464 * Description of fs contents. 465 */ 466 struct rpc_filelist { 467 const char *name; 468 const struct file_operations *i_fop; 469 umode_t mode; 470 }; 471 472 static struct inode * 473 rpc_get_inode(struct super_block *sb, umode_t mode) 474 { 475 struct inode *inode = new_inode(sb); 476 if (!inode) 477 return NULL; 478 inode->i_ino = get_next_ino(); 479 inode->i_mode = mode; 480 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; 481 switch (mode & S_IFMT) { 482 case S_IFDIR: 483 inode->i_fop = &simple_dir_operations; 484 inode->i_op = &simple_dir_inode_operations; 485 inc_nlink(inode); 486 default: 487 break; 488 } 489 return inode; 490 } 491 492 static int __rpc_create_common(struct inode *dir, struct dentry *dentry, 493 umode_t mode, 494 const struct file_operations *i_fop, 495 void *private) 496 { 497 struct inode *inode; 498 499 d_drop(dentry); 500 inode = rpc_get_inode(dir->i_sb, mode); 501 if (!inode) 502 goto out_err; 503 inode->i_ino = iunique(dir->i_sb, 100); 504 if (i_fop) 505 inode->i_fop = i_fop; 506 if (private) 507 rpc_inode_setowner(inode, private); 508 d_add(dentry, inode); 509 return 0; 510 out_err: 511 printk(KERN_WARNING "%s: %s failed to allocate inode for dentry %pd\n", 512 __FILE__, __func__, dentry); 513 dput(dentry); 514 return -ENOMEM; 515 } 516 517 static int __rpc_create(struct inode *dir, struct dentry *dentry, 518 umode_t mode, 519 const struct file_operations *i_fop, 520 void *private) 521 { 522 int err; 523 524 err = __rpc_create_common(dir, dentry, S_IFREG | mode, i_fop, private); 525 if (err) 526 return err; 527 fsnotify_create(dir, dentry); 528 return 0; 529 } 530 531 static int __rpc_mkdir(struct inode *dir, struct dentry *dentry, 532 umode_t mode, 533 const struct file_operations *i_fop, 534 void *private) 535 { 536 int err; 537 538 err = __rpc_create_common(dir, dentry, S_IFDIR | mode, i_fop, private); 539 if (err) 540 return err; 541 inc_nlink(dir); 542 fsnotify_mkdir(dir, dentry); 543 return 0; 544 } 545 546 static void 547 init_pipe(struct rpc_pipe *pipe) 548 { 549 pipe->nreaders = 0; 550 pipe->nwriters = 0; 551 INIT_LIST_HEAD(&pipe->in_upcall); 552 INIT_LIST_HEAD(&pipe->in_downcall); 553 INIT_LIST_HEAD(&pipe->pipe); 554 pipe->pipelen = 0; 555 INIT_DELAYED_WORK(&pipe->queue_timeout, 556 rpc_timeout_upcall_queue); 557 pipe->ops = NULL; 558 spin_lock_init(&pipe->lock); 559 pipe->dentry = NULL; 560 } 561 562 void rpc_destroy_pipe_data(struct rpc_pipe *pipe) 563 { 564 kfree(pipe); 565 } 566 EXPORT_SYMBOL_GPL(rpc_destroy_pipe_data); 567 568 struct rpc_pipe *rpc_mkpipe_data(const struct rpc_pipe_ops *ops, int flags) 569 { 570 struct rpc_pipe *pipe; 571 572 pipe = kzalloc(sizeof(struct rpc_pipe), GFP_KERNEL); 573 if (!pipe) 574 return ERR_PTR(-ENOMEM); 575 init_pipe(pipe); 576 pipe->ops = ops; 577 pipe->flags = flags; 578 return pipe; 579 } 580 EXPORT_SYMBOL_GPL(rpc_mkpipe_data); 581 582 static int __rpc_mkpipe_dentry(struct inode *dir, struct dentry *dentry, 583 umode_t mode, 584 const struct file_operations *i_fop, 585 void *private, 586 struct rpc_pipe *pipe) 587 { 588 struct rpc_inode *rpci; 589 int err; 590 591 err = __rpc_create_common(dir, dentry, S_IFIFO | mode, i_fop, private); 592 if (err) 593 return err; 594 rpci = RPC_I(d_inode(dentry)); 595 rpci->private = private; 596 rpci->pipe = pipe; 597 fsnotify_create(dir, dentry); 598 return 0; 599 } 600 601 static int __rpc_rmdir(struct inode *dir, struct dentry *dentry) 602 { 603 int ret; 604 605 dget(dentry); 606 ret = simple_rmdir(dir, dentry); 607 d_delete(dentry); 608 dput(dentry); 609 return ret; 610 } 611 612 int rpc_rmdir(struct dentry *dentry) 613 { 614 struct dentry *parent; 615 struct inode *dir; 616 int error; 617 618 parent = dget_parent(dentry); 619 dir = d_inode(parent); 620 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT); 621 error = __rpc_rmdir(dir, dentry); 622 mutex_unlock(&dir->i_mutex); 623 dput(parent); 624 return error; 625 } 626 EXPORT_SYMBOL_GPL(rpc_rmdir); 627 628 static int __rpc_unlink(struct inode *dir, struct dentry *dentry) 629 { 630 int ret; 631 632 dget(dentry); 633 ret = simple_unlink(dir, dentry); 634 d_delete(dentry); 635 dput(dentry); 636 return ret; 637 } 638 639 static int __rpc_rmpipe(struct inode *dir, struct dentry *dentry) 640 { 641 struct inode *inode = d_inode(dentry); 642 643 rpc_close_pipes(inode); 644 return __rpc_unlink(dir, dentry); 645 } 646 647 static struct dentry *__rpc_lookup_create_exclusive(struct dentry *parent, 648 const char *name) 649 { 650 struct qstr q = QSTR_INIT(name, strlen(name)); 651 struct dentry *dentry = d_hash_and_lookup(parent, &q); 652 if (!dentry) { 653 dentry = d_alloc(parent, &q); 654 if (!dentry) 655 return ERR_PTR(-ENOMEM); 656 } 657 if (d_really_is_negative(dentry)) 658 return dentry; 659 dput(dentry); 660 return ERR_PTR(-EEXIST); 661 } 662 663 /* 664 * FIXME: This probably has races. 665 */ 666 static void __rpc_depopulate(struct dentry *parent, 667 const struct rpc_filelist *files, 668 int start, int eof) 669 { 670 struct inode *dir = d_inode(parent); 671 struct dentry *dentry; 672 struct qstr name; 673 int i; 674 675 for (i = start; i < eof; i++) { 676 name.name = files[i].name; 677 name.len = strlen(files[i].name); 678 dentry = d_hash_and_lookup(parent, &name); 679 680 if (dentry == NULL) 681 continue; 682 if (d_really_is_negative(dentry)) 683 goto next; 684 switch (d_inode(dentry)->i_mode & S_IFMT) { 685 default: 686 BUG(); 687 case S_IFREG: 688 __rpc_unlink(dir, dentry); 689 break; 690 case S_IFDIR: 691 __rpc_rmdir(dir, dentry); 692 } 693 next: 694 dput(dentry); 695 } 696 } 697 698 static void rpc_depopulate(struct dentry *parent, 699 const struct rpc_filelist *files, 700 int start, int eof) 701 { 702 struct inode *dir = d_inode(parent); 703 704 mutex_lock_nested(&dir->i_mutex, I_MUTEX_CHILD); 705 __rpc_depopulate(parent, files, start, eof); 706 mutex_unlock(&dir->i_mutex); 707 } 708 709 static int rpc_populate(struct dentry *parent, 710 const struct rpc_filelist *files, 711 int start, int eof, 712 void *private) 713 { 714 struct inode *dir = d_inode(parent); 715 struct dentry *dentry; 716 int i, err; 717 718 mutex_lock(&dir->i_mutex); 719 for (i = start; i < eof; i++) { 720 dentry = __rpc_lookup_create_exclusive(parent, files[i].name); 721 err = PTR_ERR(dentry); 722 if (IS_ERR(dentry)) 723 goto out_bad; 724 switch (files[i].mode & S_IFMT) { 725 default: 726 BUG(); 727 case S_IFREG: 728 err = __rpc_create(dir, dentry, 729 files[i].mode, 730 files[i].i_fop, 731 private); 732 break; 733 case S_IFDIR: 734 err = __rpc_mkdir(dir, dentry, 735 files[i].mode, 736 NULL, 737 private); 738 } 739 if (err != 0) 740 goto out_bad; 741 } 742 mutex_unlock(&dir->i_mutex); 743 return 0; 744 out_bad: 745 __rpc_depopulate(parent, files, start, eof); 746 mutex_unlock(&dir->i_mutex); 747 printk(KERN_WARNING "%s: %s failed to populate directory %pd\n", 748 __FILE__, __func__, parent); 749 return err; 750 } 751 752 static struct dentry *rpc_mkdir_populate(struct dentry *parent, 753 const char *name, umode_t mode, void *private, 754 int (*populate)(struct dentry *, void *), void *args_populate) 755 { 756 struct dentry *dentry; 757 struct inode *dir = d_inode(parent); 758 int error; 759 760 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT); 761 dentry = __rpc_lookup_create_exclusive(parent, name); 762 if (IS_ERR(dentry)) 763 goto out; 764 error = __rpc_mkdir(dir, dentry, mode, NULL, private); 765 if (error != 0) 766 goto out_err; 767 if (populate != NULL) { 768 error = populate(dentry, args_populate); 769 if (error) 770 goto err_rmdir; 771 } 772 out: 773 mutex_unlock(&dir->i_mutex); 774 return dentry; 775 err_rmdir: 776 __rpc_rmdir(dir, dentry); 777 out_err: 778 dentry = ERR_PTR(error); 779 goto out; 780 } 781 782 static int rpc_rmdir_depopulate(struct dentry *dentry, 783 void (*depopulate)(struct dentry *)) 784 { 785 struct dentry *parent; 786 struct inode *dir; 787 int error; 788 789 parent = dget_parent(dentry); 790 dir = d_inode(parent); 791 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT); 792 if (depopulate != NULL) 793 depopulate(dentry); 794 error = __rpc_rmdir(dir, dentry); 795 mutex_unlock(&dir->i_mutex); 796 dput(parent); 797 return error; 798 } 799 800 /** 801 * rpc_mkpipe - make an rpc_pipefs file for kernel<->userspace communication 802 * @parent: dentry of directory to create new "pipe" in 803 * @name: name of pipe 804 * @private: private data to associate with the pipe, for the caller's use 805 * @pipe: &rpc_pipe containing input parameters 806 * 807 * Data is made available for userspace to read by calls to 808 * rpc_queue_upcall(). The actual reads will result in calls to 809 * @ops->upcall, which will be called with the file pointer, 810 * message, and userspace buffer to copy to. 811 * 812 * Writes can come at any time, and do not necessarily have to be 813 * responses to upcalls. They will result in calls to @msg->downcall. 814 * 815 * The @private argument passed here will be available to all these methods 816 * from the file pointer, via RPC_I(file_inode(file))->private. 817 */ 818 struct dentry *rpc_mkpipe_dentry(struct dentry *parent, const char *name, 819 void *private, struct rpc_pipe *pipe) 820 { 821 struct dentry *dentry; 822 struct inode *dir = d_inode(parent); 823 umode_t umode = S_IFIFO | S_IRUSR | S_IWUSR; 824 int err; 825 826 if (pipe->ops->upcall == NULL) 827 umode &= ~S_IRUGO; 828 if (pipe->ops->downcall == NULL) 829 umode &= ~S_IWUGO; 830 831 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT); 832 dentry = __rpc_lookup_create_exclusive(parent, name); 833 if (IS_ERR(dentry)) 834 goto out; 835 err = __rpc_mkpipe_dentry(dir, dentry, umode, &rpc_pipe_fops, 836 private, pipe); 837 if (err) 838 goto out_err; 839 out: 840 mutex_unlock(&dir->i_mutex); 841 return dentry; 842 out_err: 843 dentry = ERR_PTR(err); 844 printk(KERN_WARNING "%s: %s() failed to create pipe %pd/%s (errno = %d)\n", 845 __FILE__, __func__, parent, name, 846 err); 847 goto out; 848 } 849 EXPORT_SYMBOL_GPL(rpc_mkpipe_dentry); 850 851 /** 852 * rpc_unlink - remove a pipe 853 * @dentry: dentry for the pipe, as returned from rpc_mkpipe 854 * 855 * After this call, lookups will no longer find the pipe, and any 856 * attempts to read or write using preexisting opens of the pipe will 857 * return -EPIPE. 858 */ 859 int 860 rpc_unlink(struct dentry *dentry) 861 { 862 struct dentry *parent; 863 struct inode *dir; 864 int error = 0; 865 866 parent = dget_parent(dentry); 867 dir = d_inode(parent); 868 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT); 869 error = __rpc_rmpipe(dir, dentry); 870 mutex_unlock(&dir->i_mutex); 871 dput(parent); 872 return error; 873 } 874 EXPORT_SYMBOL_GPL(rpc_unlink); 875 876 /** 877 * rpc_init_pipe_dir_head - initialise a struct rpc_pipe_dir_head 878 * @pdh: pointer to struct rpc_pipe_dir_head 879 */ 880 void rpc_init_pipe_dir_head(struct rpc_pipe_dir_head *pdh) 881 { 882 INIT_LIST_HEAD(&pdh->pdh_entries); 883 pdh->pdh_dentry = NULL; 884 } 885 EXPORT_SYMBOL_GPL(rpc_init_pipe_dir_head); 886 887 /** 888 * rpc_init_pipe_dir_object - initialise a struct rpc_pipe_dir_object 889 * @pdo: pointer to struct rpc_pipe_dir_object 890 * @pdo_ops: pointer to const struct rpc_pipe_dir_object_ops 891 * @pdo_data: pointer to caller-defined data 892 */ 893 void rpc_init_pipe_dir_object(struct rpc_pipe_dir_object *pdo, 894 const struct rpc_pipe_dir_object_ops *pdo_ops, 895 void *pdo_data) 896 { 897 INIT_LIST_HEAD(&pdo->pdo_head); 898 pdo->pdo_ops = pdo_ops; 899 pdo->pdo_data = pdo_data; 900 } 901 EXPORT_SYMBOL_GPL(rpc_init_pipe_dir_object); 902 903 static int 904 rpc_add_pipe_dir_object_locked(struct net *net, 905 struct rpc_pipe_dir_head *pdh, 906 struct rpc_pipe_dir_object *pdo) 907 { 908 int ret = 0; 909 910 if (pdh->pdh_dentry) 911 ret = pdo->pdo_ops->create(pdh->pdh_dentry, pdo); 912 if (ret == 0) 913 list_add_tail(&pdo->pdo_head, &pdh->pdh_entries); 914 return ret; 915 } 916 917 static void 918 rpc_remove_pipe_dir_object_locked(struct net *net, 919 struct rpc_pipe_dir_head *pdh, 920 struct rpc_pipe_dir_object *pdo) 921 { 922 if (pdh->pdh_dentry) 923 pdo->pdo_ops->destroy(pdh->pdh_dentry, pdo); 924 list_del_init(&pdo->pdo_head); 925 } 926 927 /** 928 * rpc_add_pipe_dir_object - associate a rpc_pipe_dir_object to a directory 929 * @net: pointer to struct net 930 * @pdh: pointer to struct rpc_pipe_dir_head 931 * @pdo: pointer to struct rpc_pipe_dir_object 932 * 933 */ 934 int 935 rpc_add_pipe_dir_object(struct net *net, 936 struct rpc_pipe_dir_head *pdh, 937 struct rpc_pipe_dir_object *pdo) 938 { 939 int ret = 0; 940 941 if (list_empty(&pdo->pdo_head)) { 942 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id); 943 944 mutex_lock(&sn->pipefs_sb_lock); 945 ret = rpc_add_pipe_dir_object_locked(net, pdh, pdo); 946 mutex_unlock(&sn->pipefs_sb_lock); 947 } 948 return ret; 949 } 950 EXPORT_SYMBOL_GPL(rpc_add_pipe_dir_object); 951 952 /** 953 * rpc_remove_pipe_dir_object - remove a rpc_pipe_dir_object from a directory 954 * @net: pointer to struct net 955 * @pdh: pointer to struct rpc_pipe_dir_head 956 * @pdo: pointer to struct rpc_pipe_dir_object 957 * 958 */ 959 void 960 rpc_remove_pipe_dir_object(struct net *net, 961 struct rpc_pipe_dir_head *pdh, 962 struct rpc_pipe_dir_object *pdo) 963 { 964 if (!list_empty(&pdo->pdo_head)) { 965 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id); 966 967 mutex_lock(&sn->pipefs_sb_lock); 968 rpc_remove_pipe_dir_object_locked(net, pdh, pdo); 969 mutex_unlock(&sn->pipefs_sb_lock); 970 } 971 } 972 EXPORT_SYMBOL_GPL(rpc_remove_pipe_dir_object); 973 974 /** 975 * rpc_find_or_alloc_pipe_dir_object 976 * @net: pointer to struct net 977 * @pdh: pointer to struct rpc_pipe_dir_head 978 * @match: match struct rpc_pipe_dir_object to data 979 * @alloc: allocate a new struct rpc_pipe_dir_object 980 * @data: user defined data for match() and alloc() 981 * 982 */ 983 struct rpc_pipe_dir_object * 984 rpc_find_or_alloc_pipe_dir_object(struct net *net, 985 struct rpc_pipe_dir_head *pdh, 986 int (*match)(struct rpc_pipe_dir_object *, void *), 987 struct rpc_pipe_dir_object *(*alloc)(void *), 988 void *data) 989 { 990 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id); 991 struct rpc_pipe_dir_object *pdo; 992 993 mutex_lock(&sn->pipefs_sb_lock); 994 list_for_each_entry(pdo, &pdh->pdh_entries, pdo_head) { 995 if (!match(pdo, data)) 996 continue; 997 goto out; 998 } 999 pdo = alloc(data); 1000 if (!pdo) 1001 goto out; 1002 rpc_add_pipe_dir_object_locked(net, pdh, pdo); 1003 out: 1004 mutex_unlock(&sn->pipefs_sb_lock); 1005 return pdo; 1006 } 1007 EXPORT_SYMBOL_GPL(rpc_find_or_alloc_pipe_dir_object); 1008 1009 static void 1010 rpc_create_pipe_dir_objects(struct rpc_pipe_dir_head *pdh) 1011 { 1012 struct rpc_pipe_dir_object *pdo; 1013 struct dentry *dir = pdh->pdh_dentry; 1014 1015 list_for_each_entry(pdo, &pdh->pdh_entries, pdo_head) 1016 pdo->pdo_ops->create(dir, pdo); 1017 } 1018 1019 static void 1020 rpc_destroy_pipe_dir_objects(struct rpc_pipe_dir_head *pdh) 1021 { 1022 struct rpc_pipe_dir_object *pdo; 1023 struct dentry *dir = pdh->pdh_dentry; 1024 1025 list_for_each_entry(pdo, &pdh->pdh_entries, pdo_head) 1026 pdo->pdo_ops->destroy(dir, pdo); 1027 } 1028 1029 enum { 1030 RPCAUTH_info, 1031 RPCAUTH_EOF 1032 }; 1033 1034 static const struct rpc_filelist authfiles[] = { 1035 [RPCAUTH_info] = { 1036 .name = "info", 1037 .i_fop = &rpc_info_operations, 1038 .mode = S_IFREG | S_IRUSR, 1039 }, 1040 }; 1041 1042 static int rpc_clntdir_populate(struct dentry *dentry, void *private) 1043 { 1044 return rpc_populate(dentry, 1045 authfiles, RPCAUTH_info, RPCAUTH_EOF, 1046 private); 1047 } 1048 1049 static void rpc_clntdir_depopulate(struct dentry *dentry) 1050 { 1051 rpc_depopulate(dentry, authfiles, RPCAUTH_info, RPCAUTH_EOF); 1052 } 1053 1054 /** 1055 * rpc_create_client_dir - Create a new rpc_client directory in rpc_pipefs 1056 * @dentry: the parent of new directory 1057 * @name: the name of new directory 1058 * @rpc_client: rpc client to associate with this directory 1059 * 1060 * This creates a directory at the given @path associated with 1061 * @rpc_clnt, which will contain a file named "info" with some basic 1062 * information about the client, together with any "pipes" that may 1063 * later be created using rpc_mkpipe(). 1064 */ 1065 struct dentry *rpc_create_client_dir(struct dentry *dentry, 1066 const char *name, 1067 struct rpc_clnt *rpc_client) 1068 { 1069 struct dentry *ret; 1070 1071 ret = rpc_mkdir_populate(dentry, name, S_IRUGO | S_IXUGO, NULL, 1072 rpc_clntdir_populate, rpc_client); 1073 if (!IS_ERR(ret)) { 1074 rpc_client->cl_pipedir_objects.pdh_dentry = ret; 1075 rpc_create_pipe_dir_objects(&rpc_client->cl_pipedir_objects); 1076 } 1077 return ret; 1078 } 1079 1080 /** 1081 * rpc_remove_client_dir - Remove a directory created with rpc_create_client_dir() 1082 * @rpc_client: rpc_client for the pipe 1083 */ 1084 int rpc_remove_client_dir(struct rpc_clnt *rpc_client) 1085 { 1086 struct dentry *dentry = rpc_client->cl_pipedir_objects.pdh_dentry; 1087 1088 if (dentry == NULL) 1089 return 0; 1090 rpc_destroy_pipe_dir_objects(&rpc_client->cl_pipedir_objects); 1091 rpc_client->cl_pipedir_objects.pdh_dentry = NULL; 1092 return rpc_rmdir_depopulate(dentry, rpc_clntdir_depopulate); 1093 } 1094 1095 static const struct rpc_filelist cache_pipefs_files[3] = { 1096 [0] = { 1097 .name = "channel", 1098 .i_fop = &cache_file_operations_pipefs, 1099 .mode = S_IFREG|S_IRUSR|S_IWUSR, 1100 }, 1101 [1] = { 1102 .name = "content", 1103 .i_fop = &content_file_operations_pipefs, 1104 .mode = S_IFREG|S_IRUSR, 1105 }, 1106 [2] = { 1107 .name = "flush", 1108 .i_fop = &cache_flush_operations_pipefs, 1109 .mode = S_IFREG|S_IRUSR|S_IWUSR, 1110 }, 1111 }; 1112 1113 static int rpc_cachedir_populate(struct dentry *dentry, void *private) 1114 { 1115 return rpc_populate(dentry, 1116 cache_pipefs_files, 0, 3, 1117 private); 1118 } 1119 1120 static void rpc_cachedir_depopulate(struct dentry *dentry) 1121 { 1122 rpc_depopulate(dentry, cache_pipefs_files, 0, 3); 1123 } 1124 1125 struct dentry *rpc_create_cache_dir(struct dentry *parent, const char *name, 1126 umode_t umode, struct cache_detail *cd) 1127 { 1128 return rpc_mkdir_populate(parent, name, umode, NULL, 1129 rpc_cachedir_populate, cd); 1130 } 1131 1132 void rpc_remove_cache_dir(struct dentry *dentry) 1133 { 1134 rpc_rmdir_depopulate(dentry, rpc_cachedir_depopulate); 1135 } 1136 1137 /* 1138 * populate the filesystem 1139 */ 1140 static const struct super_operations s_ops = { 1141 .alloc_inode = rpc_alloc_inode, 1142 .destroy_inode = rpc_destroy_inode, 1143 .statfs = simple_statfs, 1144 }; 1145 1146 #define RPCAUTH_GSSMAGIC 0x67596969 1147 1148 /* 1149 * We have a single directory with 1 node in it. 1150 */ 1151 enum { 1152 RPCAUTH_lockd, 1153 RPCAUTH_mount, 1154 RPCAUTH_nfs, 1155 RPCAUTH_portmap, 1156 RPCAUTH_statd, 1157 RPCAUTH_nfsd4_cb, 1158 RPCAUTH_cache, 1159 RPCAUTH_nfsd, 1160 RPCAUTH_gssd, 1161 RPCAUTH_RootEOF 1162 }; 1163 1164 static const struct rpc_filelist files[] = { 1165 [RPCAUTH_lockd] = { 1166 .name = "lockd", 1167 .mode = S_IFDIR | S_IRUGO | S_IXUGO, 1168 }, 1169 [RPCAUTH_mount] = { 1170 .name = "mount", 1171 .mode = S_IFDIR | S_IRUGO | S_IXUGO, 1172 }, 1173 [RPCAUTH_nfs] = { 1174 .name = "nfs", 1175 .mode = S_IFDIR | S_IRUGO | S_IXUGO, 1176 }, 1177 [RPCAUTH_portmap] = { 1178 .name = "portmap", 1179 .mode = S_IFDIR | S_IRUGO | S_IXUGO, 1180 }, 1181 [RPCAUTH_statd] = { 1182 .name = "statd", 1183 .mode = S_IFDIR | S_IRUGO | S_IXUGO, 1184 }, 1185 [RPCAUTH_nfsd4_cb] = { 1186 .name = "nfsd4_cb", 1187 .mode = S_IFDIR | S_IRUGO | S_IXUGO, 1188 }, 1189 [RPCAUTH_cache] = { 1190 .name = "cache", 1191 .mode = S_IFDIR | S_IRUGO | S_IXUGO, 1192 }, 1193 [RPCAUTH_nfsd] = { 1194 .name = "nfsd", 1195 .mode = S_IFDIR | S_IRUGO | S_IXUGO, 1196 }, 1197 [RPCAUTH_gssd] = { 1198 .name = "gssd", 1199 .mode = S_IFDIR | S_IRUGO | S_IXUGO, 1200 }, 1201 }; 1202 1203 /* 1204 * This call can be used only in RPC pipefs mount notification hooks. 1205 */ 1206 struct dentry *rpc_d_lookup_sb(const struct super_block *sb, 1207 const unsigned char *dir_name) 1208 { 1209 struct qstr dir = QSTR_INIT(dir_name, strlen(dir_name)); 1210 return d_hash_and_lookup(sb->s_root, &dir); 1211 } 1212 EXPORT_SYMBOL_GPL(rpc_d_lookup_sb); 1213 1214 int rpc_pipefs_init_net(struct net *net) 1215 { 1216 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id); 1217 1218 sn->gssd_dummy = rpc_mkpipe_data(&gssd_dummy_pipe_ops, 0); 1219 if (IS_ERR(sn->gssd_dummy)) 1220 return PTR_ERR(sn->gssd_dummy); 1221 1222 mutex_init(&sn->pipefs_sb_lock); 1223 sn->pipe_version = -1; 1224 return 0; 1225 } 1226 1227 void rpc_pipefs_exit_net(struct net *net) 1228 { 1229 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id); 1230 1231 rpc_destroy_pipe_data(sn->gssd_dummy); 1232 } 1233 1234 /* 1235 * This call will be used for per network namespace operations calls. 1236 * Note: Function will be returned with pipefs_sb_lock taken if superblock was 1237 * found. This lock have to be released by rpc_put_sb_net() when all operations 1238 * will be completed. 1239 */ 1240 struct super_block *rpc_get_sb_net(const struct net *net) 1241 { 1242 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id); 1243 1244 mutex_lock(&sn->pipefs_sb_lock); 1245 if (sn->pipefs_sb) 1246 return sn->pipefs_sb; 1247 mutex_unlock(&sn->pipefs_sb_lock); 1248 return NULL; 1249 } 1250 EXPORT_SYMBOL_GPL(rpc_get_sb_net); 1251 1252 void rpc_put_sb_net(const struct net *net) 1253 { 1254 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id); 1255 1256 WARN_ON(sn->pipefs_sb == NULL); 1257 mutex_unlock(&sn->pipefs_sb_lock); 1258 } 1259 EXPORT_SYMBOL_GPL(rpc_put_sb_net); 1260 1261 static const struct rpc_filelist gssd_dummy_clnt_dir[] = { 1262 [0] = { 1263 .name = "clntXX", 1264 .mode = S_IFDIR | S_IRUGO | S_IXUGO, 1265 }, 1266 }; 1267 1268 static ssize_t 1269 dummy_downcall(struct file *filp, const char __user *src, size_t len) 1270 { 1271 return -EINVAL; 1272 } 1273 1274 static const struct rpc_pipe_ops gssd_dummy_pipe_ops = { 1275 .upcall = rpc_pipe_generic_upcall, 1276 .downcall = dummy_downcall, 1277 }; 1278 1279 /* 1280 * Here we present a bogus "info" file to keep rpc.gssd happy. We don't expect 1281 * that it will ever use this info to handle an upcall, but rpc.gssd expects 1282 * that this file will be there and have a certain format. 1283 */ 1284 static int 1285 rpc_show_dummy_info(struct seq_file *m, void *v) 1286 { 1287 seq_printf(m, "RPC server: %s\n", utsname()->nodename); 1288 seq_printf(m, "service: foo (1) version 0\n"); 1289 seq_printf(m, "address: 127.0.0.1\n"); 1290 seq_printf(m, "protocol: tcp\n"); 1291 seq_printf(m, "port: 0\n"); 1292 return 0; 1293 } 1294 1295 static int 1296 rpc_dummy_info_open(struct inode *inode, struct file *file) 1297 { 1298 return single_open(file, rpc_show_dummy_info, NULL); 1299 } 1300 1301 static const struct file_operations rpc_dummy_info_operations = { 1302 .owner = THIS_MODULE, 1303 .open = rpc_dummy_info_open, 1304 .read = seq_read, 1305 .llseek = seq_lseek, 1306 .release = single_release, 1307 }; 1308 1309 static const struct rpc_filelist gssd_dummy_info_file[] = { 1310 [0] = { 1311 .name = "info", 1312 .i_fop = &rpc_dummy_info_operations, 1313 .mode = S_IFREG | S_IRUSR, 1314 }, 1315 }; 1316 1317 /** 1318 * rpc_gssd_dummy_populate - create a dummy gssd pipe 1319 * @root: root of the rpc_pipefs filesystem 1320 * @pipe_data: pipe data created when netns is initialized 1321 * 1322 * Create a dummy set of directories and a pipe that gssd can hold open to 1323 * indicate that it is up and running. 1324 */ 1325 static struct dentry * 1326 rpc_gssd_dummy_populate(struct dentry *root, struct rpc_pipe *pipe_data) 1327 { 1328 int ret = 0; 1329 struct dentry *gssd_dentry; 1330 struct dentry *clnt_dentry = NULL; 1331 struct dentry *pipe_dentry = NULL; 1332 struct qstr q = QSTR_INIT(files[RPCAUTH_gssd].name, 1333 strlen(files[RPCAUTH_gssd].name)); 1334 1335 /* We should never get this far if "gssd" doesn't exist */ 1336 gssd_dentry = d_hash_and_lookup(root, &q); 1337 if (!gssd_dentry) 1338 return ERR_PTR(-ENOENT); 1339 1340 ret = rpc_populate(gssd_dentry, gssd_dummy_clnt_dir, 0, 1, NULL); 1341 if (ret) { 1342 pipe_dentry = ERR_PTR(ret); 1343 goto out; 1344 } 1345 1346 q.name = gssd_dummy_clnt_dir[0].name; 1347 q.len = strlen(gssd_dummy_clnt_dir[0].name); 1348 clnt_dentry = d_hash_and_lookup(gssd_dentry, &q); 1349 if (!clnt_dentry) { 1350 pipe_dentry = ERR_PTR(-ENOENT); 1351 goto out; 1352 } 1353 1354 ret = rpc_populate(clnt_dentry, gssd_dummy_info_file, 0, 1, NULL); 1355 if (ret) { 1356 __rpc_depopulate(gssd_dentry, gssd_dummy_clnt_dir, 0, 1); 1357 pipe_dentry = ERR_PTR(ret); 1358 goto out; 1359 } 1360 1361 pipe_dentry = rpc_mkpipe_dentry(clnt_dentry, "gssd", NULL, pipe_data); 1362 if (IS_ERR(pipe_dentry)) { 1363 __rpc_depopulate(clnt_dentry, gssd_dummy_info_file, 0, 1); 1364 __rpc_depopulate(gssd_dentry, gssd_dummy_clnt_dir, 0, 1); 1365 } 1366 out: 1367 dput(clnt_dentry); 1368 dput(gssd_dentry); 1369 return pipe_dentry; 1370 } 1371 1372 static void 1373 rpc_gssd_dummy_depopulate(struct dentry *pipe_dentry) 1374 { 1375 struct dentry *clnt_dir = pipe_dentry->d_parent; 1376 struct dentry *gssd_dir = clnt_dir->d_parent; 1377 1378 __rpc_rmpipe(d_inode(clnt_dir), pipe_dentry); 1379 __rpc_depopulate(clnt_dir, gssd_dummy_info_file, 0, 1); 1380 __rpc_depopulate(gssd_dir, gssd_dummy_clnt_dir, 0, 1); 1381 dput(pipe_dentry); 1382 } 1383 1384 static int 1385 rpc_fill_super(struct super_block *sb, void *data, int silent) 1386 { 1387 struct inode *inode; 1388 struct dentry *root, *gssd_dentry; 1389 struct net *net = data; 1390 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id); 1391 int err; 1392 1393 sb->s_blocksize = PAGE_CACHE_SIZE; 1394 sb->s_blocksize_bits = PAGE_CACHE_SHIFT; 1395 sb->s_magic = RPCAUTH_GSSMAGIC; 1396 sb->s_op = &s_ops; 1397 sb->s_d_op = &simple_dentry_operations; 1398 sb->s_time_gran = 1; 1399 1400 inode = rpc_get_inode(sb, S_IFDIR | S_IRUGO | S_IXUGO); 1401 sb->s_root = root = d_make_root(inode); 1402 if (!root) 1403 return -ENOMEM; 1404 if (rpc_populate(root, files, RPCAUTH_lockd, RPCAUTH_RootEOF, NULL)) 1405 return -ENOMEM; 1406 1407 gssd_dentry = rpc_gssd_dummy_populate(root, sn->gssd_dummy); 1408 if (IS_ERR(gssd_dentry)) { 1409 __rpc_depopulate(root, files, RPCAUTH_lockd, RPCAUTH_RootEOF); 1410 return PTR_ERR(gssd_dentry); 1411 } 1412 1413 dprintk("RPC: sending pipefs MOUNT notification for net %p%s\n", 1414 net, NET_NAME(net)); 1415 mutex_lock(&sn->pipefs_sb_lock); 1416 sn->pipefs_sb = sb; 1417 err = blocking_notifier_call_chain(&rpc_pipefs_notifier_list, 1418 RPC_PIPEFS_MOUNT, 1419 sb); 1420 if (err) 1421 goto err_depopulate; 1422 sb->s_fs_info = get_net(net); 1423 mutex_unlock(&sn->pipefs_sb_lock); 1424 return 0; 1425 1426 err_depopulate: 1427 rpc_gssd_dummy_depopulate(gssd_dentry); 1428 blocking_notifier_call_chain(&rpc_pipefs_notifier_list, 1429 RPC_PIPEFS_UMOUNT, 1430 sb); 1431 sn->pipefs_sb = NULL; 1432 __rpc_depopulate(root, files, RPCAUTH_lockd, RPCAUTH_RootEOF); 1433 mutex_unlock(&sn->pipefs_sb_lock); 1434 return err; 1435 } 1436 1437 bool 1438 gssd_running(struct net *net) 1439 { 1440 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id); 1441 struct rpc_pipe *pipe = sn->gssd_dummy; 1442 1443 return pipe->nreaders || pipe->nwriters; 1444 } 1445 EXPORT_SYMBOL_GPL(gssd_running); 1446 1447 static struct dentry * 1448 rpc_mount(struct file_system_type *fs_type, 1449 int flags, const char *dev_name, void *data) 1450 { 1451 return mount_ns(fs_type, flags, current->nsproxy->net_ns, rpc_fill_super); 1452 } 1453 1454 static void rpc_kill_sb(struct super_block *sb) 1455 { 1456 struct net *net = sb->s_fs_info; 1457 struct sunrpc_net *sn = net_generic(net, sunrpc_net_id); 1458 1459 mutex_lock(&sn->pipefs_sb_lock); 1460 if (sn->pipefs_sb != sb) { 1461 mutex_unlock(&sn->pipefs_sb_lock); 1462 goto out; 1463 } 1464 sn->pipefs_sb = NULL; 1465 dprintk("RPC: sending pipefs UMOUNT notification for net %p%s\n", 1466 net, NET_NAME(net)); 1467 blocking_notifier_call_chain(&rpc_pipefs_notifier_list, 1468 RPC_PIPEFS_UMOUNT, 1469 sb); 1470 mutex_unlock(&sn->pipefs_sb_lock); 1471 put_net(net); 1472 out: 1473 kill_litter_super(sb); 1474 } 1475 1476 static struct file_system_type rpc_pipe_fs_type = { 1477 .owner = THIS_MODULE, 1478 .name = "rpc_pipefs", 1479 .mount = rpc_mount, 1480 .kill_sb = rpc_kill_sb, 1481 }; 1482 MODULE_ALIAS_FS("rpc_pipefs"); 1483 MODULE_ALIAS("rpc_pipefs"); 1484 1485 static void 1486 init_once(void *foo) 1487 { 1488 struct rpc_inode *rpci = (struct rpc_inode *) foo; 1489 1490 inode_init_once(&rpci->vfs_inode); 1491 rpci->private = NULL; 1492 rpci->pipe = NULL; 1493 init_waitqueue_head(&rpci->waitq); 1494 } 1495 1496 int register_rpc_pipefs(void) 1497 { 1498 int err; 1499 1500 rpc_inode_cachep = kmem_cache_create("rpc_inode_cache", 1501 sizeof(struct rpc_inode), 1502 0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| 1503 SLAB_MEM_SPREAD), 1504 init_once); 1505 if (!rpc_inode_cachep) 1506 return -ENOMEM; 1507 err = rpc_clients_notifier_register(); 1508 if (err) 1509 goto err_notifier; 1510 err = register_filesystem(&rpc_pipe_fs_type); 1511 if (err) 1512 goto err_register; 1513 return 0; 1514 1515 err_register: 1516 rpc_clients_notifier_unregister(); 1517 err_notifier: 1518 kmem_cache_destroy(rpc_inode_cachep); 1519 return err; 1520 } 1521 1522 void unregister_rpc_pipefs(void) 1523 { 1524 rpc_clients_notifier_unregister(); 1525 kmem_cache_destroy(rpc_inode_cachep); 1526 unregister_filesystem(&rpc_pipe_fs_type); 1527 } 1528