root.c 23.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
6
/* -*- c -*- --------------------------------------------------------------- *
 *
 * linux/fs/autofs/root.c
 *
 *  Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
 *  Copyright 1999-2000 Jeremy Fitzhardinge <jeremy@goop.org>
7
 *  Copyright 2001-2006 Ian Kent <raven@themaw.net>
Linus Torvalds's avatar
Linus Torvalds committed
8
9
10
11
12
13
14
 *
 * This file is part of the Linux kernel and is made available under
 * the terms of the GNU General Public License, version 2, or at your
 * option, any later version, incorporated herein by reference.
 *
 * ------------------------------------------------------------------------- */

15
#include <linux/capability.h>
Linus Torvalds's avatar
Linus Torvalds committed
16
17
#include <linux/errno.h>
#include <linux/stat.h>
18
#include <linux/slab.h>
Linus Torvalds's avatar
Linus Torvalds committed
19
20
#include <linux/param.h>
#include <linux/time.h>
21
#include <linux/compat.h>
Arnd Bergmann's avatar
Arnd Bergmann committed
22
#include <linux/mutex.h>
23

Linus Torvalds's avatar
Linus Torvalds committed
24
25
26
27
28
#include "autofs_i.h"

static int autofs4_dir_symlink(struct inode *,struct dentry *,const char *);
static int autofs4_dir_unlink(struct inode *,struct dentry *);
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
Linus Torvalds's avatar
Linus Torvalds committed
34
static int autofs4_dir_open(struct inode *inode, struct file *file);
Al Viro's avatar
Al Viro committed
35
static struct dentry *autofs4_lookup(struct inode *,struct dentry *, unsigned int);
Ian Kent's avatar
Ian Kent committed
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 *);
Linus Torvalds's avatar
Linus Torvalds committed
39

40
const struct file_operations autofs4_root_operations = {
Linus Torvalds's avatar
Linus Torvalds committed
41
42
43
	.open		= dcache_dir_open,
	.release	= dcache_dir_close,
	.read		= generic_read_dir,
44
	.iterate	= dcache_readdir,
45
	.llseek		= dcache_dir_lseek,
46
	.unlocked_ioctl	= autofs4_root_ioctl,
47
48
49
#ifdef CONFIG_COMPAT
	.compat_ioctl	= autofs4_root_compat_ioctl,
#endif
Linus Torvalds's avatar
Linus Torvalds committed
50
51
};

52
const struct file_operations autofs4_dir_operations = {
Linus Torvalds's avatar
Linus Torvalds committed
53
	.open		= autofs4_dir_open,
54
	.release	= dcache_dir_close,
Linus Torvalds's avatar
Linus Torvalds committed
55
	.read		= generic_read_dir,
56
	.iterate	= dcache_readdir,
57
	.llseek		= dcache_dir_lseek,
Linus Torvalds's avatar
Linus Torvalds committed
58
59
};

60
const struct inode_operations autofs4_dir_inode_operations = {
Linus Torvalds's avatar
Linus Torvalds committed
61
62
63
64
65
66
67
	.lookup		= autofs4_lookup,
	.unlink		= autofs4_dir_unlink,
	.symlink	= autofs4_dir_symlink,
	.mkdir		= autofs4_dir_mkdir,
	.rmdir		= autofs4_dir_rmdir,
};

Ian Kent's avatar
Ian Kent committed
68
69
70
71
72
73
const struct dentry_operations autofs4_dentry_operations = {
	.d_automount	= autofs4_d_automount,
	.d_manage	= autofs4_d_manage,
	.d_release	= autofs4_dentry_release,
};

74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
static void autofs4_add_active(struct dentry *dentry)
{
	struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
	struct autofs_info *ino = autofs4_dentry_ino(dentry);
	if (ino) {
		spin_lock(&sbi->lookup_lock);
		if (!ino->active_count) {
			if (list_empty(&ino->active))
				list_add(&ino->active, &sbi->active_list);
		}
		ino->active_count++;
		spin_unlock(&sbi->lookup_lock);
	}
	return;
}

static void autofs4_del_active(struct dentry *dentry)
{
	struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
	struct autofs_info *ino = autofs4_dentry_ino(dentry);
	if (ino) {
		spin_lock(&sbi->lookup_lock);
		ino->active_count--;
		if (!ino->active_count) {
			if (!list_empty(&ino->active))
				list_del_init(&ino->active);
		}
		spin_unlock(&sbi->lookup_lock);
	}
	return;
}

