1
2
3
4
5
6
7
8
9
10
11
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
26DEFINE_SPINLOCK(autofs4_lock);
27
28static int autofs4_dir_symlink(struct inode *,struct dentry *,const char *);
29static int autofs4_dir_unlink(struct inode *,struct dentry *);
30static int autofs4_dir_rmdir(struct inode *,struct dentry *);
31static int autofs4_dir_mkdir(struct inode *,struct dentry *,int);
32static long autofs4_root_ioctl(struct file *,unsigned int,unsigned long);
33#ifdef CONFIG_COMPAT
34static long autofs4_root_compat_ioctl(struct file *,unsigned int,unsigned long);
35#endif
36static int autofs4_dir_open(struct inode *inode, struct file *file);
37static struct dentry *autofs4_lookup(struct inode *,struct dentry *, struct nameidata *);
38static struct vfsmount *autofs4_d_automount(struct path *);
39static int autofs4_d_manage(struct dentry *, bool, bool);
40static void autofs4_dentry_release(struct dentry *);
41
42const struct file_operations autofs4_root_operations = {
43 .open = dcache_dir_open,
44 .release = dcache_dir_close,
45 .read = generic_read_dir,
46 .readdir = dcache_readdir,
47 .llseek = dcache_dir_lseek,
48 .unlocked_ioctl = autofs4_root_ioctl,
49#ifdef CONFIG_COMPAT
50 .compat_ioctl = autofs4_root_compat_ioctl,
51#endif
52};
53
54const struct file_operations autofs4_dir_operations = {
55 .open = autofs4_dir_open,
56 .release = dcache_dir_close,
57 .read = generic_read_dir,
58 .readdir = dcache_readdir,
59 .llseek = dcache_dir_lseek,
60};
61
62const struct inode_operations autofs4_dir_inode_operations = {
63 .lookup = autofs4_lookup,
64 .unlink = autofs4_dir_unlink,
65 .symlink = autofs4_dir_symlink,
66 .mkdir = autofs4_dir_mkdir,
67 .rmdir = autofs4_dir_rmdir,
68};
69
70const struct dentry_operations autofs4_dentry_operations = {
71 .d_automount = autofs4_d_automount,
72 .d_manage = autofs4_d_manage,
73 .d_release = autofs4_dentry_release,
74};
75
76static void autofs4_add_active(struct dentry *dentry)
77{
78 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
79 struct autofs_info *ino = autofs4_dentry_ino(dentry);
80 if (ino) {
81 spin_lock(&sbi->lookup_lock);
82 if (!ino->active_count) {
83 if (list_empty(&ino->active))
84 list_add(&ino->active, &sbi->active_list);
85 }
86 ino->active_count++;
87 spin_unlock(&sbi->lookup_lock);
88 }
89 return;
90}
91
92static void autofs4_del_active(struct dentry *dentry)
93{
94 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
95 struct autofs_info *ino = autofs4_dentry_ino(dentry);
96 if (ino) {
97 spin_lock(&sbi->lookup_lock);
98 ino->active_count--;
99 if (!ino->active_count) {
100 if (!list_empty(&ino->active))
101 list_del_init(&ino->active);
102 }
103 spin_unlock(&sbi->lookup_lock);
104 }
105 return;
106}
107
108static int autofs4_dir_open(struct inode *inode, struct file *file)
109{
110 struct dentry *dentry = file->f_path.dentry;
111 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
112
113 DPRINTK("file=%p dentry=%p %.*s",
114 file, dentry, dentry->d_name.len, dentry->d_name.name);
115
116 if (autofs4_oz_mode(sbi))
117 goto out;
118
119
120
121
122
123
124
125
126
127
128 spin_lock(&autofs4_lock);
129 spin_lock(&dentry->d_lock);
130 if (!d_mountpoint(dentry) && list_empty(&dentry->d_subdirs)) {
131 spin_unlock(&dentry->d_lock);
132 spin_unlock(&autofs4_lock);
133 return -ENOENT;
134 }
135 spin_unlock(&dentry->d_lock);
136 spin_unlock(&autofs4_lock);
137
138out:
139 return dcache_dir_open(inode, file);
140}
141
142static void autofs4_dentry_release(struct dentry *de)
143{
144 struct autofs_info *ino = autofs4_dentry_ino(de);
145 struct autofs_sb_info *sbi = autofs4_sbi(de->d_sb);
146
147 DPRINTK("releasing %p", de);
148
149 if (!ino)
150 return;
151
152 if (sbi) {
153 spin_lock(&sbi->lookup_lock);
154 if (!list_empty(&ino->active))
155 list_del(&ino->active);
156 if (!list_empty(&ino->expiring))
157 list_del(&ino->expiring);
158 spin_unlock(&sbi->lookup_lock);
159 }
160
161 autofs4_free_ino(ino);
162}
163
164static struct dentry *autofs4_lookup_active(struct dentry *dentry)
165{
166 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
167 struct dentry *parent = dentry->d_parent;
168 struct qstr *name = &dentry->d_name;
169 unsigned int len = name->len;
170 unsigned int hash = name->hash;
171 const unsigned char *str = name->name;
172 struct list_head *p, *head;
173
174 spin_lock(&autofs4_lock);
175 spin_lock(&sbi->lookup_lock);
176 head = &sbi->active_list;
177 list_for_each(p, head) {
178 struct autofs_info *ino;
179 struct dentry *active;
180 struct qstr *qstr;
181
182 ino = list_entry(p, struct autofs_info, active);
183 active = ino->dentry;
184
185 spin_lock(&active->d_lock);
186
187
188 if (active->d_count == 0)
189 goto next;
190
191 qstr = &active->d_name;
192
193 if (active->d_name.hash != hash)
194 goto next;
195 if (active->d_parent != parent)
196 goto next;
197
198 if (qstr->len != len)
199 goto next;
200 if (memcmp(qstr->name, str, len))
201 goto next;
202
203 if (d_unhashed(active)) {
204 dget_dlock(active);
205 spin_unlock(&active->d_lock);
206 spin_unlock(&sbi->lookup_lock);
207 spin_unlock(&autofs4_lock);
208 return active;
209 }
210next:
211 spin_unlock(&active->d_lock);
212 }
213 spin_unlock(&sbi->lookup_lock);
214 spin_unlock(&autofs4_lock);
215
216 return NULL;
217}
218
219static struct dentry *autofs4_lookup_expiring(struct dentry *dentry)
220{
221 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
222 struct dentry *parent = dentry->d_parent;
223 struct qstr *name = &dentry->d_name;
224 unsigned int len = name->len;
225 unsigned int hash = name->hash;
226 const unsigned char *str = name->name;
227 struct list_head *p, *head;
228
229 spin_lock(&autofs4_lock);
230 spin_lock(&sbi->lookup_lock);
231 head = &sbi->expiring_list;
232 list_for_each(p, head) {
233 struct autofs_info *ino;
234 struct dentry *expiring;
235 struct qstr *qstr;
236
237 ino = list_entry(p, struct autofs_info, expiring);
238 expiring = ino->dentry;
239
240 spin_lock(&expiring->d_lock);
241
242
243 if (!expiring->d_inode)
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 spin_unlock(&autofs4_lock);
263 return expiring;
264 }
265next:
266 spin_unlock(&expiring->d_lock);
267 }
268 spin_unlock(&sbi->lookup_lock);
269 spin_unlock(&autofs4_lock);
270
271 return NULL;
272}
273
274static int autofs4_mount_wait(struct dentry *dentry)
275{
276 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
277 struct autofs_info *ino = autofs4_dentry_ino(dentry);
278 int status;
279
280 if (ino->flags & AUTOFS_INF_PENDING) {
281 DPRINTK("waiting for mount name=%.*s",
282 dentry->d_name.len, dentry->d_name.name);
283 status = autofs4_wait(sbi, dentry, NFY_MOUNT);
284 DPRINTK("mount wait done status=%d", status);
285 ino->last_used = jiffies;
286 return status;
287 }
288 return 0;
289}
290
291static int do_expire_wait(struct dentry *dentry)
292{
293 struct dentry *expiring;
294
295 expiring = autofs4_lookup_expiring(dentry);
296 if (!expiring)
297 return autofs4_expire_wait(dentry);
298 else {
299
300
301
302
303
304 autofs4_expire_wait(expiring);
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
318
319
320 if (autofs_type_indirect(sbi->type) && d_unhashed(dentry)) {
321 struct dentry *parent = dentry->d_parent;
322 struct dentry *new = d_lookup(parent, &dentry->d_name);
323 if (!new)
324 return NULL;
325 dput(path->dentry);
326 path->dentry = new;
327 }
328 return path->dentry;
329}
330
331static struct vfsmount *autofs4_d_automount(struct path *path)
332{
333 struct dentry *dentry = path->dentry;
334 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
335 struct autofs_info *ino = autofs4_dentry_ino(dentry);
336 int status;
337
338 DPRINTK("dentry=%p %.*s",
339 dentry, dentry->d_name.len, dentry->d_name.name);
340
341
342
343
344
345 spin_lock(&dentry->d_lock);
346 if (!d_mountpoint(dentry) && list_empty(&dentry->d_subdirs)) {
347 if (!(dentry->d_flags & DCACHE_MANAGE_TRANSIT) &&
348 (dentry->d_flags & DCACHE_NEED_AUTOMOUNT))
349 __managed_dentry_set_transit(path->dentry);
350 }
351 spin_unlock(&dentry->d_lock);
352
353
354 if (autofs4_oz_mode(sbi))
355 return NULL;
356
357
358
359
360
361
362
363
364
365 status = do_expire_wait(dentry);
366 if (status && status != -EAGAIN)
367 return NULL;
368
369
370 spin_lock(&sbi->fs_lock);
371 if (ino->flags & AUTOFS_INF_PENDING) {
372 spin_unlock(&sbi->fs_lock);
373 status = autofs4_mount_wait(dentry);
374 if (status)
375 return ERR_PTR(status);
376 spin_lock(&sbi->fs_lock);
377 goto done;
378 }
379
380
381
382
383
384
385 if (dentry->d_inode && S_ISLNK(dentry->d_inode->i_mode))
386 goto done;
387 if (!d_mountpoint(dentry)) {
388
389
390
391
392
393
394
395
396
397
398
399 if (sbi->version > 4) {
400 if (have_submounts(dentry))
401 goto done;
402 } else {
403 spin_lock(&dentry->d_lock);
404 if (!list_empty(&dentry->d_subdirs)) {
405 spin_unlock(&dentry->d_lock);
406 goto done;
407 }
408 spin_unlock(&dentry->d_lock);
409 }
410 ino->flags |= AUTOFS_INF_PENDING;
411 spin_unlock(&sbi->fs_lock);
412 status = autofs4_mount_wait(dentry);
413 if (status)
414 return ERR_PTR(status);
415 spin_lock(&sbi->fs_lock);
416 ino->flags &= ~AUTOFS_INF_PENDING;
417 }
418done:
419 if (!(ino->flags & AUTOFS_INF_EXPIRING)) {
420
421
422
423
424
425 spin_lock(&dentry->d_lock);
426 __managed_dentry_clear_transit(dentry);
427
428
429
430
431
432
433 if ((!d_mountpoint(dentry) &&
434 !list_empty(&dentry->d_subdirs)) ||
435 (dentry->d_inode && S_ISLNK(dentry->d_inode->i_mode)))
436 __managed_dentry_clear_automount(dentry);
437 spin_unlock(&dentry->d_lock);
438 }
439 spin_unlock(&sbi->fs_lock);
440
441
442 dentry = autofs4_mountpoint_changed(path);
443 if (!dentry)
444 return ERR_PTR(-ENOENT);
445
446 return NULL;
447}
448
449int autofs4_d_manage(struct dentry *dentry, bool mounting_here, bool rcu_walk)
450{
451 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
452
453 DPRINTK("dentry=%p %.*s",
454 dentry, dentry->d_name.len, dentry->d_name.name);
455
456
457 if (autofs4_oz_mode(sbi) || mounting_here) {
458 if (!d_mountpoint(dentry))
459 return -EISDIR;
460 return 0;
461 }
462
463
464 if (rcu_walk)
465 return -ECHILD;
466
467
468 do_expire_wait(dentry);
469
470
471
472
473
474 return autofs4_mount_wait(dentry);
475}
476
477
478static struct dentry *autofs4_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
479{
480 struct autofs_sb_info *sbi;
481 struct autofs_info *ino;
482 struct dentry *active;
483
484 DPRINTK("name = %.*s", dentry->d_name.len, dentry->d_name.name);
485
486
487 if (dentry->d_name.len > NAME_MAX)
488 return ERR_PTR(-ENAMETOOLONG);
489
490 sbi = autofs4_sbi(dir->i_sb);
491
492 DPRINTK("pid = %u, pgrp = %u, catatonic = %d, oz_mode = %d",
493 current->pid, task_pgrp_nr(current), sbi->catatonic,
494 autofs4_oz_mode(sbi));
495
496 active = autofs4_lookup_active(dentry);
497 if (active) {
498 return active;
499 } else {
500
501
502
503
504
505
506 if (!autofs4_oz_mode(sbi) && !IS_ROOT(dentry->d_parent))
507 return ERR_PTR(-ENOENT);
508
509
510 if (autofs_type_indirect(sbi->type) && IS_ROOT(dentry->d_parent))
511 __managed_dentry_set_managed(dentry);
512
513 ino = autofs4_new_ino(sbi);
514 if (!ino)
515 return ERR_PTR(-ENOMEM);
516
517 dentry->d_fsdata = ino;
518 ino->dentry = dentry;
519
520 autofs4_add_active(dentry);
521
522 d_instantiate(dentry, NULL);
523 }
524 return NULL;
525}
526
527static int autofs4_dir_symlink(struct inode *dir,
528 struct dentry *dentry,
529 const char *symname)
530{
531 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
532 struct autofs_info *ino = autofs4_dentry_ino(dentry);
533 struct autofs_info *p_ino;
534 struct inode *inode;
535 size_t size = strlen(symname);
536 char *cp;
537
538 DPRINTK("%s <- %.*s", symname,
539 dentry->d_name.len, dentry->d_name.name);
540
541 if (!autofs4_oz_mode(sbi))
542 return -EACCES;
543
544 BUG_ON(!ino);
545
546 autofs4_clean_ino(ino);
547
548 autofs4_del_active(dentry);
549
550 cp = kmalloc(size + 1, GFP_KERNEL);
551 if (!cp)
552 return -ENOMEM;
553
554 strcpy(cp, symname);
555
556 inode = autofs4_get_inode(dir->i_sb, S_IFLNK | 0555);
557 if (!inode) {
558 kfree(cp);
559 if (!dentry->d_fsdata)
560 kfree(ino);
561 return -ENOMEM;
562 }
563 inode->i_private = cp;
564 inode->i_size = size;
565 d_add(dentry, inode);
566
567 dget(dentry);
568 atomic_inc(&ino->count);
569 p_ino = autofs4_dentry_ino(dentry->d_parent);
570 if (p_ino && dentry->d_parent != dentry)
571 atomic_inc(&p_ino->count);
572
573 dir->i_mtime = CURRENT_TIME;
574
575 return 0;
576}
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593static int autofs4_dir_unlink(struct inode *dir, struct dentry *dentry)
594{
595 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
596 struct autofs_info *ino = autofs4_dentry_ino(dentry);
597 struct autofs_info *p_ino;
598
599
600 if (!autofs4_oz_mode(sbi) && !capable(CAP_SYS_ADMIN))
601 return -EACCES;
602
603 if (atomic_dec_and_test(&ino->count)) {
604 p_ino = autofs4_dentry_ino(dentry->d_parent);
605 if (p_ino && dentry->d_parent != dentry)
606 atomic_dec(&p_ino->count);
607 }
608 dput(ino->dentry);
609
610 dentry->d_inode->i_size = 0;
611 clear_nlink(dentry->d_inode);
612
613 dir->i_mtime = CURRENT_TIME;
614
615 spin_lock(&autofs4_lock);
616 autofs4_add_expiring(dentry);
617 spin_lock(&dentry->d_lock);
618 __d_drop(dentry);
619 spin_unlock(&dentry->d_lock);
620 spin_unlock(&autofs4_lock);
621
622 return 0;
623}
624
625
626
627
628
629
630
631
632
633
634
635
636static void autofs_set_leaf_automount_flags(struct dentry *dentry)
637{
638 struct dentry *parent;
639
640
641 if (IS_ROOT(dentry->d_parent))
642 return;
643
644 managed_dentry_set_managed(dentry);
645
646 parent = dentry->d_parent;
647
648 if (IS_ROOT(parent->d_parent))
649 return;
650 managed_dentry_clear_managed(parent);
651 return;
652}
653
654static void autofs_clear_leaf_automount_flags(struct dentry *dentry)
655{
656 struct list_head *d_child;
657 struct dentry *parent;
658
659
660 if (IS_ROOT(dentry->d_parent))
661 return;
662
663 managed_dentry_clear_managed(dentry);
664
665 parent = dentry->d_parent;
666
667 if (IS_ROOT(parent->d_parent))
668 return;
669 d_child = &dentry->d_u.d_child;
670
671 if (d_child->next == &parent->d_subdirs &&
672 d_child->prev == &parent->d_subdirs)
673 managed_dentry_set_managed(parent);
674 return;
675}
676
677static int autofs4_dir_rmdir(struct inode *dir, struct dentry *dentry)
678{
679 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
680 struct autofs_info *ino = autofs4_dentry_ino(dentry);
681 struct autofs_info *p_ino;
682
683 DPRINTK("dentry %p, removing %.*s",
684 dentry, dentry->d_name.len, dentry->d_name.name);
685
686 if (!autofs4_oz_mode(sbi))
687 return -EACCES;
688
689 spin_lock(&autofs4_lock);
690 spin_lock(&sbi->lookup_lock);
691 spin_lock(&dentry->d_lock);
692 if (!list_empty(&dentry->d_subdirs)) {
693 spin_unlock(&dentry->d_lock);
694 spin_unlock(&sbi->lookup_lock);
695 spin_unlock(&autofs4_lock);
696 return -ENOTEMPTY;
697 }
698 __autofs4_add_expiring(dentry);
699 spin_unlock(&sbi->lookup_lock);
700 __d_drop(dentry);
701 spin_unlock(&dentry->d_lock);
702 spin_unlock(&autofs4_lock);
703
704 if (sbi->version < 5)
705 autofs_clear_leaf_automount_flags(dentry);
706
707 if (atomic_dec_and_test(&ino->count)) {
708 p_ino = autofs4_dentry_ino(dentry->d_parent);
709 if (p_ino && dentry->d_parent != dentry)
710 atomic_dec(&p_ino->count);
711 }
712 dput(ino->dentry);
713 dentry->d_inode->i_size = 0;
714 clear_nlink(dentry->d_inode);
715
716 if (dir->i_nlink)
717 drop_nlink(dir);
718
719 return 0;
720}
721
722static int autofs4_dir_mkdir(struct inode *dir, struct dentry *dentry, int mode)
723{
724 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
725 struct autofs_info *ino = autofs4_dentry_ino(dentry);
726 struct autofs_info *p_ino;
727 struct inode *inode;
728
729 if (!autofs4_oz_mode(sbi))
730 return -EACCES;
731
732 DPRINTK("dentry %p, creating %.*s",
733 dentry, dentry->d_name.len, dentry->d_name.name);
734
735 BUG_ON(!ino);
736
737 autofs4_clean_ino(ino);
738
739 autofs4_del_active(dentry);
740
741 inode = autofs4_get_inode(dir->i_sb, S_IFDIR | 0555);
742 if (!inode)
743 return -ENOMEM;
744 d_add(dentry, inode);
745
746 if (sbi->version < 5)
747 autofs_set_leaf_automount_flags(dentry);
748
749 dget(dentry);
750 atomic_inc(&ino->count);
751 p_ino = autofs4_dentry_ino(dentry->d_parent);
752 if (p_ino && dentry->d_parent != dentry)
753 atomic_inc(&p_ino->count);
754 inc_nlink(dir);
755 dir->i_mtime = CURRENT_TIME;
756
757 return 0;
758}
759
760
761#ifdef CONFIG_COMPAT
762static inline int autofs4_compat_get_set_timeout(struct autofs_sb_info *sbi,
763 compat_ulong_t __user *p)
764{
765 int rv;
766 unsigned long ntimeout;
767
768 if ((rv = get_user(ntimeout, p)) ||
769 (rv = put_user(sbi->exp_timeout/HZ, p)))
770 return rv;
771
772 if (ntimeout > UINT_MAX/HZ)
773 sbi->exp_timeout = 0;
774 else
775 sbi->exp_timeout = ntimeout * HZ;
776
777 return 0;
778}
779#endif
780
781static inline int autofs4_get_set_timeout(struct autofs_sb_info *sbi,
782 unsigned long __user *p)
783{
784 int rv;
785 unsigned long ntimeout;
786
787 if ((rv = get_user(ntimeout, p)) ||
788 (rv = put_user(sbi->exp_timeout/HZ, p)))
789 return rv;
790
791 if (ntimeout > ULONG_MAX/HZ)
792 sbi->exp_timeout = 0;
793 else
794 sbi->exp_timeout = ntimeout * HZ;
795
796 return 0;
797}
798
799
800static inline int autofs4_get_protover(struct autofs_sb_info *sbi, int __user *p)
801{
802 return put_user(sbi->version, p);
803}
804
805
806static inline int autofs4_get_protosubver(struct autofs_sb_info *sbi, int __user *p)
807{
808 return put_user(sbi->sub_version, p);
809}
810
811
812
813
814static inline int autofs4_ask_umount(struct vfsmount *mnt, int __user *p)
815{
816 int status = 0;
817
818 if (may_umount(mnt))
819 status = 1;
820
821 DPRINTK("returning %d", status);
822
823 status = put_user(status, p);
824
825 return status;
826}
827
828
829
830
831
832int is_autofs4_dentry(struct dentry *dentry)
833{
834 return dentry && dentry->d_inode &&
835 dentry->d_op == &autofs4_dentry_operations &&
836 dentry->d_fsdata != NULL;
837}
838
839
840
841
842
843static int autofs4_root_ioctl_unlocked(struct inode *inode, struct file *filp,
844 unsigned int cmd, unsigned long arg)
845{
846 struct autofs_sb_info *sbi = autofs4_sbi(inode->i_sb);
847 void __user *p = (void __user *)arg;
848
849 DPRINTK("cmd = 0x%08x, arg = 0x%08lx, sbi = %p, pgrp = %u",
850 cmd,arg,sbi,task_pgrp_nr(current));
851
852 if (_IOC_TYPE(cmd) != _IOC_TYPE(AUTOFS_IOC_FIRST) ||
853 _IOC_NR(cmd) - _IOC_NR(AUTOFS_IOC_FIRST) >= AUTOFS_IOC_COUNT)
854 return -ENOTTY;
855
856 if (!autofs4_oz_mode(sbi) && !capable(CAP_SYS_ADMIN))
857 return -EPERM;
858
859 switch(cmd) {
860 case AUTOFS_IOC_READY:
861 return autofs4_wait_release(sbi,(autofs_wqt_t)arg,0);
862 case AUTOFS_IOC_FAIL:
863 return autofs4_wait_release(sbi,(autofs_wqt_t)arg,-ENOENT);
864 case AUTOFS_IOC_CATATONIC:
865 autofs4_catatonic_mode(sbi);
866 return 0;
867 case AUTOFS_IOC_PROTOVER:
868 return autofs4_get_protover(sbi, p);
869 case AUTOFS_IOC_PROTOSUBVER:
870 return autofs4_get_protosubver(sbi, p);
871 case AUTOFS_IOC_SETTIMEOUT:
872 return autofs4_get_set_timeout(sbi, p);
873#ifdef CONFIG_COMPAT
874 case AUTOFS_IOC_SETTIMEOUT32:
875 return autofs4_compat_get_set_timeout(sbi, p);
876#endif
877
878 case AUTOFS_IOC_ASKUMOUNT:
879 return autofs4_ask_umount(filp->f_path.mnt, p);
880
881
882 case AUTOFS_IOC_EXPIRE:
883 return autofs4_expire_run(inode->i_sb,filp->f_path.mnt,sbi, p);
884
885 case AUTOFS_IOC_EXPIRE_MULTI:
886 return autofs4_expire_multi(inode->i_sb,filp->f_path.mnt,sbi, p);
887
888 default:
889 return -ENOSYS;
890 }
891}
892
893static long autofs4_root_ioctl(struct file *filp,
894 unsigned int cmd, unsigned long arg)
895{
896 struct inode *inode = filp->f_dentry->d_inode;
897 return autofs4_root_ioctl_unlocked(inode, filp, cmd, arg);
898}
899
900#ifdef CONFIG_COMPAT
901static long autofs4_root_compat_ioctl(struct file *filp,
902 unsigned int cmd, unsigned long arg)
903{
904 struct inode *inode = filp->f_path.dentry->d_inode;
905 int ret;
906
907 if (cmd == AUTOFS_IOC_READY || cmd == AUTOFS_IOC_FAIL)
908 ret = autofs4_root_ioctl_unlocked(inode, filp, cmd, arg);
909 else
910 ret = autofs4_root_ioctl_unlocked(inode, filp, cmd,
911 (unsigned long)compat_ptr(arg));
912
913 return ret;
914}
915#endif
916