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