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