Linus Torvalds's avatar
Linus Torvalds committed
106
107
static int autofs4_dir_open(struct inode *inode, struct file *file)
{
108
	struct dentry *dentry = file->f_path.dentry;
Linus Torvalds's avatar
Linus Torvalds committed
109
	struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
110

Linus Torvalds's avatar
Linus Torvalds committed
111
112
113
114
115
116
	DPRINTK("file=%p dentry=%p %.*s",
		file, dentry, dentry->d_name.len, dentry->d_name.name);

	if (autofs4_oz_mode(sbi))
		goto out;

117
118
119
120
121
122
123
124
125
	/*
	 * An empty directory in an autofs file system is always a
	 * mount point. The daemon must have failed to mount this
	 * during lookup so it doesn't exist. This can happen, for
	 * example, if user space returns an incorrect status for a
	 * mount request. Otherwise we're doing a readdir on the
	 * autofs file system so just let the libfs routines handle
	 * it.
	 */
Ian Kent's avatar
Ian Kent committed
126
	spin_lock(&sbi->lookup_lock);
127
	if (!d_mountpoint(dentry) && simple_empty(dentry)) {
Ian Kent's avatar
Ian Kent committed
128
		spin_unlock(&sbi->lookup_lock);
129
		return -ENOENT;
Linus Torvalds's avatar
Linus Torvalds committed
130
	}
Ian Kent's avatar
Ian Kent committed
131
	spin_unlock(&sbi->lookup_lock);
Linus Torvalds's avatar
Linus Torvalds committed
132
133

out:
134
	return dcache_dir_open(inode, file);
Linus Torvalds's avatar
Linus Torvalds committed
135
136
}

137
static void autofs4_dentry_release(struct dentry *de)
Linus Torvalds's avatar
Linus Torvalds committed
138
{
139
140
	struct autofs_info *ino = autofs4_dentry_ino(de);
	struct autofs_sb_info *sbi = autofs4_sbi(de->d_sb);
Linus Torvalds's avatar
Linus Torvalds committed
141
142
143

	DPRINTK("releasing %p", de);

144
145
146
147
148
149
150
151
152
153
	if (!ino)
		return;

	if (sbi) {
		spin_lock(&sbi->lookup_lock);
		if (!list_empty(&ino->active))
			list_del(&ino->active);
		if (!list_empty(&ino->expiring))
			list_del(&ino->expiring);
		spin_unlock(&sbi->lookup_lock);
Linus Torvalds's avatar
Linus Torvalds committed
154
	}
155
156

	autofs4_free_ino(ino);
Linus Torvalds's avatar
Linus Torvalds committed
157
158
}

159
static struct dentry *autofs4_lookup_active(struct dentry *dentry)
160
{
161
162
163
	struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
	struct dentry *parent = dentry->d_parent;
	struct qstr *name = &dentry->d_name;
164
165
166
167
168
169
170
171
172
	unsigned int len = name->len;
	unsigned int hash = name->hash;
	const unsigned char *str = name->name;
	struct list_head *p, *head;

	spin_lock(&sbi->lookup_lock);
	head = &sbi->active_list;
	list_for_each(p, head) {
		struct autofs_info *ino;
173
		struct dentry *active;
174
175
176
		struct qstr *qstr;

		ino = list_entry(p, struct autofs_info, active);
177
		active = ino->dentry;
178

179
		spin_lock(&active->d_lock);
180
181

		/* Already gone? */
Ian Kent's avatar
Ian Kent committed
182
		if ((int) d_count(active) <= 0)
183
184
			goto next;

185
		qstr = &active->d_name;
186

187
		if (active->d_name.hash != hash)
188
			goto next;
189
		if (active->d_parent != parent)
190
191
192
193
194
195
196
			goto next;

		if (qstr->len != len)
			goto next;
		if (memcmp(qstr->name, str, len))
			goto next;

197
		if (d_unhashed(active)) {
Nick Piggin's avatar
Nick Piggin committed
198
			dget_dlock(active);
199
200
201
202
			spin_unlock(&active->d_lock);
			spin_unlock(&sbi->lookup_lock);
			return active;
		}
203
next:
204
		spin_unlock(&active->d_lock);
205
206
207
208
209
210
	}
	spin_unlock(&sbi->lookup_lock);

	return NULL;
}

