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