1/* 2 * Copyright 2008 Red Hat, Inc. All rights reserved. 3 * Copyright 2008 Ian Kent <raven@themaw.net> 4 * 5 * This file is part of the Linux kernel and is made available under 6 * the terms of the GNU General Public License, version 2, or at your 7 * option, any later version, incorporated herein by reference. 8 */ 9 10#include <linux/module.h> 11#include <linux/vmalloc.h> 12#include <linux/miscdevice.h> 13#include <linux/init.h> 14#include <linux/wait.h> 15#include <linux/namei.h> 16#include <linux/fcntl.h> 17#include <linux/file.h> 18#include <linux/fdtable.h> 19#include <linux/sched.h> 20#include <linux/compat.h> 21#include <linux/syscalls.h> 22#include <linux/magic.h> 23#include <linux/dcache.h> 24#include <linux/uaccess.h> 25#include <linux/slab.h> 26 27#include "autofs_i.h" 28 29/* 30 * This module implements an interface for routing autofs ioctl control 31 * commands via a miscellaneous device file. 32 * 33 * The alternate interface is needed because we need to be able open 34 * an ioctl file descriptor on an autofs mount that may be covered by 35 * another mount. This situation arises when starting automount(8) 36 * or other user space daemon which uses direct mounts or offset 37 * mounts (used for autofs lazy mount/umount of nested mount trees), 38 * which have been left busy at at service shutdown. 39 */ 40 41#define AUTOFS_DEV_IOCTL_SIZE sizeof(struct autofs_dev_ioctl) 42 43typedef int (*ioctl_fn)(struct file *, struct autofs_sb_info *, 44 struct autofs_dev_ioctl *); 45 46static int check_name(const char *name) 47{ 48 if (!strchr(name, '/')) 49 return -EINVAL; 50 return 0; 51} 52 53/* 54 * Check a string doesn't overrun the chunk of 55 * memory we copied from user land. 56 */ 57static int invalid_str(char *str, size_t size) 58{ 59 if (memchr(str, 0, size)) 60 return 0; 61 return -EINVAL; 62} 63 64/* 65 * Check that the user compiled against correct version of autofs 66 * misc device code. 67 * 68 * As well as checking the version compatibility this always copies 69 * the kernel interface version out. 70 */ 71static int check_dev_ioctl_version(int cmd, struct autofs_dev_ioctl *param) 72{ 73 int err = 0; 74 75 if ((AUTOFS_DEV_IOCTL_VERSION_MAJOR != param->ver_major) || 76 (AUTOFS_DEV_IOCTL_VERSION_MINOR < param->ver_minor)) { 77 AUTOFS_WARN("ioctl control interface version mismatch: " 78 "kernel(%u.%u), user(%u.%u), cmd(%d)", 79 AUTOFS_DEV_IOCTL_VERSION_MAJOR, 80 AUTOFS_DEV_IOCTL_VERSION_MINOR, 81 param->ver_major, param->ver_minor, cmd); 82 err = -EINVAL; 83 } 84 85 /* Fill in the kernel version. */ 86 param->ver_major = AUTOFS_DEV_IOCTL_VERSION_MAJOR; 87 param->ver_minor = AUTOFS_DEV_IOCTL_VERSION_MINOR; 88 89 return err; 90} 91 92/* 93 * Copy parameter control struct, including a possible path allocated 94 * at the end of the struct. 95 */ 96static struct autofs_dev_ioctl *copy_dev_ioctl(struct autofs_dev_ioctl __user *in) 97{ 98 struct autofs_dev_ioctl tmp; 99 100 if (copy_from_user(&tmp, in, sizeof(tmp))) 101 return ERR_PTR(-EFAULT); 102 103 if (tmp.size < sizeof(tmp)) 104 return ERR_PTR(-EINVAL); 105 106 return memdup_user(in, tmp.size); 107} 108 109static inline void free_dev_ioctl(struct autofs_dev_ioctl *param) 110{ 111 kfree(param); 112 return; 113} 114 115/* 116 * Check sanity of parameter control fields and if a path is present 117 * check that it is terminated and contains at least one "/". 118 */ 119static int validate_dev_ioctl(int cmd, struct autofs_dev_ioctl *param) 120{ 121 int err; 122 123 err = check_dev_ioctl_version(cmd, param); 124 if (err) { 125 AUTOFS_WARN("invalid device control module version " 126 "supplied for cmd(0x%08x)", cmd); 127 goto out; 128 } 129 130 if (param->size > sizeof(*param)) { 131 err = invalid_str(param->path, param->size - sizeof(*param)); 132 if (err) { 133 AUTOFS_WARN( 134 "path string terminator missing for cmd(0x%08x)", 135 cmd); 136 goto out; 137 } 138 139 err = check_name(param->path); 140 if (err) { 141 AUTOFS_WARN("invalid path supplied for cmd(0x%08x)", 142 cmd); 143 goto out; 144 } 145 } 146 147 err = 0; 148out: 149 return err; 150} 151 152/* 153 * Get the autofs super block info struct from the file opened on 154 * the autofs mount point. 155 */ 156static struct autofs_sb_info *autofs_dev_ioctl_sbi(struct file *f) 157{ 158 struct autofs_sb_info *sbi = NULL; 159 struct inode *inode; 160 161 if (f) { 162 inode = f->f_path.dentry->d_inode; 163 sbi = autofs4_sbi(inode->i_sb); 164 } 165 return sbi; 166} 167 168/* Return autofs module protocol version */ 169static int autofs_dev_ioctl_protover(struct file *fp, 170 struct autofs_sb_info *sbi, 171 struct autofs_dev_ioctl *param) 172{ 173 param->protover.version = sbi->version; 174 return 0; 175} 176 177/* Return autofs module protocol sub version */ 178static int autofs_dev_ioctl_protosubver(struct file *fp, 179 struct autofs_sb_info *sbi, 180 struct autofs_dev_ioctl *param) 181{ 182 param->protosubver.sub_version = sbi->sub_version; 183 return 0; 184} 185 186static int find_autofs_mount(const char *pathname, 187 struct path *res, 188 int test(struct path *path, void *data), 189 void *data) 190{ 191 struct path path; 192 int err = kern_path(pathname, 0, &path); 193 if (err) 194 return err; 195 err = -ENOENT; 196 while (path.dentry == path.mnt->mnt_root) { 197 if (path.mnt->mnt_sb->s_magic == AUTOFS_SUPER_MAGIC) { 198 if (test(&path, data)) { 199 path_get(&path); 200 if (!err) /* already found some */ 201 path_put(res); 202 *res = path; 203 err = 0; 204 } 205 } 206 if (!follow_up(&path)) 207 break; 208 } 209 path_put(&path); 210 return err; 211} 212 213static int test_by_dev(struct path *path, void *p) 214{ 215 return path->mnt->mnt_sb->s_dev == *(dev_t *)p; 216} 217 218static int test_by_type(struct path *path, void *p) 219{ 220 struct autofs_info *ino = autofs4_dentry_ino(path->dentry); 221 return ino && ino->sbi->type & *(unsigned *)p; 222} 223 224static void autofs_dev_ioctl_fd_install(unsigned int fd, struct file *file) 225{ 226 struct files_struct *files = current->files; 227 struct fdtable *fdt; 228 229 spin_lock(&files->file_lock); 230 fdt = files_fdtable(files); 231 BUG_ON(fdt->fd[fd] != NULL); 232 rcu_assign_pointer(fdt->fd[fd], file); 233 FD_SET(fd, fdt->close_on_exec); 234 spin_unlock(&files->file_lock); 235} 236 237 238/* 239 * Open a file descriptor on the autofs mount point corresponding 240 * to the given path and device number (aka. new_encode_dev(sb->s_dev)). 241 */ 242static int autofs_dev_ioctl_open_mountpoint(const char *name, dev_t devid) 243{ 244 int err, fd; 245 246 fd = get_unused_fd(); 247 if (likely(fd >= 0)) { 248 struct file *filp; 249 struct path path; 250 251 err = find_autofs_mount(name, &path, test_by_dev, &devid); 252 if (err) 253 goto out; 254 255 /* 256 * Find autofs super block that has the device number 257 * corresponding to the autofs fs we want to open. 258 */ 259 260 filp = dentry_open(path.dentry, path.mnt, O_RDONLY, 261 current_cred()); 262 if (IS_ERR(filp)) { 263 err = PTR_ERR(filp); 264 goto out; 265 } 266 267 autofs_dev_ioctl_fd_install(fd, filp); 268 } 269 270 return fd; 271 272out: 273 put_unused_fd(fd); 274 return err; 275} 276 277/* Open a file descriptor on an autofs mount point */ 278static int autofs_dev_ioctl_openmount(struct file *fp, 279 struct autofs_sb_info *sbi, 280 struct autofs_dev_ioctl *param) 281{ 282 const char *path; 283 dev_t devid; 284 int err, fd; 285 286 /* param->path has already been checked */ 287 if (!param->openmount.devid) 288 return -EINVAL; 289 290 param->ioctlfd = -1; 291 292 path = param->path; 293 devid = new_decode_dev(param->openmount.devid); 294 295 err = 0; 296 fd = autofs_dev_ioctl_open_mountpoint(path, devid); 297 if (unlikely(fd < 0)) { 298 err = fd; 299 goto out; 300 } 301 302 param->ioctlfd = fd; 303out: 304 return err; 305} 306 307/* Close file descriptor allocated above (user can also use close(2)). */ 308static int autofs_dev_ioctl_closemount(struct file *fp, 309 struct autofs_sb_info *sbi, 310 struct autofs_dev_ioctl *param) 311{ 312 return sys_close(param->ioctlfd); 313} 314 315/* 316 * Send "ready" status for an existing wait (either a mount or an expire 317 * request). 318 */ 319static int autofs_dev_ioctl_ready(struct file *fp, 320 struct autofs_sb_info *sbi, 321 struct autofs_dev_ioctl *param) 322{ 323 autofs_wqt_t token; 324 325 token = (autofs_wqt_t) param->ready.token; 326 return autofs4_wait_release(sbi, token, 0); 327} 328 329/* 330 * Send "fail" status for an existing wait (either a mount or an expire 331 * request). 332 */ 333static int autofs_dev_ioctl_fail(struct file *fp, 334 struct autofs_sb_info *sbi, 335 struct autofs_dev_ioctl *param) 336{ 337 autofs_wqt_t token; 338 int status; 339 340 token = (autofs_wqt_t) param->fail.token; 341 status = param->fail.status ? param->fail.status : -ENOENT; 342 return autofs4_wait_release(sbi, token, status); 343} 344 345/* 346 * Set the pipe fd for kernel communication to the daemon. 347 * 348 * Normally this is set at mount using an option but if we 349 * are reconnecting to a busy mount then we need to use this 350 * to tell the autofs mount about the new kernel pipe fd. In 351 * order to protect mounts against incorrectly setting the 352 * pipefd we also require that the autofs mount be catatonic. 353 * 354 * This also sets the process group id used to identify the 355 * controlling process (eg. the owning automount(8) daemon). 356 */ 357static int autofs_dev_ioctl_setpipefd(struct file *fp, 358 struct autofs_sb_info *sbi, 359 struct autofs_dev_ioctl *param) 360{ 361 int pipefd; 362 int err = 0; 363 364 if (param->setpipefd.pipefd == -1) 365 return -EINVAL; 366 367 pipefd = param->setpipefd.pipefd; 368 369 mutex_lock(&sbi->wq_mutex); 370 if (!sbi->catatonic) { 371 mutex_unlock(&sbi->wq_mutex); 372 return -EBUSY; 373 } else { 374 struct file *pipe = fget(pipefd); 375 if (!pipe->f_op || !pipe->f_op->write) { 376 err = -EPIPE; 377 fput(pipe); 378 goto out; 379 } 380 sbi->oz_pgrp = task_pgrp_nr(current); 381 sbi->pipefd = pipefd; 382 sbi->pipe = pipe; 383 sbi->catatonic = 0; 384 } 385out: 386 mutex_unlock(&sbi->wq_mutex); 387 return err; 388} 389 390/* 391 * Make the autofs mount point catatonic, no longer responsive to 392 * mount requests. Also closes the kernel pipe file descriptor. 393 */ 394static int autofs_dev_ioctl_catatonic(struct file *fp, 395 struct autofs_sb_info *sbi, 396 struct autofs_dev_ioctl *param) 397{ 398 autofs4_catatonic_mode(sbi); 399 return 0; 400} 401 402/* Set the autofs mount timeout */ 403static int autofs_dev_ioctl_timeout(struct file *fp, 404 struct autofs_sb_info *sbi, 405 struct autofs_dev_ioctl *param) 406{ 407 unsigned long timeout; 408 409 timeout = param->timeout.timeout; 410 param->timeout.timeout = sbi->exp_timeout / HZ; 411 sbi->exp_timeout = timeout * HZ; 412 return 0; 413} 414 415/* 416 * Return the uid and gid of the last request for the mount 417 * 418 * When reconstructing an autofs mount tree with active mounts 419 * we need to re-connect to mounts that may have used the original 420 * process uid and gid (or string variations of them) for mount 421 * lookups within the map entry. 422 */ 423static int autofs_dev_ioctl_requester(struct file *fp, 424 struct autofs_sb_info *sbi, 425 struct autofs_dev_ioctl *param) 426{ 427 struct autofs_info *ino; 428 struct path path; 429 dev_t devid; 430 int err = -ENOENT; 431 432 if (param->size <= sizeof(*param)) { 433 err = -EINVAL; 434 goto out; 435 } 436 437 devid = sbi->sb->s_dev; 438 439 param->requester.uid = param->requester.gid = -1; 440 441 err = find_autofs_mount(param->path, &path, test_by_dev, &devid); 442 if (err) 443 goto out; 444 445 ino = autofs4_dentry_ino(path.dentry); 446 if (ino) { 447 err = 0; 448 autofs4_expire_wait(path.dentry); 449 spin_lock(&sbi->fs_lock); 450 param->requester.uid = ino->uid; 451 param->requester.gid = ino->gid; 452 spin_unlock(&sbi->fs_lock); 453 } 454 path_put(&path); 455out: 456 return err; 457} 458 459/* 460 * Call repeatedly until it returns -EAGAIN, meaning there's nothing 461 * more that can be done. 462 */ 463static int autofs_dev_ioctl_expire(struct file *fp, 464 struct autofs_sb_info *sbi, 465 struct autofs_dev_ioctl *param) 466{ 467 struct vfsmount *mnt; 468 int how; 469 470 how = param->expire.how; 471 mnt = fp->f_path.mnt; 472 473 return autofs4_do_expire_multi(sbi->sb, mnt, sbi, how); 474} 475 476/* Check if autofs mount point is in use */ 477static int autofs_dev_ioctl_askumount(struct file *fp, 478 struct autofs_sb_info *sbi, 479 struct autofs_dev_ioctl *param) 480{ 481 param->askumount.may_umount = 0; 482 if (may_umount(fp->f_path.mnt)) 483 param->askumount.may_umount = 1; 484 return 0; 485} 486 487/* 488 * Check if the given path is a mountpoint. 489 * 490 * If we are supplied with the file descriptor of an autofs 491 * mount we're looking for a specific mount. In this case 492 * the path is considered a mountpoint if it is itself a 493 * mountpoint or contains a mount, such as a multi-mount 494 * without a root mount. In this case we return 1 if the 495 * path is a mount point and the super magic of the covering 496 * mount if there is one or 0 if it isn't a mountpoint. 497 * 498 * If we aren't supplied with a file descriptor then we 499 * lookup the nameidata of the path and check if it is the 500 * root of a mount. If a type is given we are looking for 501 * a particular autofs mount and if we don't find a match 502 * we return fail. If the located nameidata path is the 503 * root of a mount we return 1 along with the super magic 504 * of the mount or 0 otherwise. 505 * 506 * In both cases the the device number (as returned by 507 * new_encode_dev()) is also returned. 508 */ 509static int autofs_dev_ioctl_ismountpoint(struct file *fp, 510 struct autofs_sb_info *sbi, 511 struct autofs_dev_ioctl *param) 512{ 513 struct path path; 514 const char *name; 515 unsigned int type; 516 unsigned int devid, magic; 517 int err = -ENOENT; 518 519 if (param->size <= sizeof(*param)) { 520 err = -EINVAL; 521 goto out; 522 } 523 524 name = param->path; 525 type = param->ismountpoint.in.type; 526 527 param->ismountpoint.out.devid = devid = 0; 528 param->ismountpoint.out.magic = magic = 0; 529 530 if (!fp || param->ioctlfd == -1) { 531 if (autofs_type_any(type)) 532 err = kern_path(name, LOOKUP_FOLLOW, &path); 533 else 534 err = find_autofs_mount(name, &path, test_by_type, &type); 535 if (err) 536 goto out; 537 devid = new_encode_dev(path.mnt->mnt_sb->s_dev); 538 err = 0; 539 if (path.mnt->mnt_root == path.dentry) { 540 err = 1; 541 magic = path.mnt->mnt_sb->s_magic; 542 } 543 } else { 544 dev_t dev = sbi->sb->s_dev; 545 546 err = find_autofs_mount(name, &path, test_by_dev, &dev); 547 if (err) 548 goto out; 549 550 devid = new_encode_dev(dev); 551 552 err = have_submounts(path.dentry); 553 554 if (follow_down(&path)) 555 magic = path.mnt->mnt_sb->s_magic; 556 } 557 558 param->ismountpoint.out.devid = devid; 559 param->ismountpoint.out.magic = magic; 560 path_put(&path); 561out: 562 return err; 563} 564 565/* 566 * Our range of ioctl numbers isn't 0 based so we need to shift 567 * the array index by _IOC_NR(AUTOFS_CTL_IOC_FIRST) for the table 568 * lookup. 569 */ 570#define cmd_idx(cmd) (cmd - _IOC_NR(AUTOFS_DEV_IOCTL_IOC_FIRST)) 571 572static ioctl_fn lookup_dev_ioctl(unsigned int cmd) 573{ 574 static struct { 575 int cmd; 576 ioctl_fn fn; 577 } _ioctls[] = { 578 {cmd_idx(AUTOFS_DEV_IOCTL_VERSION_CMD), NULL}, 579 {cmd_idx(AUTOFS_DEV_IOCTL_PROTOVER_CMD), 580 autofs_dev_ioctl_protover}, 581 {cmd_idx(AUTOFS_DEV_IOCTL_PROTOSUBVER_CMD), 582 autofs_dev_ioctl_protosubver}, 583 {cmd_idx(AUTOFS_DEV_IOCTL_OPENMOUNT_CMD), 584 autofs_dev_ioctl_openmount}, 585 {cmd_idx(AUTOFS_DEV_IOCTL_CLOSEMOUNT_CMD), 586 autofs_dev_ioctl_closemount}, 587 {cmd_idx(AUTOFS_DEV_IOCTL_READY_CMD), 588 autofs_dev_ioctl_ready}, 589 {cmd_idx(AUTOFS_DEV_IOCTL_FAIL_CMD), 590 autofs_dev_ioctl_fail}, 591 {cmd_idx(AUTOFS_DEV_IOCTL_SETPIPEFD_CMD), 592 autofs_dev_ioctl_setpipefd}, 593 {cmd_idx(AUTOFS_DEV_IOCTL_CATATONIC_CMD), 594 autofs_dev_ioctl_catatonic}, 595 {cmd_idx(AUTOFS_DEV_IOCTL_TIMEOUT_CMD), 596 autofs_dev_ioctl_timeout}, 597 {cmd_idx(AUTOFS_DEV_IOCTL_REQUESTER_CMD), 598 autofs_dev_ioctl_requester}, 599 {cmd_idx(AUTOFS_DEV_IOCTL_EXPIRE_CMD), 600 autofs_dev_ioctl_expire}, 601 {cmd_idx(AUTOFS_DEV_IOCTL_ASKUMOUNT_CMD), 602 autofs_dev_ioctl_askumount}, 603 {cmd_idx(AUTOFS_DEV_IOCTL_ISMOUNTPOINT_CMD), 604 autofs_dev_ioctl_ismountpoint} 605 }; 606 unsigned int idx = cmd_idx(cmd); 607 608 return (idx >= ARRAY_SIZE(_ioctls)) ? NULL : _ioctls[idx].fn; 609} 610 611/* ioctl dispatcher */ 612static int _autofs_dev_ioctl(unsigned int command, struct autofs_dev_ioctl __user *user) 613{ 614 struct autofs_dev_ioctl *param; 615 struct file *fp; 616 struct autofs_sb_info *sbi; 617 unsigned int cmd_first, cmd; 618 ioctl_fn fn = NULL; 619 int err = 0; 620 621 /* only root can play with this */ 622 if (!capable(CAP_SYS_ADMIN)) 623 return -EPERM; 624 625 cmd_first = _IOC_NR(AUTOFS_DEV_IOCTL_IOC_FIRST); 626 cmd = _IOC_NR(command); 627 628 if (_IOC_TYPE(command) != _IOC_TYPE(AUTOFS_DEV_IOCTL_IOC_FIRST) || 629 cmd - cmd_first >= AUTOFS_DEV_IOCTL_IOC_COUNT) { 630 return -ENOTTY; 631 } 632 633 /* Copy the parameters into kernel space. */ 634 param = copy_dev_ioctl(user); 635 if (IS_ERR(param)) 636 return PTR_ERR(param); 637 638 err = validate_dev_ioctl(command, param); 639 if (err) 640 goto out; 641 642 /* The validate routine above always sets the version */ 643 if (cmd == AUTOFS_DEV_IOCTL_VERSION_CMD) 644 goto done; 645 646 fn = lookup_dev_ioctl(cmd); 647 if (!fn) { 648 AUTOFS_WARN("unknown command 0x%08x", command); 649 return -ENOTTY; 650 } 651 652 fp = NULL; 653 sbi = NULL; 654 655 /* 656 * For obvious reasons the openmount can't have a file 657 * descriptor yet. We don't take a reference to the 658 * file during close to allow for immediate release. 659 */ 660 if (cmd != AUTOFS_DEV_IOCTL_OPENMOUNT_CMD && 661 cmd != AUTOFS_DEV_IOCTL_CLOSEMOUNT_CMD) { 662 fp = fget(param->ioctlfd); 663 if (!fp) { 664 if (cmd == AUTOFS_DEV_IOCTL_ISMOUNTPOINT_CMD) 665 goto cont; 666 err = -EBADF; 667 goto out; 668 } 669 670 if (!fp->f_op) { 671 err = -ENOTTY; 672 fput(fp); 673 goto out; 674 } 675 676 sbi = autofs_dev_ioctl_sbi(fp); 677 if (!sbi || sbi->magic != AUTOFS_SBI_MAGIC) { 678 err = -EINVAL; 679 fput(fp); 680 goto out; 681 } 682 683 /* 684 * Admin needs to be able to set the mount catatonic in 685 * order to be able to perform the re-open. 686 */ 687 if (!autofs4_oz_mode(sbi) && 688 cmd != AUTOFS_DEV_IOCTL_CATATONIC_CMD) { 689 err = -EACCES; 690 fput(fp); 691 goto out; 692 } 693 } 694cont: 695 err = fn(fp, sbi, param); 696 697 if (fp) 698 fput(fp); 699done: 700 if (err >= 0 && copy_to_user(user, param, AUTOFS_DEV_IOCTL_SIZE)) 701 err = -EFAULT; 702out: 703 free_dev_ioctl(param); 704 return err; 705} 706 707static long autofs_dev_ioctl(struct file *file, uint command, ulong u) 708{ 709 int err; 710 err = _autofs_dev_ioctl(command, (struct autofs_dev_ioctl __user *) u); 711 return (long) err; 712} 713 714#ifdef CONFIG_COMPAT 715static long autofs_dev_ioctl_compat(struct file *file, uint command, ulong u) 716{ 717 return (long) autofs_dev_ioctl(file, command, (ulong) compat_ptr(u)); 718} 719#else 720#define autofs_dev_ioctl_compat NULL 721#endif 722 723static const struct file_operations _dev_ioctl_fops = { 724 .unlocked_ioctl = autofs_dev_ioctl, 725 .compat_ioctl = autofs_dev_ioctl_compat, 726 .owner = THIS_MODULE, 727}; 728 729static struct miscdevice _autofs_dev_ioctl_misc = { 730 .minor = AUTOFS_MINOR, 731 .name = AUTOFS_DEVICE_NAME, 732 .fops = &_dev_ioctl_fops 733}; 734 735MODULE_ALIAS_MISCDEV(AUTOFS_MINOR); 736MODULE_ALIAS("devname:autofs"); 737 738/* Register/deregister misc character device */ 739int autofs_dev_ioctl_init(void) 740{ 741 int r; 742 743 r = misc_register(&_autofs_dev_ioctl_misc); 744 if (r) { 745 AUTOFS_ERROR("misc_register failed for control device"); 746 return r; 747 } 748 749 return 0; 750} 751 752void autofs_dev_ioctl_exit(void) 753{ 754 misc_deregister(&_autofs_dev_ioctl_misc); 755 return; 756} 757