211
static struct dentry *autofs4_lookup_expiring(struct dentry *dentry)
212
{
213
214
215
	struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
	struct dentry *parent = dentry->d_parent;
	struct qstr *name = &dentry->d_name;
216
217
218
219
220
	unsigned int len = name->len;
	unsigned int hash = name->hash;
	const unsigned char *str = name->name;
	struct list_head *p, *head;

221
222
	spin_lock(&sbi->lookup_lock);
	head = &sbi->expiring_list;
223
224
	list_for_each(p, head) {
		struct autofs_info *ino;
225
		struct dentry *expiring;
226
227
		struct qstr *qstr;

228
		ino = list_entry(p, struct autofs_info, expiring);
229
		expiring = ino->dentry;
230

231
		spin_lock(&expiring->d_lock);
232

Ian Kent's avatar
Ian Kent committed
233
		/* We've already been dentry_iput or unlinked */
234
		if (!expiring->d_inode)
235
236
			goto next;

237
		qstr = &expiring->d_name;
238

239
		if (expiring->d_name.hash != hash)
240
			goto next;
241
		if (expiring->d_parent != parent)
242
243
244
245
246
247
248
			goto next;

		if (qstr->len != len)
			goto next;
		if (memcmp(qstr->name, str, len))
			goto next;

249
		if (d_unhashed(expiring)) {
Nick Piggin's avatar
Nick Piggin committed
250
			dget_dlock(expiring);
251
252
253
254
			spin_unlock(&expiring->d_lock);
			spin_unlock(&sbi->lookup_lock);
			return expiring;
		}
255
next:
256
		spin_unlock(&expiring->d_lock);
257
	}
258
	spin_unlock(&sbi->lookup_lock);
259
260
261
262

	return NULL;
}

263
264
265
266
static int autofs4_mount_wait(struct dentry *dentry)
{
	struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
	struct autofs_info *ino = autofs4_dentry_ino(dentry);
267
	int status = 0;
268
269
270
271
272
273
274

	if (ino->flags & AUTOFS_INF_PENDING) {
		DPRINTK("waiting for mount name=%.*s",
			dentry->d_name.len, dentry->d_name.name);
		status = autofs4_wait(sbi, dentry, NFY_MOUNT);
		DPRINTK("mount wait done status=%d", status);
	}
275
276
	ino->last_used = jiffies;
	return status;
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
}

static int do_expire_wait(struct dentry *dentry)
{
	struct dentry *expiring;

	expiring = autofs4_lookup_expiring(dentry);
	if (!expiring)
		return autofs4_expire_wait(dentry);
	else {
		/*
		 * If we are racing with expire the request might not
		 * be quite complete, but the directory has been removed
		 * so it must have been successful, just wait for it.
		 */
		autofs4_expire_wait(expiring);
		autofs4_del_expiring(expiring);
		dput(expiring);
	}
	return 0;
}

static struct dentry *autofs4_mountpoint_changed(struct path *path)
{
	struct dentry *dentry = path->dentry;
	struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);

	/*
	 * If this is an indirect mount the dentry could have gone away
	 * as a result of an expire and a new one created.
	 */
	if (autofs_type_indirect(sbi->type) && d_unhashed(dentry)) {
		struct dentry *parent = dentry->d_parent;
310
		struct autofs_info *ino;
311
312
313
		struct dentry *new = d_lookup(parent, &dentry->d_name);
		if (!new)
			return NULL;
314
315
		ino = autofs4_dentry_ino(new);
		ino->last_used = jiffies;
316
317
318
319
320
321
		dput(path->dentry);
		path->dentry = new;
	}
	return path->dentry;
}

