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