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/smp_lock.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 *,int); 30static long autofs4_root_ioctl(struct file *,unsigned int,unsigned long); 31static long autofs4_root_compat_ioctl(struct file *,unsigned int,unsigned long); 32static int autofs4_dir_open(struct inode *inode, struct file *file); 33static struct dentry *autofs4_lookup(struct inode *,struct dentry *, struct nameidata *); 34static void *autofs4_follow_link(struct dentry *, struct nameidata *); 35 36#define TRIGGER_FLAGS (LOOKUP_CONTINUE | LOOKUP_DIRECTORY) 37#define TRIGGER_INTENTS (LOOKUP_OPEN | LOOKUP_CREATE) 38 39const struct file_operations autofs4_root_operations = { 40 .open = dcache_dir_open, 41 .release = dcache_dir_close, 42 .read = generic_read_dir, 43 .readdir = dcache_readdir, 44 .llseek = dcache_dir_lseek, 45 .unlocked_ioctl = autofs4_root_ioctl, 46#ifdef CONFIG_COMPAT 47 .compat_ioctl = autofs4_root_compat_ioctl, 48#endif 49}; 50 51const struct file_operations autofs4_dir_operations = { 52 .open = autofs4_dir_open, 53 .release = dcache_dir_close, 54 .read = generic_read_dir, 55 .readdir = dcache_readdir, 56 .llseek = dcache_dir_lseek, 57}; 58 59const struct inode_operations autofs4_indirect_root_inode_operations = { 60 .lookup = autofs4_lookup, 61 .unlink = autofs4_dir_unlink, 62 .symlink = autofs4_dir_symlink, 63 .mkdir = autofs4_dir_mkdir, 64 .rmdir = autofs4_dir_rmdir, 65}; 66 67const struct inode_operations autofs4_direct_root_inode_operations = { 68 .lookup = autofs4_lookup, 69 .unlink = autofs4_dir_unlink, 70 .mkdir = autofs4_dir_mkdir, 71 .rmdir = autofs4_dir_rmdir, 72 .follow_link = autofs4_follow_link, 73}; 74 75const struct inode_operations autofs4_dir_inode_operations = { 76 .lookup = autofs4_lookup, 77 .unlink = autofs4_dir_unlink, 78 .symlink = autofs4_dir_symlink, 79 .mkdir = autofs4_dir_mkdir, 80 .rmdir = autofs4_dir_rmdir, 81}; 82 83static void autofs4_add_active(struct dentry *dentry) 84{ 85 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); 86 struct autofs_info *ino = autofs4_dentry_ino(dentry); 87 if (ino) { 88 spin_lock(&sbi->lookup_lock); 89 if (!ino->active_count) { 90 if (list_empty(&ino->active)) 91 list_add(&ino->active, &sbi->active_list); 92 } 93 ino->active_count++; 94 spin_unlock(&sbi->lookup_lock); 95 } 96 return; 97} 98 99static void autofs4_del_active(struct dentry *dentry) 100{ 101 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); 102 struct autofs_info *ino = autofs4_dentry_ino(dentry); 103 if (ino) { 104 spin_lock(&sbi->lookup_lock); 105 ino->active_count--; 106 if (!ino->active_count) { 107 if (!list_empty(&ino->active)) 108 list_del_init(&ino->active); 109 } 110 spin_unlock(&sbi->lookup_lock); 111 } 112 return; 113} 114 115static unsigned int autofs4_need_mount(unsigned int flags) 116{ 117 unsigned int res = 0; 118 if (flags & (TRIGGER_FLAGS | TRIGGER_INTENTS)) 119 res = 1; 120 return res; 121} 122 123static int autofs4_dir_open(struct inode *inode, struct file *file) 124{ 125 struct dentry *dentry = file->f_path.dentry; 126 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); 127 128 DPRINTK("file=%p dentry=%p %.*s", 129 file, dentry, dentry->d_name.len, dentry->d_name.name); 130 131 if (autofs4_oz_mode(sbi)) 132 goto out; 133 134 /* 135 * An empty directory in an autofs file system is always a 136 * mount point. The daemon must have failed to mount this 137 * during lookup so it doesn't exist. This can happen, for 138 * example, if user space returns an incorrect status for a 139 * mount request. Otherwise we're doing a readdir on the 140 * autofs file system so just let the libfs routines handle 141 * it. 142 */ 143 spin_lock(&dcache_lock); 144 if (!d_mountpoint(dentry) && list_empty(&dentry->d_subdirs)) { 145 spin_unlock(&dcache_lock); 146 return -ENOENT; 147 } 148 spin_unlock(&dcache_lock); 149 150out: 151 return dcache_dir_open(inode, file); 152} 153 154static int try_to_fill_dentry(struct dentry *dentry, int flags) 155{ 156 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); 157 struct autofs_info *ino = autofs4_dentry_ino(dentry); 158 int status; 159 160 DPRINTK("dentry=%p %.*s ino=%p", 161 dentry, dentry->d_name.len, dentry->d_name.name, dentry->d_inode); 162 163 /* 164 * Wait for a pending mount, triggering one if there 165 * isn't one already 166 */ 167 if (dentry->d_inode == NULL) { 168 DPRINTK("waiting for mount name=%.*s", 169 dentry->d_name.len, dentry->d_name.name); 170 171 status = autofs4_wait(sbi, dentry, NFY_MOUNT); 172 173 DPRINTK("mount done status=%d", status); 174 175 /* Turn this into a real negative dentry? */ 176 if (status == -ENOENT) { 177 spin_lock(&sbi->fs_lock); 178 ino->flags &= ~AUTOFS_INF_PENDING; 179 spin_unlock(&sbi->fs_lock); 180 return status; 181 } else if (status) { 182 /* Return a negative dentry, but leave it "pending" */ 183 return status; 184 } 185 /* Trigger mount for path component or follow link */ 186 } else if (ino->flags & AUTOFS_INF_PENDING || 187 autofs4_need_mount(flags)) { 188 DPRINTK("waiting for mount name=%.*s", 189 dentry->d_name.len, dentry->d_name.name); 190 191 spin_lock(&sbi->fs_lock); 192 ino->flags |= AUTOFS_INF_PENDING; 193 spin_unlock(&sbi->fs_lock); 194 status = autofs4_wait(sbi, dentry, NFY_MOUNT); 195 196 DPRINTK("mount done status=%d", status); 197 198 if (status) { 199 spin_lock(&sbi->fs_lock); 200 ino->flags &= ~AUTOFS_INF_PENDING; 201 spin_unlock(&sbi->fs_lock); 202 return status; 203 } 204 } 205 206 /* Initialize expiry counter after successful mount */ 207 ino->last_used = jiffies; 208 209 spin_lock(&sbi->fs_lock); 210 ino->flags &= ~AUTOFS_INF_PENDING; 211 spin_unlock(&sbi->fs_lock); 212 213 return 0; 214} 215 216/* For autofs direct mounts the follow link triggers the mount */ 217static void *autofs4_follow_link(struct dentry *dentry, struct nameidata *nd) 218{ 219 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); 220 struct autofs_info *ino = autofs4_dentry_ino(dentry); 221 int oz_mode = autofs4_oz_mode(sbi); 222 unsigned int lookup_type; 223 int status; 224 225 DPRINTK("dentry=%p %.*s oz_mode=%d nd->flags=%d", 226 dentry, dentry->d_name.len, dentry->d_name.name, oz_mode, 227 nd->flags); 228 /* 229 * For an expire of a covered direct or offset mount we need 230 * to break out of follow_down() at the autofs mount trigger 231 * (d_mounted--), so we can see the expiring flag, and manage 232 * the blocking and following here until the expire is completed. 233 */ 234 if (oz_mode) { 235 spin_lock(&sbi->fs_lock); 236 if (ino->flags & AUTOFS_INF_EXPIRING) { 237 spin_unlock(&sbi->fs_lock); 238 /* Follow down to our covering mount. */ 239 if (!follow_down(&nd->path)) 240 goto done; 241 goto follow; 242 } 243 spin_unlock(&sbi->fs_lock); 244 goto done; 245 } 246 247 /* If an expire request is pending everyone must wait. */ 248 autofs4_expire_wait(dentry); 249 250 /* We trigger a mount for almost all flags */ 251 lookup_type = autofs4_need_mount(nd->flags); 252 spin_lock(&sbi->fs_lock); 253 spin_lock(&dcache_lock); 254 if (!(lookup_type || ino->flags & AUTOFS_INF_PENDING)) { 255 spin_unlock(&dcache_lock); 256 spin_unlock(&sbi->fs_lock); 257 goto follow; 258 } 259 260 /* 261 * If the dentry contains directories then it is an autofs 262 * multi-mount with no root mount offset. So don't try to 263 * mount it again. 264 */ 265 if (ino->flags & AUTOFS_INF_PENDING || 266 (!d_mountpoint(dentry) && list_empty(&dentry->d_subdirs))) { 267 spin_unlock(&dcache_lock); 268 spin_unlock(&sbi->fs_lock); 269 270 status = try_to_fill_dentry(dentry, nd->flags); 271 if (status) 272 goto out_error; 273 274 goto follow; 275 } 276 spin_unlock(&dcache_lock); 277 spin_unlock(&sbi->fs_lock); 278follow: 279 /* 280 * If there is no root mount it must be an autofs 281 * multi-mount with no root offset so we don't need 282 * to follow it. 283 */ 284 if (d_mountpoint(dentry)) { 285 if (!autofs4_follow_mount(&nd->path)) { 286 status = -ENOENT; 287 goto out_error; 288 } 289 } 290 291done: 292 return NULL; 293 294out_error: 295 path_put(&nd->path); 296 return ERR_PTR(status); 297} 298 299/* 300 * Revalidate is called on every cache lookup. Some of those 301 * cache lookups may actually happen while the dentry is not 302 * yet completely filled in, and revalidate has to delay such 303 * lookups.. 304 */ 305static int autofs4_revalidate(struct dentry *dentry, struct nameidata *nd) 306{ 307 struct inode *dir = dentry->d_parent->d_inode; 308 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb); 309 int oz_mode = autofs4_oz_mode(sbi); 310 int flags = nd ? nd->flags : 0; 311 int status = 1; 312 313 /* Pending dentry */ 314 spin_lock(&sbi->fs_lock); 315 if (autofs4_ispending(dentry)) { 316 /* The daemon never causes a mount to trigger */ 317 spin_unlock(&sbi->fs_lock); 318 319 if (oz_mode) 320 return 1; 321 322 /* 323 * If the directory has gone away due to an expire 324 * we have been called as ->d_revalidate() and so 325 * we need to return false and proceed to ->lookup(). 326 */ 327 if (autofs4_expire_wait(dentry) == -EAGAIN) 328 return 0; 329 330 /* 331 * A zero status is success otherwise we have a 332 * negative error code. 333 */ 334 status = try_to_fill_dentry(dentry, flags); 335 if (status == 0) 336 return 1; 337 338 return status; 339 } 340 spin_unlock(&sbi->fs_lock); 341 342 /* Negative dentry.. invalidate if "old" */ 343 if (dentry->d_inode == NULL) 344 return 0; 345 346 /* Check for a non-mountpoint directory with no contents */ 347 spin_lock(&dcache_lock); 348 if (S_ISDIR(dentry->d_inode->i_mode) && 349 !d_mountpoint(dentry) && list_empty(&dentry->d_subdirs)) { 350 DPRINTK("dentry=%p %.*s, emptydir", 351 dentry, dentry->d_name.len, dentry->d_name.name); 352 spin_unlock(&dcache_lock); 353 354 /* The daemon never causes a mount to trigger */ 355 if (oz_mode) 356 return 1; 357 358 /* 359 * A zero status is success otherwise we have a 360 * negative error code. 361 */ 362 status = try_to_fill_dentry(dentry, flags); 363 if (status == 0) 364 return 1; 365 366 return status; 367 } 368 spin_unlock(&dcache_lock); 369 370 return 1; 371} 372 373void autofs4_dentry_release(struct dentry *de) 374{ 375 struct autofs_info *inf; 376 377 DPRINTK("releasing %p", de); 378 379 inf = autofs4_dentry_ino(de); 380 de->d_fsdata = NULL; 381 382 if (inf) { 383 struct autofs_sb_info *sbi = autofs4_sbi(de->d_sb); 384 385 if (sbi) { 386 spin_lock(&sbi->lookup_lock); 387 if (!list_empty(&inf->active)) 388 list_del(&inf->active); 389 if (!list_empty(&inf->expiring)) 390 list_del(&inf->expiring); 391 spin_unlock(&sbi->lookup_lock); 392 } 393 394 inf->dentry = NULL; 395 inf->inode = NULL; 396 397 autofs4_free_ino(inf); 398 } 399} 400 401/* For dentries of directories in the root dir */ 402static const struct dentry_operations autofs4_root_dentry_operations = { 403 .d_revalidate = autofs4_revalidate, 404 .d_release = autofs4_dentry_release, 405}; 406 407/* For other dentries */ 408static const struct dentry_operations autofs4_dentry_operations = { 409 .d_revalidate = autofs4_revalidate, 410 .d_release = autofs4_dentry_release, 411}; 412 413static struct dentry *autofs4_lookup_active(struct dentry *dentry) 414{ 415 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); 416 struct dentry *parent = dentry->d_parent; 417 struct qstr *name = &dentry->d_name; 418 unsigned int len = name->len; 419 unsigned int hash = name->hash; 420 const unsigned char *str = name->name; 421 struct list_head *p, *head; 422 423 spin_lock(&dcache_lock); 424 spin_lock(&sbi->lookup_lock); 425 head = &sbi->active_list; 426 list_for_each(p, head) { 427 struct autofs_info *ino; 428 struct dentry *active; 429 struct qstr *qstr; 430 431 ino = list_entry(p, struct autofs_info, active); 432 active = ino->dentry; 433 434 spin_lock(&active->d_lock); 435 436 /* Already gone? */ 437 if (atomic_read(&active->d_count) == 0) 438 goto next; 439 440 qstr = &active->d_name; 441 442 if (active->d_name.hash != hash) 443 goto next; 444 if (active->d_parent != parent) 445 goto next; 446 447 if (qstr->len != len) 448 goto next; 449 if (memcmp(qstr->name, str, len)) 450 goto next; 451 452 if (d_unhashed(active)) { 453 dget(active); 454 spin_unlock(&active->d_lock); 455 spin_unlock(&sbi->lookup_lock); 456 spin_unlock(&dcache_lock); 457 return active; 458 } 459next: 460 spin_unlock(&active->d_lock); 461 } 462 spin_unlock(&sbi->lookup_lock); 463 spin_unlock(&dcache_lock); 464 465 return NULL; 466} 467 468static struct dentry *autofs4_lookup_expiring(struct dentry *dentry) 469{ 470 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); 471 struct dentry *parent = dentry->d_parent; 472 struct qstr *name = &dentry->d_name; 473 unsigned int len = name->len; 474 unsigned int hash = name->hash; 475 const unsigned char *str = name->name; 476 struct list_head *p, *head; 477 478 spin_lock(&dcache_lock); 479 spin_lock(&sbi->lookup_lock); 480 head = &sbi->expiring_list; 481 list_for_each(p, head) { 482 struct autofs_info *ino; 483 struct dentry *expiring; 484 struct qstr *qstr; 485 486 ino = list_entry(p, struct autofs_info, expiring); 487 expiring = ino->dentry; 488 489 spin_lock(&expiring->d_lock); 490 491 /* Bad luck, we've already been dentry_iput */ 492 if (!expiring->d_inode) 493 goto next; 494 495 qstr = &expiring->d_name; 496 497 if (expiring->d_name.hash != hash) 498 goto next; 499 if (expiring->d_parent != parent) 500 goto next; 501 502 if (qstr->len != len) 503 goto next; 504 if (memcmp(qstr->name, str, len)) 505 goto next; 506 507 if (d_unhashed(expiring)) { 508 dget(expiring); 509 spin_unlock(&expiring->d_lock); 510 spin_unlock(&sbi->lookup_lock); 511 spin_unlock(&dcache_lock); 512 return expiring; 513 } 514next: 515 spin_unlock(&expiring->d_lock); 516 } 517 spin_unlock(&sbi->lookup_lock); 518 spin_unlock(&dcache_lock); 519 520 return NULL; 521} 522 523/* Lookups in the root directory */ 524static struct dentry *autofs4_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd) 525{ 526 struct autofs_sb_info *sbi; 527 struct autofs_info *ino; 528 struct dentry *expiring, *active; 529 int oz_mode; 530 531 DPRINTK("name = %.*s", 532 dentry->d_name.len, dentry->d_name.name); 533 534 /* File name too long to exist */ 535 if (dentry->d_name.len > NAME_MAX) 536 return ERR_PTR(-ENAMETOOLONG); 537 538 sbi = autofs4_sbi(dir->i_sb); 539 oz_mode = autofs4_oz_mode(sbi); 540 541 DPRINTK("pid = %u, pgrp = %u, catatonic = %d, oz_mode = %d", 542 current->pid, task_pgrp_nr(current), sbi->catatonic, oz_mode); 543 544 active = autofs4_lookup_active(dentry); 545 if (active) { 546 dentry = active; 547 ino = autofs4_dentry_ino(dentry); 548 } else { 549 /* 550 * Mark the dentry incomplete but don't hash it. We do this 551 * to serialize our inode creation operations (symlink and 552 * mkdir) which prevents deadlock during the callback to 553 * the daemon. Subsequent user space lookups for the same 554 * dentry are placed on the wait queue while the daemon 555 * itself is allowed passage unresticted so the create 556 * operation itself can then hash the dentry. Finally, 557 * we check for the hashed dentry and return the newly 558 * hashed dentry. 559 */ 560 dentry->d_op = &autofs4_root_dentry_operations; 561 562 /* 563 * And we need to ensure that the same dentry is used for 564 * all following lookup calls until it is hashed so that 565 * the dentry flags are persistent throughout the request. 566 */ 567 ino = autofs4_init_ino(NULL, sbi, 0555); 568 if (!ino) 569 return ERR_PTR(-ENOMEM); 570 571 dentry->d_fsdata = ino; 572 ino->dentry = dentry; 573 574 autofs4_add_active(dentry); 575 576 d_instantiate(dentry, NULL); 577 } 578 579 if (!oz_mode) { 580 mutex_unlock(&dir->i_mutex); 581 expiring = autofs4_lookup_expiring(dentry); 582 if (expiring) { 583 /* 584 * If we are racing with expire the request might not 585 * be quite complete but the directory has been removed 586 * so it must have been successful, so just wait for it. 587 */ 588 autofs4_expire_wait(expiring); 589 autofs4_del_expiring(expiring); 590 dput(expiring); 591 } 592 593 spin_lock(&sbi->fs_lock); 594 ino->flags |= AUTOFS_INF_PENDING; 595 spin_unlock(&sbi->fs_lock); 596 if (dentry->d_op && dentry->d_op->d_revalidate) 597 (dentry->d_op->d_revalidate)(dentry, nd); 598 mutex_lock(&dir->i_mutex); 599 } 600 601 /* 602 * If we are still pending, check if we had to handle 603 * a signal. If so we can force a restart.. 604 */ 605 if (ino->flags & AUTOFS_INF_PENDING) { 606 /* See if we were interrupted */ 607 if (signal_pending(current)) { 608 sigset_t *sigset = ¤t->pending.signal; 609 if (sigismember (sigset, SIGKILL) || 610 sigismember (sigset, SIGQUIT) || 611 sigismember (sigset, SIGINT)) { 612 if (active) 613 dput(active); 614 return ERR_PTR(-ERESTARTNOINTR); 615 } 616 } 617 if (!oz_mode) { 618 spin_lock(&sbi->fs_lock); 619 ino->flags &= ~AUTOFS_INF_PENDING; 620 spin_unlock(&sbi->fs_lock); 621 } 622 } 623 624 /* 625 * If this dentry is unhashed, then we shouldn't honour this 626 * lookup. Returning ENOENT here doesn't do the right thing 627 * for all system calls, but it should be OK for the operations 628 * we permit from an autofs. 629 */ 630 if (!oz_mode && d_unhashed(dentry)) { 631 /* 632 * A user space application can (and has done in the past) 633 * remove and re-create this directory during the callback. 634 * This can leave us with an unhashed dentry, but a 635 * successful mount! So we need to perform another 636 * cached lookup in case the dentry now exists. 637 */ 638 struct dentry *parent = dentry->d_parent; 639 struct dentry *new = d_lookup(parent, &dentry->d_name); 640 if (new != NULL) 641 dentry = new; 642 else 643 dentry = ERR_PTR(-ENOENT); 644 645 if (active) 646 dput(active); 647 648 return dentry; 649 } 650 651 if (active) 652 return active; 653 654 return NULL; 655} 656 657static int autofs4_dir_symlink(struct inode *dir, 658 struct dentry *dentry, 659 const char *symname) 660{ 661 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb); 662 struct autofs_info *ino = autofs4_dentry_ino(dentry); 663 struct autofs_info *p_ino; 664 struct inode *inode; 665 char *cp; 666 667 DPRINTK("%s <- %.*s", symname, 668 dentry->d_name.len, dentry->d_name.name); 669 670 if (!autofs4_oz_mode(sbi)) 671 return -EACCES; 672 673 ino = autofs4_init_ino(ino, sbi, S_IFLNK | 0555); 674 if (!ino) 675 return -ENOMEM; 676 677 autofs4_del_active(dentry); 678 679 ino->size = strlen(symname); 680 cp = kmalloc(ino->size + 1, GFP_KERNEL); 681 if (!cp) { 682 if (!dentry->d_fsdata) 683 kfree(ino); 684 return -ENOMEM; 685 } 686 687 strcpy(cp, symname); 688 689 inode = autofs4_get_inode(dir->i_sb, ino); 690 if (!inode) { 691 kfree(cp); 692 if (!dentry->d_fsdata) 693 kfree(ino); 694 return -ENOMEM; 695 } 696 d_add(dentry, inode); 697 698 if (dir == dir->i_sb->s_root->d_inode) 699 dentry->d_op = &autofs4_root_dentry_operations; 700 else 701 dentry->d_op = &autofs4_dentry_operations; 702 703 dentry->d_fsdata = ino; 704 ino->dentry = dget(dentry); 705 atomic_inc(&ino->count); 706 p_ino = autofs4_dentry_ino(dentry->d_parent); 707 if (p_ino && dentry->d_parent != dentry) 708 atomic_inc(&p_ino->count); 709 ino->inode = inode; 710 711 ino->u.symlink = cp; 712 dir->i_mtime = CURRENT_TIME; 713 714 return 0; 715} 716 717/* 718 * NOTE! 719 * 720 * Normal filesystems would do a "d_delete()" to tell the VFS dcache 721 * that the file no longer exists. However, doing that means that the 722 * VFS layer can turn the dentry into a negative dentry. We don't want 723 * this, because the unlink is probably the result of an expire. 724 * We simply d_drop it and add it to a expiring list in the super block, 725 * which allows the dentry lookup to check for an incomplete expire. 726 * 727 * If a process is blocked on the dentry waiting for the expire to finish, 728 * it will invalidate the dentry and try to mount with a new one. 729 * 730 * Also see autofs4_dir_rmdir().. 731 */ 732static int autofs4_dir_unlink(struct inode *dir, struct dentry *dentry) 733{ 734 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb); 735 struct autofs_info *ino = autofs4_dentry_ino(dentry); 736 struct autofs_info *p_ino; 737 738 /* This allows root to remove symlinks */ 739 if (!autofs4_oz_mode(sbi) && !capable(CAP_SYS_ADMIN)) 740 return -EACCES; 741 742 if (atomic_dec_and_test(&ino->count)) { 743 p_ino = autofs4_dentry_ino(dentry->d_parent); 744 if (p_ino && dentry->d_parent != dentry) 745 atomic_dec(&p_ino->count); 746 } 747 dput(ino->dentry); 748 749 dentry->d_inode->i_size = 0; 750 clear_nlink(dentry->d_inode); 751 752 dir->i_mtime = CURRENT_TIME; 753 754 spin_lock(&dcache_lock); 755 autofs4_add_expiring(dentry); 756 spin_lock(&dentry->d_lock); 757 __d_drop(dentry); 758 spin_unlock(&dentry->d_lock); 759 spin_unlock(&dcache_lock); 760 761 return 0; 762} 763 764static int autofs4_dir_rmdir(struct inode *dir, struct dentry *dentry) 765{ 766 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb); 767 struct autofs_info *ino = autofs4_dentry_ino(dentry); 768 struct autofs_info *p_ino; 769 770 DPRINTK("dentry %p, removing %.*s", 771 dentry, dentry->d_name.len, dentry->d_name.name); 772 773 if (!autofs4_oz_mode(sbi)) 774 return -EACCES; 775 776 spin_lock(&dcache_lock); 777 if (!list_empty(&dentry->d_subdirs)) { 778 spin_unlock(&dcache_lock); 779 return -ENOTEMPTY; 780 } 781 autofs4_add_expiring(dentry); 782 spin_lock(&dentry->d_lock); 783 __d_drop(dentry); 784 spin_unlock(&dentry->d_lock); 785 spin_unlock(&dcache_lock); 786 787 if (atomic_dec_and_test(&ino->count)) { 788 p_ino = autofs4_dentry_ino(dentry->d_parent); 789 if (p_ino && dentry->d_parent != dentry) 790 atomic_dec(&p_ino->count); 791 } 792 dput(ino->dentry); 793 dentry->d_inode->i_size = 0; 794 clear_nlink(dentry->d_inode); 795 796 if (dir->i_nlink) 797 drop_nlink(dir); 798 799 return 0; 800} 801 802static int autofs4_dir_mkdir(struct inode *dir, struct dentry *dentry, int mode) 803{ 804 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb); 805 struct autofs_info *ino = autofs4_dentry_ino(dentry); 806 struct autofs_info *p_ino; 807 struct inode *inode; 808 809 if (!autofs4_oz_mode(sbi)) 810 return -EACCES; 811 812 DPRINTK("dentry %p, creating %.*s", 813 dentry, dentry->d_name.len, dentry->d_name.name); 814 815 ino = autofs4_init_ino(ino, sbi, S_IFDIR | 0555); 816 if (!ino) 817 return -ENOMEM; 818 819 autofs4_del_active(dentry); 820 821 inode = autofs4_get_inode(dir->i_sb, ino); 822 if (!inode) { 823 if (!dentry->d_fsdata) 824 kfree(ino); 825 return -ENOMEM; 826 } 827 d_add(dentry, inode); 828 829 if (dir == dir->i_sb->s_root->d_inode) 830 dentry->d_op = &autofs4_root_dentry_operations; 831 else 832 dentry->d_op = &autofs4_dentry_operations; 833 834 dentry->d_fsdata = ino; 835 ino->dentry = dget(dentry); 836 atomic_inc(&ino->count); 837 p_ino = autofs4_dentry_ino(dentry->d_parent); 838 if (p_ino && dentry->d_parent != dentry) 839 atomic_inc(&p_ino->count); 840 ino->inode = inode; 841 inc_nlink(dir); 842 dir->i_mtime = CURRENT_TIME; 843 844 return 0; 845} 846 847/* Get/set timeout ioctl() operation */ 848#ifdef CONFIG_COMPAT 849static inline int autofs4_compat_get_set_timeout(struct autofs_sb_info *sbi, 850 compat_ulong_t __user *p) 851{ 852 int rv; 853 unsigned long ntimeout; 854 855 if ((rv = get_user(ntimeout, p)) || 856 (rv = put_user(sbi->exp_timeout/HZ, p))) 857 return rv; 858 859 if (ntimeout > UINT_MAX/HZ) 860 sbi->exp_timeout = 0; 861 else 862 sbi->exp_timeout = ntimeout * HZ; 863 864 return 0; 865} 866#endif 867 868static inline int autofs4_get_set_timeout(struct autofs_sb_info *sbi, 869 unsigned long __user *p) 870{ 871 int rv; 872 unsigned long ntimeout; 873 874 if ((rv = get_user(ntimeout, p)) || 875 (rv = put_user(sbi->exp_timeout/HZ, p))) 876 return rv; 877 878 if (ntimeout > ULONG_MAX/HZ) 879 sbi->exp_timeout = 0; 880 else 881 sbi->exp_timeout = ntimeout * HZ; 882 883 return 0; 884} 885 886/* Return protocol version */ 887static inline int autofs4_get_protover(struct autofs_sb_info *sbi, int __user *p) 888{ 889 return put_user(sbi->version, p); 890} 891 892/* Return protocol sub version */ 893static inline int autofs4_get_protosubver(struct autofs_sb_info *sbi, int __user *p) 894{ 895 return put_user(sbi->sub_version, p); 896} 897 898/* 899* Tells the daemon whether it can umount the autofs mount. 900*/ 901static inline int autofs4_ask_umount(struct vfsmount *mnt, int __user *p) 902{ 903 int status = 0; 904 905 if (may_umount(mnt)) 906 status = 1; 907 908 DPRINTK("returning %d", status); 909 910 status = put_user(status, p); 911 912 return status; 913} 914 915/* Identify autofs4_dentries - this is so we can tell if there's 916 an extra dentry refcount or not. We only hold a refcount on the 917 dentry if its non-negative (ie, d_inode != NULL) 918*/ 919int is_autofs4_dentry(struct dentry *dentry) 920{ 921 return dentry && dentry->d_inode && 922 (dentry->d_op == &autofs4_root_dentry_operations || 923 dentry->d_op == &autofs4_dentry_operations) && 924 dentry->d_fsdata != NULL; 925} 926 927/* 928 * ioctl()'s on the root directory is the chief method for the daemon to 929 * generate kernel reactions 930 */ 931static int autofs4_root_ioctl_unlocked(struct inode *inode, struct file *filp, 932 unsigned int cmd, unsigned long arg) 933{ 934 struct autofs_sb_info *sbi = autofs4_sbi(inode->i_sb); 935 void __user *p = (void __user *)arg; 936 937 DPRINTK("cmd = 0x%08x, arg = 0x%08lx, sbi = %p, pgrp = %u", 938 cmd,arg,sbi,task_pgrp_nr(current)); 939 940 if (_IOC_TYPE(cmd) != _IOC_TYPE(AUTOFS_IOC_FIRST) || 941 _IOC_NR(cmd) - _IOC_NR(AUTOFS_IOC_FIRST) >= AUTOFS_IOC_COUNT) 942 return -ENOTTY; 943 944 if (!autofs4_oz_mode(sbi) && !capable(CAP_SYS_ADMIN)) 945 return -EPERM; 946 947 switch(cmd) { 948 case AUTOFS_IOC_READY: /* Wait queue: go ahead and retry */ 949 return autofs4_wait_release(sbi,(autofs_wqt_t)arg,0); 950 case AUTOFS_IOC_FAIL: /* Wait queue: fail with ENOENT */ 951 return autofs4_wait_release(sbi,(autofs_wqt_t)arg,-ENOENT); 952 case AUTOFS_IOC_CATATONIC: /* Enter catatonic mode (daemon shutdown) */ 953 autofs4_catatonic_mode(sbi); 954 return 0; 955 case AUTOFS_IOC_PROTOVER: /* Get protocol version */ 956 return autofs4_get_protover(sbi, p); 957 case AUTOFS_IOC_PROTOSUBVER: /* Get protocol sub version */ 958 return autofs4_get_protosubver(sbi, p); 959 case AUTOFS_IOC_SETTIMEOUT: 960 return autofs4_get_set_timeout(sbi, p); 961#ifdef CONFIG_COMPAT 962 case AUTOFS_IOC_SETTIMEOUT32: 963 return autofs4_compat_get_set_timeout(sbi, p); 964#endif 965 966 case AUTOFS_IOC_ASKUMOUNT: 967 return autofs4_ask_umount(filp->f_path.mnt, p); 968 969 /* return a single thing to expire */ 970 case AUTOFS_IOC_EXPIRE: 971 return autofs4_expire_run(inode->i_sb,filp->f_path.mnt,sbi, p); 972 /* same as above, but can send multiple expires through pipe */ 973 case AUTOFS_IOC_EXPIRE_MULTI: 974 return autofs4_expire_multi(inode->i_sb,filp->f_path.mnt,sbi, p); 975 976 default: 977 return -ENOSYS; 978 } 979} 980 981static long autofs4_root_ioctl(struct file *filp, 982 unsigned int cmd, unsigned long arg) 983{ 984 long ret; 985 struct inode *inode = filp->f_dentry->d_inode; 986 987 lock_kernel(); 988 ret = autofs4_root_ioctl_unlocked(inode, filp, cmd, arg); 989 unlock_kernel(); 990 991 return ret; 992} 993 994#ifdef CONFIG_COMPAT 995static long autofs4_root_compat_ioctl(struct file *filp, 996 unsigned int cmd, unsigned long arg) 997{ 998 struct inode *inode = filp->f_path.dentry->d_inode; 999 int ret; 1000 1001 lock_kernel(); 1002 if (cmd == AUTOFS_IOC_READY || cmd == AUTOFS_IOC_FAIL) 1003 ret = autofs4_root_ioctl_unlocked(inode, filp, cmd, arg); 1004 else 1005 ret = autofs4_root_ioctl_unlocked(inode, filp, cmd, 1006 (unsigned long)compat_ptr(arg)); 1007 unlock_kernel(); 1008 1009 return ret; 1010} 1011#endif 1012