Ian Kent's avatar
Ian Kent committed
322
static struct vfsmount *autofs4_d_automount(struct path *path)
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
{
	struct dentry *dentry = path->dentry;
	struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
	struct autofs_info *ino = autofs4_dentry_ino(dentry);
	int status;

	DPRINTK("dentry=%p %.*s",
		dentry, dentry->d_name.len, dentry->d_name.name);

	/* The daemon never triggers a mount. */
	if (autofs4_oz_mode(sbi))
		return NULL;

	/*
	 * If an expire request is pending everyone must wait.
	 * If the expire fails we're still mounted so continue
	 * the follow and return. A return of -EAGAIN (which only
	 * happens with indirect mounts) means the expire completed
	 * and the directory was removed, so just go ahead and try
	 * the mount.
	 */
	status = do_expire_wait(dentry);
	if (status && status != -EAGAIN)
		return NULL;

	/* Callback to the daemon to perform the mount or wait */
	spin_lock(&sbi->fs_lock);
	if (ino->flags & AUTOFS_INF_PENDING) {
		spin_unlock(&sbi->fs_lock);
		status = autofs4_mount_wait(dentry);
		if (status)
			return ERR_PTR(status);
		goto done;
	}

	/*
	 * If the dentry is a symlink it's equivalent to a directory
360
	 * having d_mountpoint() true, so there's no need to call back
361
362
	 * to the daemon.
	 */
363
364
	if (dentry->d_inode && S_ISLNK(dentry->d_inode->i_mode)) {
		spin_unlock(&sbi->fs_lock);
365
		goto done;
366
367
	}

368
369
370
371
372
373
374
375
376
377
378
379
380
	if (!d_mountpoint(dentry)) {
		/*
		 * It's possible that user space hasn't removed directories
		 * after umounting a rootless multi-mount, although it
		 * should. For v5 have_submounts() is sufficient to handle
		 * this because the leaves of the directory tree under the
		 * mount never trigger mounts themselves (they have an autofs
		 * trigger mount mounted on them). But v4 pseudo direct mounts
		 * do need the leaves to to trigger mounts. In this case we
		 * have no choice but to use the list_empty() check and
		 * require user space behave.
		 */
		if (sbi->version > 4) {
381
382
			if (have_submounts(dentry)) {
				spin_unlock(&sbi->fs_lock);
383
				goto done;
384
			}
385
		} else {
386
387
			if (!simple_empty(dentry)) {
				spin_unlock(&sbi->fs_lock);
388
				goto done;
389
			}
390
		}
391
392
393
394
395
		ino->flags |= AUTOFS_INF_PENDING;
		spin_unlock(&sbi->fs_lock);
		status = autofs4_mount_wait(dentry);
		spin_lock(&sbi->fs_lock);
		ino->flags &= ~AUTOFS_INF_PENDING;
396
397
398
399
		if (status) {
			spin_unlock(&sbi->fs_lock);
			return ERR_PTR(status);
		}
400
401
	}
	spin_unlock(&sbi->fs_lock);
402
done:
403
404
405
406
407
408
409
410
	/* Mount succeeded, check if we ended up with a new dentry */
	dentry = autofs4_mountpoint_changed(path);
	if (!dentry)
		return ERR_PTR(-ENOENT);

	return NULL;
}

411
static int autofs4_d_manage(struct dentry *dentry, bool rcu_walk)
412
413
{
	struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
414
415
	struct autofs_info *ino = autofs4_dentry_ino(dentry);
	int status;
416
417
418
419
420

	DPRINTK("dentry=%p %.*s",
		dentry, dentry->d_name.len, dentry->d_name.name);

	/* The daemon never waits. */
421
	if (autofs4_oz_mode(sbi)) {
422
423
		if (rcu_walk)
			return 0;
424
425
426
427
428
		if (!d_mountpoint(dentry))
			return -EISDIR;
		return 0;
	}

429
430
431
432
	/* We need to sleep, so we need pathwalk to be in ref-mode */
	if (rcu_walk)
		return -ECHILD;

433
434
435
436
437
438
439
	/* Wait for pending expires */
	do_expire_wait(dentry);

	/*
	 * This dentry may be under construction so wait on mount
	 * completion.
	 */
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
	status = autofs4_mount_wait(dentry);
	if (status)
		return status;

	spin_lock(&sbi->fs_lock);
	/*
	 * If the dentry has been selected for expire while we slept
	 * on the lock then it might go away. We'll deal with that in
	 * ->d_automount() and wait on a new mount if the expire
	 * succeeds or return here if it doesn't (since there's no
	 * mount to follow with a rootless multi-mount).
	 */
	if (!(ino->flags & AUTOFS_INF_EXPIRING)) {
		/*
		 * Any needed mounting has been completed and the path
		 * updated so check if this is a rootless multi-mount so
		 * we can avoid needless calls ->d_automount() and avoid
		 * an incorrect ELOOP error return.
		 */
		if ((!d_mountpoint(dentry) && !simple_empty(dentry)) ||
		    (dentry->d_inode && S_ISLNK(dentry->d_inode->i_mode)))
			status = -EISDIR;
	}
	spin_unlock(&sbi->fs_lock);

	return status;
466
467
}

