1/* -*- c -*- --------------------------------------------------------------- * 2 * 3 * linux/fs/autofs/root.c 4 * 5 * Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved 6 * Copyright 1999-2000 Jeremy Fitzhardinge <jeremy@goop.org> 7 * Copyright 2001-2006 Ian Kent <raven@themaw.net> 8 * 9 * This file is part of the Linux kernel and is made available under 10 * the terms of the GNU General Public License, version 2, or at your 11 * option, any later version, incorporated herein by reference. 12 * 13 * ------------------------------------------------------------------------- */ 14 15#include <linux/capability.h> 16#include <linux/errno.h> 17#include <linux/stat.h> 18#include <linux/slab.h> 19#include <linux/param.h> 20#include <linux/time.h> 21#include <linux/compat.h> 22#include <linux/mutex.h> 23 24#include "autofs_i.h" 25 26static int autofs4_dir_symlink(struct inode *,struct dentry *,const char *); 27static int autofs4_dir_unlink(struct inode *,struct dentry *); 28static int autofs4_dir_rmdir(struct inode *,struct dentry *); 29static int autofs4_dir_mkdir(struct inode *,struct dentry *,umode_t); 30static long autofs4_root_ioctl(struct file *,unsigned int,unsigned long); 31#ifdef CONFIG_COMPAT 32static long autofs4_root_compat_ioctl(struct file *,unsigned int,unsigned long); 33#endif 34static int autofs4_dir_open(struct inode *inode, struct file *file); 35static struct dentry *autofs4_lookup(struct inode *,struct dentry *, unsigned int); 36static struct vfsmount *autofs4_d_automount(struct path *); 37static int autofs4_d_manage(struct dentry *, bool); 38static void autofs4_dentry_release(struct dentry *); 39 40const struct file_operations autofs4_root_operations = { 41 .open = dcache_dir_open, 42 .release = dcache_dir_close, 43 .read = generic_read_dir, 44 .iterate = dcache_readdir, 45 .llseek = dcache_dir_lseek, 46 .unlocked_ioctl = autofs4_root_ioctl, 47#ifdef CONFIG_COMPAT 48 .compat_ioctl = autofs4_root_compat_ioctl, 49#endif 50}; 51 52const struct file_operations autofs4_dir_operations = { 53 .open = autofs4_dir_open, 54 .release = dcache_dir_close, 55 .read = generic_read_dir, 56 .iterate = dcache_readdir, 57 .llseek = dcache_dir_lseek, 58}; 59 60const struct inode_operations autofs4_dir_inode_operations = { 61 .lookup = autofs4_lookup, 62 .unlink = autofs4_dir_unlink, 63 .symlink = autofs4_dir_symlink, 64 .mkdir = autofs4_dir_mkdir, 65 .rmdir = autofs4_dir_rmdir, 66}; 67 68const struct dentry_operations autofs4_dentry_operations = { 69 .d_automount = autofs4_d_automount, 70 .d_manage = autofs4_d_manage, 71 .d_release = autofs4_dentry_release, 72}; 73 74static void autofs4_add_active(struct dentry *dentry) 75{ 76 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); 77 struct autofs_info *ino = autofs4_dentry_ino(dentry); 78 if (ino) { 79 spin_lock(&sbi->lookup_lock); 80 if (!ino->active_count) { 81 if (list_empty(&ino->active)) 82 list_add(&ino->active, &sbi->active_list); 83 } 84 ino->active_count++; 85 spin_unlock(&sbi->lookup_lock); 86 } 87 return; 88} 89 90static void autofs4_del_active(struct dentry *dentry) 91{ 92 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); 93 struct autofs_info *ino = autofs4_dentry_ino(dentry); 94 if (ino) { 95 spin_lock(&sbi->lookup_lock); 96 ino->active_count--; 97 if (!ino->active_count) { 98 if (!list_empty(&ino->active)) 99 list_del_init(&ino->active); 100 } 101 spin_unlock(&sbi->lookup_lock); 102 } 103 return; 104} 105 106static int autofs4_dir_open(struct inode *inode, struct file *file) 107{ 108 struct dentry *dentry = file->f_path.dentry; 109 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); 110 111 DPRINTK("file=%p dentry=%p %pd", file, dentry, dentry); 112 113 if (autofs4_oz_mode(sbi)) 114 goto out; 115 116 /* 117 * An empty directory in an autofs file system is always a 118 * mount point. The daemon must have failed to mount this 119 * during lookup so it doesn't exist. This can happen, for 120 * example, if user space returns an incorrect status for a 121 * mount request. Otherwise we're doing a readdir on the 122 * autofs file system so just let the libfs routines handle 123 * it. 124 */ 125 spin_lock(&sbi->lookup_lock); 126 if (!d_mountpoint(dentry) && simple_empty(dentry)) { 127 spin_unlock(&sbi->lookup_lock); 128 return -ENOENT; 129 } 130 spin_unlock(&sbi->lookup_lock); 131 132out: 133 return dcache_dir_open(inode, file); 134} 135 136static void autofs4_dentry_release(struct dentry *de) 137{ 138 struct autofs_info *ino = autofs4_dentry_ino(de); 139 struct autofs_sb_info *sbi = autofs4_sbi(de->d_sb); 140 141 DPRINTK("releasing %p", de); 142 143 if (!ino) 144 return; 145 146 if (sbi) { 147 spin_lock(&sbi->lookup_lock); 148 if (!list_empty(&ino->active)) 149 list_del(&ino->active); 150 if (!list_empty(&ino->expiring)) 151 list_del(&ino->expiring); 152 spin_unlock(&sbi->lookup_lock); 153 } 154 155 autofs4_free_ino(ino); 156} 157 158static struct dentry *autofs4_lookup_active(struct dentry *dentry) 159{ 160 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); 161 struct dentry *parent = dentry->d_parent; 162 struct qstr *name = &dentry->d_name; 163 unsigned int len = name->len; 164 unsigned int hash = name->hash; 165 const unsigned char *str = name->name; 166 struct list_head *p, *head; 167 168 head = &sbi->active_list; 169 if (list_empty(head)) 170 return NULL; 171 spin_lock(&sbi->lookup_lock); 172 list_for_each(p, head) { 173 struct autofs_info *ino; 174 struct dentry *active; 175 struct qstr *qstr; 176 177 ino = list_entry(p, struct autofs_info, active); 178 active = ino->dentry; 179 180 spin_lock(&active->d_lock); 181 182 /* Already gone? */ 183 if ((int) d_count(active) <= 0) 184 goto next; 185 186 qstr = &active->d_name; 187 188 if (active->d_name.hash != hash) 189 goto next; 190 if (active->d_parent != parent) 191 goto next; 192 193 if (qstr->len != len) 194 goto next; 195 if (memcmp(qstr->name, str, len)) 196 goto next; 197 198 if (d_unhashed(active)) { 199 dget_dlock(active); 200 spin_unlock(&active->d_lock); 201 spin_unlock(&sbi->lookup_lock); 202 return active; 203 } 204next: 205 spin_unlock(&active->d_lock); 206 } 207 spin_unlock(&sbi->lookup_lock); 208 209 return NULL; 210} 211 212static struct dentry *autofs4_lookup_expiring(struct dentry *dentry, 213 bool rcu_walk) 214{ 215 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); 216 struct dentry *parent = dentry->d_parent; 217 struct qstr *name = &dentry->d_name; 218 unsigned int len = name->len; 219 unsigned int hash = name->hash; 220 const unsigned char *str = name->name; 221 struct list_head *p, *head; 222 223 head = &sbi->expiring_list; 224 if (list_empty(head)) 225 return NULL; 226 spin_lock(&sbi->lookup_lock); 227 list_for_each(p, head) { 228 struct autofs_info *ino; 229 struct dentry *expiring; 230 struct qstr *qstr; 231 232 if (rcu_walk) { 233 spin_unlock(&sbi->lookup_lock); 234 return ERR_PTR(-ECHILD); 235 } 236 237 ino = list_entry(p, struct autofs_info, expiring); 238 expiring = ino->dentry; 239 240 spin_lock(&expiring->d_lock); 241 242 /* We've already been dentry_iput or unlinked */ 243 if (d_really_is_negative(expiring)) 244 goto next; 245 246 qstr = &expiring->d_name; 247 248 if (expiring->d_name.hash != hash) 249 goto next; 250 if (expiring->d_parent != parent) 251 goto next; 252 253 if (qstr->len != len) 254 goto next; 255 if (memcmp(qstr->name, str, len)) 256 goto next; 257 258 if (d_unhashed(expiring)) { 259 dget_dlock(expiring); 260 spin_unlock(&expiring->d_lock); 261 spin_unlock(&sbi->lookup_lock); 262 return expiring; 263 } 264next: 265 spin_unlock(&expiring->d_lock); 266 } 267 spin_unlock(&sbi->lookup_lock); 268 269 return NULL; 270} 271 272static int autofs4_mount_wait(struct dentry *dentry, bool rcu_walk) 273{ 274 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); 275 struct autofs_info *ino = autofs4_dentry_ino(dentry); 276 int status = 0; 277 278 if (ino->flags & AUTOFS_INF_PENDING) { 279 if (rcu_walk) 280 return -ECHILD; 281 DPRINTK("waiting for mount name=%pd", dentry); 282 status = autofs4_wait(sbi, dentry, NFY_MOUNT); 283 DPRINTK("mount wait done status=%d", status); 284 } 285 ino->last_used = jiffies; 286 return status; 287} 288 289static int do_expire_wait(struct dentry *dentry, bool rcu_walk) 290{ 291 struct dentry *expiring; 292 293 expiring = autofs4_lookup_expiring(dentry, rcu_walk); 294 if (IS_ERR(expiring)) 295 return PTR_ERR(expiring); 296 if (!expiring) 297 return autofs4_expire_wait(dentry, rcu_walk); 298 else { 299 /* 300 * If we are racing with expire the request might not 301 * be quite complete, but the directory has been removed 302 * so it must have been successful, just wait for it. 303 */ 304 autofs4_expire_wait(expiring, 0); 305 autofs4_del_expiring(expiring); 306 dput(expiring); 307 } 308 return 0; 309} 310 311static struct dentry *autofs4_mountpoint_changed(struct path *path) 312{ 313 struct dentry *dentry = path->dentry; 314 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); 315 316 /* 317 * If this is an indirect mount the dentry could have gone away 318 * as a result of an expire and a new one created. 319 */ 320 if (autofs_type_indirect(sbi->type) && d_unhashed(dentry)) { 321 struct dentry *parent = dentry->d_parent; 322 struct autofs_info *ino; 323 struct dentry *new = d_lookup(parent, &dentry->d_name); 324 if (!new) 325 return NULL; 326 ino = autofs4_dentry_ino(new); 327 ino->last_used = jiffies; 328 dput(path->dentry); 329 path->dentry = new; 330 } 331 return path->dentry; 332} 333 334static struct vfsmount *autofs4_d_automount(struct path *path) 335{ 336 struct dentry *dentry = path->dentry; 337 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); 338 struct autofs_info *ino = autofs4_dentry_ino(dentry); 339 int status; 340 341 DPRINTK("dentry=%p %pd", dentry, dentry); 342 343 /* The daemon never triggers a mount. */ 344 if (autofs4_oz_mode(sbi)) 345 return NULL; 346 347 /* 348 * If an expire request is pending everyone must wait. 349 * If the expire fails we're still mounted so continue 350 * the follow and return. A return of -EAGAIN (which only 351 * happens with indirect mounts) means the expire completed 352 * and the directory was removed, so just go ahead and try 353 * the mount. 354 */ 355 status = do_expire_wait(dentry, 0); 356 if (status && status != -EAGAIN) 357 return NULL; 358 359 /* Callback to the daemon to perform the mount or wait */ 360 spin_lock(&sbi->fs_lock); 361 if (ino->flags & AUTOFS_INF_PENDING) { 362 spin_unlock(&sbi->fs_lock); 363 status = autofs4_mount_wait(dentry, 0); 364 if (status) 365 return ERR_PTR(status); 366 goto done; 367 } 368 369 /* 370 * If the dentry is a symlink it's equivalent to a directory 371 * having d_mountpoint() true, so there's no need to call back 372 * to the daemon. 373 */ 374 if (d_really_is_positive(dentry) && d_is_symlink(dentry)) { 375 spin_unlock(&sbi->fs_lock); 376 goto done; 377 } 378 379 if (!d_mountpoint(dentry)) { 380 /* 381 * It's possible that user space hasn't removed directories 382 * after umounting a rootless multi-mount, although it 383 * should. For v5 have_submounts() is sufficient to handle 384 * this because the leaves of the directory tree under the 385 * mount never trigger mounts themselves (they have an autofs 386 * trigger mount mounted on them). But v4 pseudo direct mounts 387 * do need the leaves to trigger mounts. In this case we 388 * have no choice but to use the list_empty() check and 389 * require user space behave. 390 */ 391 if (sbi->version > 4) { 392 if (have_submounts(dentry)) { 393 spin_unlock(&sbi->fs_lock); 394 goto done; 395 } 396 } else { 397 if (!simple_empty(dentry)) { 398 spin_unlock(&sbi->fs_lock); 399 goto done; 400 } 401 } 402 ino->flags |= AUTOFS_INF_PENDING; 403 spin_unlock(&sbi->fs_lock); 404 status = autofs4_mount_wait(dentry, 0); 405 spin_lock(&sbi->fs_lock); 406 ino->flags &= ~AUTOFS_INF_PENDING; 407 if (status) { 408 spin_unlock(&sbi->fs_lock); 409 return ERR_PTR(status); 410 } 411 } 412 spin_unlock(&sbi->fs_lock); 413done: 414 /* Mount succeeded, check if we ended up with a new dentry */ 415 dentry = autofs4_mountpoint_changed(path); 416 if (!dentry) 417 return ERR_PTR(-ENOENT); 418 419 return NULL; 420} 421 422static int autofs4_d_manage(struct dentry *dentry, bool rcu_walk) 423{ 424 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); 425 struct autofs_info *ino = autofs4_dentry_ino(dentry); 426 int status; 427 428 DPRINTK("dentry=%p %pd", dentry, dentry); 429 430 /* The daemon never waits. */ 431 if (autofs4_oz_mode(sbi)) { 432 if (!d_mountpoint(dentry)) 433 return -EISDIR; 434 return 0; 435 } 436 437 /* Wait for pending expires */ 438 if (do_expire_wait(dentry, rcu_walk) == -ECHILD) 439 return -ECHILD; 440 441 /* 442 * This dentry may be under construction so wait on mount 443 * completion. 444 */ 445 status = autofs4_mount_wait(dentry, rcu_walk); 446 if (status) 447 return status; 448 449 if (rcu_walk) { 450 /* We don't need fs_lock in rcu_walk mode, 451 * just testing 'AUTOFS_INFO_NO_RCU' is enough. 452 * simple_empty() takes a spinlock, so leave it 453 * to last. 454 * We only return -EISDIR when certain this isn't 455 * a mount-trap. 456 */ 457 struct inode *inode; 458 if (ino->flags & (AUTOFS_INF_EXPIRING | AUTOFS_INF_NO_RCU)) 459 return 0; 460 if (d_mountpoint(dentry)) 461 return 0; 462 inode = d_inode_rcu(dentry); 463 if (inode && S_ISLNK(inode->i_mode)) 464 return -EISDIR; 465 if (list_empty(&dentry->d_subdirs)) 466 return 0; 467 if (!simple_empty(dentry)) 468 return -EISDIR; 469 return 0; 470 } 471 472 spin_lock(&sbi->fs_lock); 473 /* 474 * If the dentry has been selected for expire while we slept 475 * on the lock then it might go away. We'll deal with that in 476 * ->d_automount() and wait on a new mount if the expire 477 * succeeds or return here if it doesn't (since there's no 478 * mount to follow with a rootless multi-mount). 479 */ 480 if (!(ino->flags & AUTOFS_INF_EXPIRING)) { 481 /* 482 * Any needed mounting has been completed and the path 483 * updated so check if this is a rootless multi-mount so 484 * we can avoid needless calls ->d_automount() and avoid 485 * an incorrect ELOOP error return. 486 */ 487 if ((!d_mountpoint(dentry) && !simple_empty(dentry)) || 488 (d_really_is_positive(dentry) && d_is_symlink(dentry))) 489 status = -EISDIR; 490 } 491 spin_unlock(&sbi->fs_lock); 492 493 return status; 494} 495 496/* Lookups in the root directory */ 497static struct dentry *autofs4_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags) 498{ 499 struct autofs_sb_info *sbi; 500 struct autofs_info *ino; 501 struct dentry *active; 502 503 DPRINTK("name = %pd", dentry); 504 505 /* File name too long to exist */ 506 if (dentry->d_name.len > NAME_MAX) 507 return ERR_PTR(-ENAMETOOLONG); 508 509 sbi = autofs4_sbi(dir->i_sb); 510 511 DPRINTK("pid = %u, pgrp = %u, catatonic = %d, oz_mode = %d", 512 current->pid, task_pgrp_nr(current), sbi->catatonic, 513 autofs4_oz_mode(sbi)); 514 515 active = autofs4_lookup_active(dentry); 516 if (active) { 517 return active; 518 } else { 519 /* 520 * A dentry that is not within the root can never trigger a 521 * mount operation, unless the directory already exists, so we 522 * can return fail immediately. The daemon however does need 523 * to create directories within the file system. 524 */ 525 if (!autofs4_oz_mode(sbi) && !IS_ROOT(dentry->d_parent)) 526 return ERR_PTR(-ENOENT); 527 528 /* Mark entries in the root as mount triggers */ 529 if (autofs_type_indirect(sbi->type) && IS_ROOT(dentry->d_parent)) 530 __managed_dentry_set_managed(dentry); 531 532 ino = autofs4_new_ino(sbi); 533 if (!ino) 534 return ERR_PTR(-ENOMEM); 535 536 dentry->d_fsdata = ino; 537 ino->dentry = dentry; 538 539 autofs4_add_active(dentry); 540 541 d_instantiate(dentry, NULL); 542 } 543 return NULL; 544} 545 546static int autofs4_dir_symlink(struct inode *dir, 547 struct dentry *dentry, 548 const char *symname) 549{ 550 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb); 551 struct autofs_info *ino = autofs4_dentry_ino(dentry); 552 struct autofs_info *p_ino; 553 struct inode *inode; 554 size_t size = strlen(symname); 555 char *cp; 556 557 DPRINTK("%s <- %pd", symname, dentry); 558 559 if (!autofs4_oz_mode(sbi)) 560 return -EACCES; 561 562 BUG_ON(!ino); 563 564 autofs4_clean_ino(ino); 565 566 autofs4_del_active(dentry); 567 568 cp = kmalloc(size + 1, GFP_KERNEL); 569 if (!cp) 570 return -ENOMEM; 571 572 strcpy(cp, symname); 573 574 inode = autofs4_get_inode(dir->i_sb, S_IFLNK | 0555); 575 if (!inode) { 576 kfree(cp); 577 if (!dentry->d_fsdata) 578 kfree(ino); 579 return -ENOMEM; 580 } 581 inode->i_private = cp; 582 inode->i_size = size; 583 d_add(dentry, inode); 584 585 dget(dentry); 586 atomic_inc(&ino->count); 587 p_ino = autofs4_dentry_ino(dentry->d_parent); 588 if (p_ino && !IS_ROOT(dentry)) 589 atomic_inc(&p_ino->count); 590 591 dir->i_mtime = CURRENT_TIME; 592 593 return 0; 594} 595 596/* 597 * NOTE! 598 * 599 * Normal filesystems would do a "d_delete()" to tell the VFS dcache 600 * that the file no longer exists. However, doing that means that the 601 * VFS layer can turn the dentry into a negative dentry. We don't want 602 * this, because the unlink is probably the result of an expire. 603 * We simply d_drop it and add it to a expiring list in the super block, 604 * which allows the dentry lookup to check for an incomplete expire. 605 * 606 * If a process is blocked on the dentry waiting for the expire to finish, 607 * it will invalidate the dentry and try to mount with a new one. 608 * 609 * Also see autofs4_dir_rmdir().. 610 */ 611static int autofs4_dir_unlink(struct inode *dir, struct dentry *dentry) 612{ 613 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb); 614 struct autofs_info *ino = autofs4_dentry_ino(dentry); 615 struct autofs_info *p_ino; 616 617 /* This allows root to remove symlinks */ 618 if (!autofs4_oz_mode(sbi) && !capable(CAP_SYS_ADMIN)) 619 return -EPERM; 620 621 if (atomic_dec_and_test(&ino->count)) { 622 p_ino = autofs4_dentry_ino(dentry->d_parent); 623 if (p_ino && !IS_ROOT(dentry)) 624 atomic_dec(&p_ino->count); 625 } 626 dput(ino->dentry); 627 628 d_inode(dentry)->i_size = 0; 629 clear_nlink(d_inode(dentry)); 630 631 dir->i_mtime = CURRENT_TIME; 632 633 spin_lock(&sbi->lookup_lock); 634 __autofs4_add_expiring(dentry); 635 d_drop(dentry); 636 spin_unlock(&sbi->lookup_lock); 637 638 return 0; 639} 640 641/* 642 * Version 4 of autofs provides a pseudo direct mount implementation 643 * that relies on directories at the leaves of a directory tree under 644 * an indirect mount to trigger mounts. To allow for this we need to 645 * set the DMANAGED_AUTOMOUNT and DMANAGED_TRANSIT flags on the leaves 646 * of the directory tree. There is no need to clear the automount flag 647 * following a mount or restore it after an expire because these mounts 648 * are always covered. However, it is necessary to ensure that these 649 * flags are clear on non-empty directories to avoid unnecessary calls 650 * during path walks. 651 */ 652static void autofs_set_leaf_automount_flags(struct dentry *dentry) 653{ 654 struct dentry *parent; 655 656 /* root and dentrys in the root are already handled */ 657 if (IS_ROOT(dentry->d_parent)) 658 return; 659 660 managed_dentry_set_managed(dentry); 661 662 parent = dentry->d_parent; 663 /* only consider parents below dentrys in the root */ 664 if (IS_ROOT(parent->d_parent)) 665 return; 666 managed_dentry_clear_managed(parent); 667 return; 668} 669 670static void autofs_clear_leaf_automount_flags(struct dentry *dentry) 671{ 672 struct list_head *d_child; 673 struct dentry *parent; 674 675 /* flags for dentrys in the root are handled elsewhere */ 676 if (IS_ROOT(dentry->d_parent)) 677 return; 678 679 managed_dentry_clear_managed(dentry); 680 681 parent = dentry->d_parent; 682 /* only consider parents below dentrys in the root */ 683 if (IS_ROOT(parent->d_parent)) 684 return; 685 d_child = &dentry->d_child; 686 /* Set parent managed if it's becoming empty */ 687 if (d_child->next == &parent->d_subdirs && 688 d_child->prev == &parent->d_subdirs) 689 managed_dentry_set_managed(parent); 690 return; 691} 692 693static int autofs4_dir_rmdir(struct inode *dir, struct dentry *dentry) 694{ 695 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb); 696 struct autofs_info *ino = autofs4_dentry_ino(dentry); 697 struct autofs_info *p_ino; 698 699 DPRINTK("dentry %p, removing %pd", dentry, dentry); 700 701 if (!autofs4_oz_mode(sbi)) 702 return -EACCES; 703 704 spin_lock(&sbi->lookup_lock); 705 if (!simple_empty(dentry)) { 706 spin_unlock(&sbi->lookup_lock); 707 return -ENOTEMPTY; 708 } 709 __autofs4_add_expiring(dentry); 710 d_drop(dentry); 711 spin_unlock(&sbi->lookup_lock); 712 713 if (sbi->version < 5) 714 autofs_clear_leaf_automount_flags(dentry); 715 716 if (atomic_dec_and_test(&ino->count)) { 717 p_ino = autofs4_dentry_ino(dentry->d_parent); 718 if (p_ino && dentry->d_parent != dentry) 719 atomic_dec(&p_ino->count); 720 } 721 dput(ino->dentry); 722 d_inode(dentry)->i_size = 0; 723 clear_nlink(d_inode(dentry)); 724 725 if (dir->i_nlink) 726 drop_nlink(dir); 727 728 return 0; 729} 730 731static int autofs4_dir_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) 732{ 733 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb); 734 struct autofs_info *ino = autofs4_dentry_ino(dentry); 735 struct autofs_info *p_ino; 736 struct inode *inode; 737 738 if (!autofs4_oz_mode(sbi)) 739 return -EACCES; 740 741 DPRINTK("dentry %p, creating %pd", dentry, dentry); 742 743 BUG_ON(!ino); 744 745 autofs4_clean_ino(ino); 746 747 autofs4_del_active(dentry); 748 749 inode = autofs4_get_inode(dir->i_sb, S_IFDIR | 0555); 750 if (!inode) 751 return -ENOMEM; 752 d_add(dentry, inode); 753 754 if (sbi->version < 5) 755 autofs_set_leaf_automount_flags(dentry); 756 757 dget(dentry); 758 atomic_inc(&ino->count); 759 p_ino = autofs4_dentry_ino(dentry->d_parent); 760 if (p_ino && !IS_ROOT(dentry)) 761 atomic_inc(&p_ino->count); 762 inc_nlink(dir); 763 dir->i_mtime = CURRENT_TIME; 764 765 return 0; 766} 767 768/* Get/set timeout ioctl() operation */ 769#ifdef CONFIG_COMPAT 770static inline int autofs4_compat_get_set_timeout(struct autofs_sb_info *sbi, 771 compat_ulong_t __user *p) 772{ 773 int rv; 774 unsigned long ntimeout; 775 776 if ((rv = get_user(ntimeout, p)) || 777 (rv = put_user(sbi->exp_timeout/HZ, p))) 778 return rv; 779 780 if (ntimeout > UINT_MAX/HZ) 781 sbi->exp_timeout = 0; 782 else 783 sbi->exp_timeout = ntimeout * HZ; 784 785 return 0; 786} 787#endif 788 789static inline int autofs4_get_set_timeout(struct autofs_sb_info *sbi, 790 unsigned long __user *p) 791{ 792 int rv; 793 unsigned long ntimeout; 794 795 if ((rv = get_user(ntimeout, p)) || 796 (rv = put_user(sbi->exp_timeout/HZ, p))) 797 return rv; 798 799 if (ntimeout > ULONG_MAX/HZ) 800 sbi->exp_timeout = 0; 801 else 802 sbi->exp_timeout = ntimeout * HZ; 803 804 return 0; 805} 806 807/* Return protocol version */ 808static inline int autofs4_get_protover(struct autofs_sb_info *sbi, int __user *p) 809{ 810 return put_user(sbi->version, p); 811} 812 813/* Return protocol sub version */ 814static inline int autofs4_get_protosubver(struct autofs_sb_info *sbi, int __user *p) 815{ 816 return put_user(sbi->sub_version, p); 817} 818 819/* 820* Tells the daemon whether it can umount the autofs mount. 821*/ 822static inline int autofs4_ask_umount(struct vfsmount *mnt, int __user *p) 823{ 824 int status = 0; 825 826 if (may_umount(mnt)) 827 status = 1; 828 829 DPRINTK("returning %d", status); 830 831 status = put_user(status, p); 832 833 return status; 834} 835 836/* Identify autofs4_dentries - this is so we can tell if there's 837 an extra dentry refcount or not. We only hold a refcount on the 838 dentry if its non-negative (ie, d_inode != NULL) 839*/ 840int is_autofs4_dentry(struct dentry *dentry) 841{ 842 return dentry && d_really_is_positive(dentry) && 843 dentry->d_op == &autofs4_dentry_operations && 844 dentry->d_fsdata != NULL; 845} 846 847/* 848 * ioctl()'s on the root directory is the chief method for the daemon to 849 * generate kernel reactions 850 */ 851static int autofs4_root_ioctl_unlocked(struct inode *inode, struct file *filp, 852 unsigned int cmd, unsigned long arg) 853{ 854 struct autofs_sb_info *sbi = autofs4_sbi(inode->i_sb); 855 void __user *p = (void __user *)arg; 856 857 DPRINTK("cmd = 0x%08x, arg = 0x%08lx, sbi = %p, pgrp = %u", 858 cmd,arg,sbi,task_pgrp_nr(current)); 859 860 if (_IOC_TYPE(cmd) != _IOC_TYPE(AUTOFS_IOC_FIRST) || 861 _IOC_NR(cmd) - _IOC_NR(AUTOFS_IOC_FIRST) >= AUTOFS_IOC_COUNT) 862 return -ENOTTY; 863 864 if (!autofs4_oz_mode(sbi) && !capable(CAP_SYS_ADMIN)) 865 return -EPERM; 866 867 switch(cmd) { 868 case AUTOFS_IOC_READY: /* Wait queue: go ahead and retry */ 869 return autofs4_wait_release(sbi,(autofs_wqt_t)arg,0); 870 case AUTOFS_IOC_FAIL: /* Wait queue: fail with ENOENT */ 871 return autofs4_wait_release(sbi,(autofs_wqt_t)arg,-ENOENT); 872 case AUTOFS_IOC_CATATONIC: /* Enter catatonic mode (daemon shutdown) */ 873 autofs4_catatonic_mode(sbi); 874 return 0; 875 case AUTOFS_IOC_PROTOVER: /* Get protocol version */ 876 return autofs4_get_protover(sbi, p); 877 case AUTOFS_IOC_PROTOSUBVER: /* Get protocol sub version */ 878 return autofs4_get_protosubver(sbi, p); 879 case AUTOFS_IOC_SETTIMEOUT: 880 return autofs4_get_set_timeout(sbi, p); 881#ifdef CONFIG_COMPAT 882 case AUTOFS_IOC_SETTIMEOUT32: 883 return autofs4_compat_get_set_timeout(sbi, p); 884#endif 885 886 case AUTOFS_IOC_ASKUMOUNT: 887 return autofs4_ask_umount(filp->f_path.mnt, p); 888 889 /* return a single thing to expire */ 890 case AUTOFS_IOC_EXPIRE: 891 return autofs4_expire_run(inode->i_sb,filp->f_path.mnt,sbi, p); 892 /* same as above, but can send multiple expires through pipe */ 893 case AUTOFS_IOC_EXPIRE_MULTI: 894 return autofs4_expire_multi(inode->i_sb,filp->f_path.mnt,sbi, p); 895 896 default: 897 return -ENOSYS; 898 } 899} 900 901static long autofs4_root_ioctl(struct file *filp, 902 unsigned int cmd, unsigned long arg) 903{ 904 struct inode *inode = file_inode(filp); 905 return autofs4_root_ioctl_unlocked(inode, filp, cmd, arg); 906} 907 908#ifdef CONFIG_COMPAT 909static long autofs4_root_compat_ioctl(struct file *filp, 910 unsigned int cmd, unsigned long arg) 911{ 912 struct inode *inode = file_inode(filp); 913 int ret; 914 915 if (cmd == AUTOFS_IOC_READY || cmd == AUTOFS_IOC_FAIL) 916 ret = autofs4_root_ioctl_unlocked(inode, filp, cmd, arg); 917 else 918 ret = autofs4_root_ioctl_unlocked(inode, filp, cmd, 919 (unsigned long)compat_ptr(arg)); 920 921 return ret; 922} 923#endif 924