Linus Torvalds's avatar
Linus Torvalds committed
468
/* Lookups in the root directory */
Al Viro's avatar
Al Viro committed
469
static struct dentry *autofs4_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
Linus Torvalds's avatar
Linus Torvalds committed
470
471
{
	struct autofs_sb_info *sbi;
472
	struct autofs_info *ino;
473
	struct dentry *active;
Linus Torvalds's avatar
Linus Torvalds committed
474

475
	DPRINTK("name = %.*s", dentry->d_name.len, dentry->d_name.name);
Linus Torvalds's avatar
Linus Torvalds committed
476

477
	/* File name too long to exist */
Linus Torvalds's avatar
Linus Torvalds committed
478
	if (dentry->d_name.len > NAME_MAX)
479
		return ERR_PTR(-ENAMETOOLONG);
Linus Torvalds's avatar
Linus Torvalds committed
480
481

	sbi = autofs4_sbi(dir->i_sb);
482

Linus Torvalds's avatar
Linus Torvalds committed
483
	DPRINTK("pid = %u, pgrp = %u, catatonic = %d, oz_mode = %d",
484
485
		current->pid, task_pgrp_nr(current), sbi->catatonic,
		autofs4_oz_mode(sbi));
Linus Torvalds's avatar
Linus Torvalds committed
486

487
	active = autofs4_lookup_active(dentry);
488
	if (active) {
489
		return active;
490
	} else {
491
		/*
492
493
494
495
		 * A dentry that is not within the root can never trigger a
		 * mount operation, unless the directory already exists, so we
		 * can return fail immediately.  The daemon however does need
		 * to create directories within the file system.
496
		 */
497
498
499
500
		if (!autofs4_oz_mode(sbi) && !IS_ROOT(dentry->d_parent))
			return ERR_PTR(-ENOENT);

		/* Mark entries in the root as mount triggers */
501
		if (autofs_type_indirect(sbi->type) && IS_ROOT(dentry->d_parent))
502
			__managed_dentry_set_managed(dentry);
503

Al Viro's avatar
Al Viro committed
504
		ino = autofs4_new_ino(sbi);
505
506
507
508
509
		if (!ino)
			return ERR_PTR(-ENOMEM);

		dentry->d_fsdata = ino;
		ino->dentry = dentry;
510

511
512
513
514
		autofs4_add_active(dentry);

		d_instantiate(dentry, NULL);
	}
Linus Torvalds's avatar
Linus Torvalds committed
515
516
517
518
519
520
521
522
523
	return NULL;
}

static int autofs4_dir_symlink(struct inode *dir, 
			       struct dentry *dentry,
			       const char *symname)
{
	struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
	struct autofs_info *ino = autofs4_dentry_ino(dentry);
524
	struct autofs_info *p_ino;
Linus Torvalds's avatar
Linus Torvalds committed
525
	struct inode *inode;
Al Viro's avatar
Al Viro committed
526
	size_t size = strlen(symname);
Linus Torvalds's avatar
Linus Torvalds committed
527
528
529
530
531
532
533
534
	char *cp;

	DPRINTK("%s <- %.*s", symname,
		dentry->d_name.len, dentry->d_name.name);

	if (!autofs4_oz_mode(sbi))
		return -EACCES;

535
536
	BUG_ON(!ino);

Al Viro's avatar
Al Viro committed
537
	autofs4_clean_ino(ino);
Linus Torvalds's avatar
Linus Torvalds committed
538

539
540
	autofs4_del_active(dentry);

Al Viro's avatar
Al Viro committed
541
	cp = kmalloc(size + 1, GFP_KERNEL);
542
	if (!cp)
543
		return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
544
545
546

	strcpy(cp, symname);

547
	inode = autofs4_get_inode(dir->i_sb, S_IFLNK | 0555);
548
549
550
551
552
553
	if (!inode) {
		kfree(cp);
		if (!dentry->d_fsdata)
			kfree(ino);
		return -ENOMEM;
	}
554
	inode->i_private = cp;
Al Viro's avatar
Al Viro committed
555
	inode->i_size = size;
Ian Kent's avatar
Ian Kent committed
556
	d_add(dentry, inode);
Linus Torvalds's avatar
Linus Torvalds committed
557

558
	dget(dentry);
559
560
	atomic_inc(&ino->count);
	p_ino = autofs4_dentry_ino(dentry->d_parent);
561
	if (p_ino && !IS_ROOT(dentry))
562
		atomic_inc(&p_ino->count);
Linus Torvalds's avatar
Linus Torvalds committed
563
564
565
566
567
568
569
570
571
572
573
574

	dir->i_mtime = CURRENT_TIME;

	return 0;
}

/*
 * NOTE!
 *
 * Normal filesystems would do a "d_delete()" to tell the VFS dcache
 * that the file no longer exists. However, doing that means that the
 * VFS layer can turn the dentry into a negative dentry.  We don't want
575
 * this, because the unlink is probably the result of an expire.
576
577
 * We simply d_drop it and add it to a expiring list in the super block,
 * which allows the dentry lookup to check for an incomplete expire.
Linus Torvalds's avatar
Linus Torvalds committed
578
579
580
581
582
583
584
585
586
587
 *
 * If a process is blocked on the dentry waiting for the expire to finish,
 * it will invalidate the dentry and try to mount with a new one.
 *
 * Also see autofs4_dir_rmdir()..
 */
static int autofs4_dir_unlink(struct inode *dir, struct dentry *dentry)
{
	struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
	struct autofs_info *ino = autofs4_dentry_ino(dentry);
588
	struct autofs_info *p_ino;
Linus Torvalds's avatar
Linus Torvalds committed
589
590
	
	/* This allows root to remove symlinks */
591
	if (!autofs4_oz_mode(sbi) && !capable(CAP_SYS_ADMIN))
592
		return -EPERM;
Linus Torvalds's avatar
Linus Torvalds committed
593

594
595
	if (atomic_dec_and_test(&ino->count)) {
		p_ino = autofs4_dentry_ino(dentry->d_parent);
596
		if (p_ino && !IS_ROOT(dentry))
597
598
			atomic_dec(&p_ino->count);
	}
Linus Torvalds's avatar
Linus Torvalds committed
599
600
601
	dput(ino->dentry);

	dentry->d_inode->i_size = 0;
602
	clear_nlink(dentry->d_inode);
Linus Torvalds's avatar
Linus Torvalds committed
603
604
605

	dir->i_mtime = CURRENT_TIME;

Ian Kent's avatar
Ian Kent committed
606
607
	spin_lock(&sbi->lookup_lock);
	__autofs4_add_expiring(dentry);
608
	d_drop(dentry);
Ian Kent's avatar
Ian Kent committed
609
	spin_unlock(&sbi->lookup_lock);
Linus Torvalds's avatar
Linus Torvalds committed
610
611
612
613

	return 0;
}

614
615
616
617
618
619
620
/*
 * Version 4 of autofs provides a pseudo direct mount implementation
 * that relies on directories at the leaves of a directory tree under
 * an indirect mount to trigger mounts. To allow for this we need to
 * set the DMANAGED_AUTOMOUNT and DMANAGED_TRANSIT flags on the leaves
 * of the directory tree. There is no need to clear the automount flag
 * following a mount or restore it after an expire because these mounts
Lucas De Marchi's avatar
Lucas De Marchi committed
621
 * are always covered. However, it is necessary to ensure that these
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
 * flags are clear on non-empty directories to avoid unnecessary calls
 * during path walks.
 */
static void autofs_set_leaf_automount_flags(struct dentry *dentry)
{
	struct dentry *parent;

	/* root and dentrys in the root are already handled */
	if (IS_ROOT(dentry->d_parent))
		return;

	managed_dentry_set_managed(dentry);

	parent = dentry->d_parent;
	/* only consider parents below dentrys in the root */
	if (IS_ROOT(parent->d_parent))
		return;
	managed_dentry_clear_managed(parent);
	return;
}

static void autofs_clear_leaf_automount_flags(struct dentry *dentry)
{
	struct list_head *d_child;
	struct dentry *parent;

	/* flags for dentrys in the root are handled elsewhere */
	if (IS_ROOT(dentry->d_parent))
		return;

	managed_dentry_clear_managed(dentry);

	parent = dentry->d_parent;
	/* only consider parents below dentrys in the root */
	if (IS_ROOT(parent->d_parent))
		return;
	d_child = &dentry->d_u.d_child;
	/* Set parent managed if it's becoming empty */
	if (d_child->next == &parent->d_subdirs &&
	    d_child->prev == &parent->d_subdirs)
		managed_dentry_set_managed(parent);
	return;
}

Linus Torvalds's avatar
Linus Torvalds committed
666
667
668
669
static int autofs4_dir_rmdir(struct inode *dir, struct dentry *dentry)
{
	struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
	struct autofs_info *ino = autofs4_dentry_ino(dentry);
670
	struct autofs_info *p_ino;
Linus Torvalds's avatar
Linus Torvalds committed
671
	
672
673
674
	DPRINTK("dentry %p, removing %.*s",
		dentry, dentry->d_name.len, dentry->d_name.name);

Linus Torvalds's avatar
Linus Torvalds committed
675
676
677
	if (!autofs4_oz_mode(sbi))
		return -EACCES;

Nick Piggin's avatar
Nick Piggin committed
678
	spin_lock(&sbi->lookup_lock);
679
	if (!simple_empty(dentry)) {
Nick Piggin's avatar
Nick Piggin committed
680
		spin_unlock(&sbi->lookup_lock);
Linus Torvalds's avatar
Linus Torvalds committed
681
682
		return -ENOTEMPTY;
	}
Nick Piggin's avatar
Nick Piggin committed
683
	__autofs4_add_expiring(dentry);
684
	d_drop(dentry);
Ian Kent's avatar
Ian Kent committed
685
	spin_unlock(&sbi->lookup_lock);
Linus Torvalds's avatar
Linus Torvalds committed
686

687
688
689
	if (sbi->version < 5)
		autofs_clear_leaf_automount_flags(dentry);

690
691
692
693
694
	if (atomic_dec_and_test(&ino->count)) {
		p_ino = autofs4_dentry_ino(dentry->d_parent);
		if (p_ino && dentry->d_parent != dentry)
			atomic_dec(&p_ino->count);
	}
Linus Torvalds's avatar
Linus Torvalds committed
695
696
	dput(ino->dentry);
	dentry->d_inode->i_size = 0;
697
	clear_nlink(dentry->d_inode);
Linus Torvalds's avatar
Linus Torvalds committed
698
699

	if (dir->i_nlink)
700
		drop_nlink(dir);
Linus Torvalds's avatar
Linus Torvalds committed
701
702
703
704

	return 0;
}

705
static int autofs4_dir_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
Linus Torvalds's avatar
Linus Torvalds committed
706
707
708
{
	struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
	struct autofs_info *ino = autofs4_dentry_ino(dentry);
709
	struct autofs_info *p_ino;
Linus Torvalds's avatar
Linus Torvalds committed
710
711
	struct inode *inode;

712
	if (!autofs4_oz_mode(sbi))
Linus Torvalds's avatar
Linus Torvalds committed
713
714
715
716
717
		return -EACCES;

	DPRINTK("dentry %p, creating %.*s",
		dentry, dentry->d_name.len, dentry->d_name.name);

718
719
	BUG_ON(!ino);

Al Viro's avatar
Al Viro committed
720
	autofs4_clean_ino(ino);
721

722
723
	autofs4_del_active(dentry);

724
	inode = autofs4_get_inode(dir->i_sb, S_IFDIR | 0555);
725
	if (!inode)
726
		return -ENOMEM;
Ian Kent's avatar
Ian Kent committed
727
	d_add(dentry, inode);
Linus Torvalds's avatar
Linus Torvalds committed
728

729
730
731
	if (sbi->version < 5)
		autofs_set_leaf_automount_flags(dentry);

732
	dget(dentry);
733
734
	atomic_inc(&ino->count);
	p_ino = autofs4_dentry_ino(dentry->d_parent);
735
	if (p_ino && !IS_ROOT(dentry))
736
		atomic_inc(&p_ino->count);
737
	inc_nlink(dir);
Linus Torvalds's avatar
Linus Torvalds committed
738
739
740
741
742
743
	dir->i_mtime = CURRENT_TIME;

	return 0;
}

/* Get/set timeout ioctl() operation */
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
#ifdef CONFIG_COMPAT
static inline int autofs4_compat_get_set_timeout(struct autofs_sb_info *sbi,
					 compat_ulong_t __user *p)
{
	int rv;
	unsigned long ntimeout;

	if ((rv = get_user(ntimeout, p)) ||
	     (rv = put_user(sbi->exp_timeout/HZ, p)))
		return rv;

	if (ntimeout > UINT_MAX/HZ)
		sbi->exp_timeout = 0;
	else
		sbi->exp_timeout = ntimeout * HZ;

	return 0;
}
#endif

Linus Torvalds's avatar
Linus Torvalds committed
764
765
766
767
768
769
static inline int autofs4_get_set_timeout(struct autofs_sb_info *sbi,
					 unsigned long __user *p)
{
	int rv;
	unsigned long ntimeout;

770
771
	if ((rv = get_user(ntimeout, p)) ||
	     (rv = put_user(sbi->exp_timeout/HZ, p)))
Linus Torvalds's avatar
Linus Torvalds committed
772
773
		return rv;

774
	if (ntimeout > ULONG_MAX/HZ)
Linus Torvalds's avatar
Linus Torvalds committed
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
		sbi->exp_timeout = 0;
	else
		sbi->exp_timeout = ntimeout * HZ;

	return 0;
}

/* Return protocol version */
static inline int autofs4_get_protover(struct autofs_sb_info *sbi, int __user *p)
{
	return put_user(sbi->version, p);
}

/* Return protocol sub version */
static inline int autofs4_get_protosubver(struct autofs_sb_info *sbi, int __user *p)
{
	return put_user(sbi->sub_version, p);
}

/*
* Tells the daemon whether it can umount the autofs mount.
*/
static inline int autofs4_ask_umount(struct vfsmount *mnt, int __user *p)
{
	int status = 0;

801
	if (may_umount(mnt))
Linus Torvalds's avatar
Linus Torvalds committed
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
		status = 1;

	DPRINTK("returning %d", status);

	status = put_user(status, p);

	return status;
}

/* Identify autofs4_dentries - this is so we can tell if there's
   an extra dentry refcount or not.  We only hold a refcount on the
   dentry if its non-negative (ie, d_inode != NULL)
*/
int is_autofs4_dentry(struct dentry *dentry)
{
	return dentry && dentry->d_inode &&
818
		dentry->d_op == &autofs4_dentry_operations &&
Linus Torvalds's avatar
Linus Torvalds committed
819
820
821
822
823
824
825
		dentry->d_fsdata != NULL;
}

/*
 * ioctl()'s on the root directory is the chief method for the daemon to
 * generate kernel reactions
 */
826
827
static int autofs4_root_ioctl_unlocked(struct inode *inode, struct file *filp,
				       unsigned int cmd, unsigned long arg)
Linus Torvalds's avatar
Linus Torvalds committed
828
829
830
831
832
{
	struct autofs_sb_info *sbi = autofs4_sbi(inode->i_sb);
	void __user *p = (void __user *)arg;

	DPRINTK("cmd = 0x%08x, arg = 0x%08lx, sbi = %p, pgrp = %u",
833
		cmd,arg,sbi,task_pgrp_nr(current));
Linus Torvalds's avatar
Linus Torvalds committed
834

835
836
	if (_IOC_TYPE(cmd) != _IOC_TYPE(AUTOFS_IOC_FIRST) ||
	     _IOC_NR(cmd) - _IOC_NR(AUTOFS_IOC_FIRST) >= AUTOFS_IOC_COUNT)
Linus Torvalds's avatar
Linus Torvalds committed
837
838
		return -ENOTTY;
	
839
	if (!autofs4_oz_mode(sbi) && !capable(CAP_SYS_ADMIN))
Linus Torvalds's avatar
Linus Torvalds committed
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
		return -EPERM;
	
	switch(cmd) {
	case AUTOFS_IOC_READY:	/* Wait queue: go ahead and retry */
		return autofs4_wait_release(sbi,(autofs_wqt_t)arg,0);
	case AUTOFS_IOC_FAIL:	/* Wait queue: fail with ENOENT */
		return autofs4_wait_release(sbi,(autofs_wqt_t)arg,-ENOENT);
	case AUTOFS_IOC_CATATONIC: /* Enter catatonic mode (daemon shutdown) */
		autofs4_catatonic_mode(sbi);
		return 0;
	case AUTOFS_IOC_PROTOVER: /* Get protocol version */
		return autofs4_get_protover(sbi, p);
	case AUTOFS_IOC_PROTOSUBVER: /* Get protocol sub version */
		return autofs4_get_protosubver(sbi, p);
	case AUTOFS_IOC_SETTIMEOUT:
		return autofs4_get_set_timeout(sbi, p);
856
857
858
859
#ifdef CONFIG_COMPAT
	case AUTOFS_IOC_SETTIMEOUT32:
		return autofs4_compat_get_set_timeout(sbi, p);
#endif
Linus Torvalds's avatar
Linus Torvalds committed
860
861

	case AUTOFS_IOC_ASKUMOUNT:
862
		return autofs4_ask_umount(filp->f_path.mnt, p);
Linus Torvalds's avatar
Linus Torvalds committed
863
864
865

	/* return a single thing to expire */
	case AUTOFS_IOC_EXPIRE:
866
		return autofs4_expire_run(inode->i_sb,filp->f_path.mnt,sbi, p);
Linus Torvalds's avatar
Linus Torvalds committed
867
868
	/* same as above, but can send multiple expires through pipe */
	case AUTOFS_IOC_EXPIRE_MULTI:
869
		return autofs4_expire_multi(inode->i_sb,filp->f_path.mnt,sbi, p);
Linus Torvalds's avatar
Linus Torvalds committed
870
871
872
873
874

	default:
		return -ENOSYS;
	}
}
875
876
877
878

static long autofs4_root_ioctl(struct file *filp,
			       unsigned int cmd, unsigned long arg)
{
Al Viro's avatar
Al Viro committed
879
	struct inode *inode = file_inode(filp);
880
	return autofs4_root_ioctl_unlocked(inode, filp, cmd, arg);
881
}
882
883
884
885
886

#ifdef CONFIG_COMPAT
static long autofs4_root_compat_ioctl(struct file *filp,
			     unsigned int cmd, unsigned long arg)
{
Al Viro's avatar
Al Viro committed
887
	struct inode *inode = file_inode(filp);
888
889
890
891
892
893
894
895
896
897
898
	int ret;

	if (cmd == AUTOFS_IOC_READY || cmd == AUTOFS_IOC_FAIL)
		ret = autofs4_root_ioctl_unlocked(inode, filp, cmd, arg);
	else
		ret = autofs4_root_ioctl_unlocked(inode, filp, cmd,
			(unsigned long)compat_ptr(arg));

	return ret;
}
#endif