blob: 2eebeae75288da876736683d99de17508d4e97ef [file] [log] [blame]
Ian Kente9a7c2f2016-03-15 14:58:25 -07001/*
2 * Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
3 * Copyright 1999-2000 Jeremy Fitzhardinge <jeremy@goop.org>
4 * Copyright 2001-2006 Ian Kent <raven@themaw.net>
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
6 * This file is part of the Linux kernel and is made available under
7 * the terms of the GNU General Public License, version 2, or at your
8 * option, any later version, incorporated herein by reference.
Ian Kente9a7c2f2016-03-15 14:58:25 -07009 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070010
Randy Dunlap16f7e0f2006-01-11 12:17:46 -080011#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/errno.h>
13#include <linux/stat.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090014#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/param.h>
16#include <linux/time.h>
Arnd Bergmannc9243f52010-07-04 00:15:07 +020017#include <linux/compat.h>
Arnd Bergmann00e300e2010-09-14 23:00:34 +020018#include <linux/mutex.h>
Arnd Bergmannc9243f52010-07-04 00:15:07 +020019
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include "autofs_i.h"
21
Ian Kente9a7c2f2016-03-15 14:58:25 -070022static int autofs4_dir_symlink(struct inode *, struct dentry *, const char *);
23static int autofs4_dir_unlink(struct inode *, struct dentry *);
24static int autofs4_dir_rmdir(struct inode *, struct dentry *);
25static int autofs4_dir_mkdir(struct inode *, struct dentry *, umode_t);
26static long autofs4_root_ioctl(struct file *, unsigned int, unsigned long);
Felipe Contreras5a44a732010-09-24 15:22:23 +020027#ifdef CONFIG_COMPAT
Ian Kente9a7c2f2016-03-15 14:58:25 -070028static long autofs4_root_compat_ioctl(struct file *,
29 unsigned int, unsigned long);
Felipe Contreras5a44a732010-09-24 15:22:23 +020030#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070031static int autofs4_dir_open(struct inode *inode, struct file *file);
Ian Kente9a7c2f2016-03-15 14:58:25 -070032static struct dentry *autofs4_lookup(struct inode *,
33 struct dentry *, unsigned int);
Ian Kent71e469d2011-01-14 18:46:19 +000034static struct vfsmount *autofs4_d_automount(struct path *);
Al Viro1aed3e42011-03-18 09:09:02 -040035static int autofs4_d_manage(struct dentry *, bool);
Al Virob89b12b2011-01-16 21:42:32 -050036static void autofs4_dentry_release(struct dentry *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -080038const struct file_operations autofs4_root_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070039 .open = dcache_dir_open,
40 .release = dcache_dir_close,
41 .read = generic_read_dir,
Al Viro4e829012016-04-20 19:52:15 -040042 .iterate_shared = dcache_readdir,
Al Viro59af1582008-08-24 07:24:41 -040043 .llseek = dcache_dir_lseek,
Frederic Weisbecker3663df72010-05-19 15:08:17 +020044 .unlocked_ioctl = autofs4_root_ioctl,
Arnd Bergmannc9243f52010-07-04 00:15:07 +020045#ifdef CONFIG_COMPAT
46 .compat_ioctl = autofs4_root_compat_ioctl,
47#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070048};
49
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -080050const struct file_operations autofs4_dir_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 .open = autofs4_dir_open,
Ian Kentff9cd492008-07-23 21:30:24 -070052 .release = dcache_dir_close,
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 .read = generic_read_dir,
Al Viro4e829012016-04-20 19:52:15 -040054 .iterate_shared = dcache_readdir,
Al Viro59af1582008-08-24 07:24:41 -040055 .llseek = dcache_dir_lseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -070056};
57
Arjan van de Ven754661f2007-02-12 00:55:38 -080058const struct inode_operations autofs4_dir_inode_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070059 .lookup = autofs4_lookup,
60 .unlink = autofs4_dir_unlink,
61 .symlink = autofs4_dir_symlink,
62 .mkdir = autofs4_dir_mkdir,
63 .rmdir = autofs4_dir_rmdir,
64};
65
Ian Kent71e469d2011-01-14 18:46:19 +000066const struct dentry_operations autofs4_dentry_operations = {
Ian Kent71e469d2011-01-14 18:46:19 +000067 .d_automount = autofs4_d_automount,
68 .d_manage = autofs4_d_manage,
69 .d_release = autofs4_dentry_release,
70};
71
Ian Kent4f8427d2009-12-15 16:45:42 -080072static void autofs4_add_active(struct dentry *dentry)
73{
74 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
Ian Kente9a7c2f2016-03-15 14:58:25 -070075 struct autofs_info *ino;
76
77 ino = autofs4_dentry_ino(dentry);
Ian Kent4f8427d2009-12-15 16:45:42 -080078 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 }
Ian Kent4f8427d2009-12-15 16:45:42 -080087}
88
89static void autofs4_del_active(struct dentry *dentry)
90{
91 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
Ian Kente9a7c2f2016-03-15 14:58:25 -070092 struct autofs_info *ino;
93
94 ino = autofs4_dentry_ino(dentry);
Ian Kent4f8427d2009-12-15 16:45:42 -080095 if (ino) {
96 spin_lock(&sbi->lookup_lock);
97 ino->active_count--;
98 if (!ino->active_count) {
99 if (!list_empty(&ino->active))
100 list_del_init(&ino->active);
101 }
102 spin_unlock(&sbi->lookup_lock);
103 }
Ian Kent4f8427d2009-12-15 16:45:42 -0800104}
105
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106static int autofs4_dir_open(struct inode *inode, struct file *file)
107{
Josef "Jeff" Sipeka4669ed2006-12-08 02:36:46 -0800108 struct dentry *dentry = file->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
Ian Kentf360ce32006-03-27 01:14:43 -0800110
Ian Kent8a78d592016-03-15 14:58:45 -0700111 pr_debug("file=%p dentry=%p %pd\n", file, dentry, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112
113 if (autofs4_oz_mode(sbi))
114 goto out;
115
Ian Kentff9cd492008-07-23 21:30:24 -0700116 /*
117 * An empty directory in an autofs file system is always a
118 * mount point. The daemon must have failed to mount this
119 * during lookup so it doesn't exist. This can happen, for
120 * example, if user space returns an incorrect status for a
121 * mount request. Otherwise we're doing a readdir on the
122 * autofs file system so just let the libfs routines handle
123 * it.
124 */
Ian Kente7854722011-03-25 01:51:31 +0800125 spin_lock(&sbi->lookup_lock);
Ian Kent0259cb02012-12-14 10:23:29 +0800126 if (!d_mountpoint(dentry) && simple_empty(dentry)) {
Ian Kente7854722011-03-25 01:51:31 +0800127 spin_unlock(&sbi->lookup_lock);
Ian Kentff9cd492008-07-23 21:30:24 -0700128 return -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 }
Ian Kente7854722011-03-25 01:51:31 +0800130 spin_unlock(&sbi->lookup_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131
Ian Kentf360ce32006-03-27 01:14:43 -0800132out:
Ian Kentff9cd492008-07-23 21:30:24 -0700133 return dcache_dir_open(inode, file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134}
135
Al Virob89b12b2011-01-16 21:42:32 -0500136static void autofs4_dentry_release(struct dentry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137{
Al Virob89b12b2011-01-16 21:42:32 -0500138 struct autofs_info *ino = autofs4_dentry_ino(de);
139 struct autofs_sb_info *sbi = autofs4_sbi(de->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140
Ian Kent8a78d592016-03-15 14:58:45 -0700141 pr_debug("releasing %p\n", de);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142
Al Virob89b12b2011-01-16 21:42:32 -0500143 if (!ino)
144 return;
145
146 if (sbi) {
147 spin_lock(&sbi->lookup_lock);
148 if (!list_empty(&ino->active))
149 list_del(&ino->active);
150 if (!list_empty(&ino->expiring))
151 list_del(&ino->expiring);
152 spin_unlock(&sbi->lookup_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 }
Al Virob89b12b2011-01-16 21:42:32 -0500154
155 autofs4_free_ino(ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156}
157
Ian Kent6510c9d2009-12-15 16:45:47 -0800158static struct dentry *autofs4_lookup_active(struct dentry *dentry)
Ian Kent25767372008-07-23 21:30:12 -0700159{
Ian Kent6510c9d2009-12-15 16:45:47 -0800160 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
161 struct dentry *parent = dentry->d_parent;
Al Viro8ac790f2016-07-20 16:25:07 -0400162 const struct qstr *name = &dentry->d_name;
Ian Kent25767372008-07-23 21:30:12 -0700163 unsigned int len = name->len;
164 unsigned int hash = name->hash;
165 const unsigned char *str = name->name;
166 struct list_head *p, *head;
167
Ian Kent25767372008-07-23 21:30:12 -0700168 head = &sbi->active_list;
NeilBrown668128e2014-08-08 14:19:54 -0700169 if (list_empty(head))
170 return NULL;
171 spin_lock(&sbi->lookup_lock);
Ian Kent25767372008-07-23 21:30:12 -0700172 list_for_each(p, head) {
173 struct autofs_info *ino;
Ian Kente4d5ade2009-12-15 16:45:49 -0800174 struct dentry *active;
Al Viro8ac790f2016-07-20 16:25:07 -0400175 const struct qstr *qstr;
Ian Kent25767372008-07-23 21:30:12 -0700176
177 ino = list_entry(p, struct autofs_info, active);
Ian Kente4d5ade2009-12-15 16:45:49 -0800178 active = ino->dentry;
Ian Kent25767372008-07-23 21:30:12 -0700179
Ian Kente4d5ade2009-12-15 16:45:49 -0800180 spin_lock(&active->d_lock);
Ian Kent25767372008-07-23 21:30:12 -0700181
182 /* Already gone? */
Ian Kent6b6751f2014-05-06 12:50:06 -0700183 if ((int) d_count(active) <= 0)
Ian Kent25767372008-07-23 21:30:12 -0700184 goto next;
185
Ian Kente4d5ade2009-12-15 16:45:49 -0800186 qstr = &active->d_name;
Ian Kent25767372008-07-23 21:30:12 -0700187
Ian Kente4d5ade2009-12-15 16:45:49 -0800188 if (active->d_name.hash != hash)
Ian Kent25767372008-07-23 21:30:12 -0700189 goto next;
Ian Kente4d5ade2009-12-15 16:45:49 -0800190 if (active->d_parent != parent)
Ian Kent25767372008-07-23 21:30:12 -0700191 goto next;
192
193 if (qstr->len != len)
194 goto next;
195 if (memcmp(qstr->name, str, len))
196 goto next;
197
Al Viro4b1ae272010-03-03 12:58:31 -0500198 if (d_unhashed(active)) {
Nick Pigginb7ab39f2011-01-07 17:49:32 +1100199 dget_dlock(active);
Al Viro4b1ae272010-03-03 12:58:31 -0500200 spin_unlock(&active->d_lock);
201 spin_unlock(&sbi->lookup_lock);
Al Viro4b1ae272010-03-03 12:58:31 -0500202 return active;
203 }
Ian Kent25767372008-07-23 21:30:12 -0700204next:
Ian Kente4d5ade2009-12-15 16:45:49 -0800205 spin_unlock(&active->d_lock);
Ian Kent25767372008-07-23 21:30:12 -0700206 }
207 spin_unlock(&sbi->lookup_lock);
Ian Kent25767372008-07-23 21:30:12 -0700208
209 return NULL;
210}
211
NeilBrown23bfc2a2014-10-13 15:52:14 -0700212static struct dentry *autofs4_lookup_expiring(struct dentry *dentry,
213 bool rcu_walk)
Ian Kentf50b6f82007-02-20 13:58:10 -0800214{
Ian Kent6510c9d2009-12-15 16:45:47 -0800215 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
216 struct dentry *parent = dentry->d_parent;
Al Viro8ac790f2016-07-20 16:25:07 -0400217 const struct qstr *name = &dentry->d_name;
Ian Kentf50b6f82007-02-20 13:58:10 -0800218 unsigned int len = name->len;
219 unsigned int hash = name->hash;
220 const unsigned char *str = name->name;
221 struct list_head *p, *head;
222
Ian Kent5f6f4f22008-07-23 21:30:09 -0700223 head = &sbi->expiring_list;
NeilBrown668128e2014-08-08 14:19:54 -0700224 if (list_empty(head))
225 return NULL;
226 spin_lock(&sbi->lookup_lock);
Ian Kentf50b6f82007-02-20 13:58:10 -0800227 list_for_each(p, head) {
228 struct autofs_info *ino;
Ian Kentcb4b4922009-12-15 16:45:50 -0800229 struct dentry *expiring;
Al Viro8ac790f2016-07-20 16:25:07 -0400230 const struct qstr *qstr;
Ian Kentf50b6f82007-02-20 13:58:10 -0800231
NeilBrown23bfc2a2014-10-13 15:52:14 -0700232 if (rcu_walk) {
233 spin_unlock(&sbi->lookup_lock);
234 return ERR_PTR(-ECHILD);
235 }
236
Ian Kent5f6f4f22008-07-23 21:30:09 -0700237 ino = list_entry(p, struct autofs_info, expiring);
Ian Kentcb4b4922009-12-15 16:45:50 -0800238 expiring = ino->dentry;
Ian Kentf50b6f82007-02-20 13:58:10 -0800239
Ian Kentcb4b4922009-12-15 16:45:50 -0800240 spin_lock(&expiring->d_lock);
Ian Kentf50b6f82007-02-20 13:58:10 -0800241
Ian Kent6b6751f2014-05-06 12:50:06 -0700242 /* We've already been dentry_iput or unlinked */
David Howells2b0143b2015-03-17 22:25:59 +0000243 if (d_really_is_negative(expiring))
Ian Kentf50b6f82007-02-20 13:58:10 -0800244 goto next;
245
Ian Kentcb4b4922009-12-15 16:45:50 -0800246 qstr = &expiring->d_name;
Ian Kentf50b6f82007-02-20 13:58:10 -0800247
Ian Kentcb4b4922009-12-15 16:45:50 -0800248 if (expiring->d_name.hash != hash)
Ian Kentf50b6f82007-02-20 13:58:10 -0800249 goto next;
Ian Kentcb4b4922009-12-15 16:45:50 -0800250 if (expiring->d_parent != parent)
Ian Kentf50b6f82007-02-20 13:58:10 -0800251 goto next;
252
253 if (qstr->len != len)
254 goto next;
255 if (memcmp(qstr->name, str, len))
256 goto next;
257
Al Viro4b1ae272010-03-03 12:58:31 -0500258 if (d_unhashed(expiring)) {
Nick Pigginb7ab39f2011-01-07 17:49:32 +1100259 dget_dlock(expiring);
Al Viro4b1ae272010-03-03 12:58:31 -0500260 spin_unlock(&expiring->d_lock);
261 spin_unlock(&sbi->lookup_lock);
Al Viro4b1ae272010-03-03 12:58:31 -0500262 return expiring;
263 }
Ian Kentf50b6f82007-02-20 13:58:10 -0800264next:
Ian Kentcb4b4922009-12-15 16:45:50 -0800265 spin_unlock(&expiring->d_lock);
Ian Kentf50b6f82007-02-20 13:58:10 -0800266 }
Ian Kent5f6f4f22008-07-23 21:30:09 -0700267 spin_unlock(&sbi->lookup_lock);
Ian Kentf50b6f82007-02-20 13:58:10 -0800268
269 return NULL;
270}
271
NeilBrown23bfc2a2014-10-13 15:52:14 -0700272static int autofs4_mount_wait(struct dentry *dentry, bool rcu_walk)
Ian Kent10584212011-01-14 18:45:58 +0000273{
274 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
275 struct autofs_info *ino = autofs4_dentry_ino(dentry);
Ian Kent3c319982011-03-25 01:51:08 +0800276 int status = 0;
Ian Kent10584212011-01-14 18:45:58 +0000277
278 if (ino->flags & AUTOFS_INF_PENDING) {
NeilBrown23bfc2a2014-10-13 15:52:14 -0700279 if (rcu_walk)
280 return -ECHILD;
Ian Kent8a78d592016-03-15 14:58:45 -0700281 pr_debug("waiting for mount name=%pd\n", dentry);
Ian Kent10584212011-01-14 18:45:58 +0000282 status = autofs4_wait(sbi, dentry, NFY_MOUNT);
Ian Kent8a78d592016-03-15 14:58:45 -0700283 pr_debug("mount wait done status=%d\n", status);
Ian Kent10584212011-01-14 18:45:58 +0000284 }
Ian Kent3c319982011-03-25 01:51:08 +0800285 ino->last_used = jiffies;
286 return status;
Ian Kent10584212011-01-14 18:45:58 +0000287}
288
NeilBrown23bfc2a2014-10-13 15:52:14 -0700289static int do_expire_wait(struct dentry *dentry, bool rcu_walk)
Ian Kent10584212011-01-14 18:45:58 +0000290{
291 struct dentry *expiring;
292
NeilBrown23bfc2a2014-10-13 15:52:14 -0700293 expiring = autofs4_lookup_expiring(dentry, rcu_walk);
294 if (IS_ERR(expiring))
295 return PTR_ERR(expiring);
Ian Kent10584212011-01-14 18:45:58 +0000296 if (!expiring)
NeilBrown23bfc2a2014-10-13 15:52:14 -0700297 return autofs4_expire_wait(dentry, rcu_walk);
Ian Kent10584212011-01-14 18:45:58 +0000298 else {
299 /*
300 * If we are racing with expire the request might not
301 * be quite complete, but the directory has been removed
302 * so it must have been successful, just wait for it.
303 */
NeilBrown23bfc2a2014-10-13 15:52:14 -0700304 autofs4_expire_wait(expiring, 0);
Ian Kent10584212011-01-14 18:45:58 +0000305 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 * If this is an indirect mount the dentry could have gone away
318 * as a result of an expire and a new one created.
319 */
320 if (autofs_type_indirect(sbi->type) && d_unhashed(dentry)) {
321 struct dentry *parent = dentry->d_parent;
Ian Kent3c319982011-03-25 01:51:08 +0800322 struct autofs_info *ino;
Ian Kente9a7c2f2016-03-15 14:58:25 -0700323 struct dentry *new;
324
325 new = d_lookup(parent, &dentry->d_name);
Ian Kent10584212011-01-14 18:45:58 +0000326 if (!new)
327 return NULL;
Ian Kent3c319982011-03-25 01:51:08 +0800328 ino = autofs4_dentry_ino(new);
329 ino->last_used = jiffies;
Ian Kent10584212011-01-14 18:45:58 +0000330 dput(path->dentry);
331 path->dentry = new;
332 }
333 return path->dentry;
334}
335
Ian Kent71e469d2011-01-14 18:46:19 +0000336static struct vfsmount *autofs4_d_automount(struct path *path)
Ian Kent10584212011-01-14 18:45:58 +0000337{
338 struct dentry *dentry = path->dentry;
339 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
340 struct autofs_info *ino = autofs4_dentry_ino(dentry);
341 int status;
342
Ian Kent8a78d592016-03-15 14:58:45 -0700343 pr_debug("dentry=%p %pd\n", dentry, dentry);
Ian Kent10584212011-01-14 18:45:58 +0000344
345 /* The daemon never triggers a mount. */
346 if (autofs4_oz_mode(sbi))
347 return NULL;
348
349 /*
350 * If an expire request is pending everyone must wait.
351 * If the expire fails we're still mounted so continue
352 * the follow and return. A return of -EAGAIN (which only
353 * happens with indirect mounts) means the expire completed
354 * and the directory was removed, so just go ahead and try
355 * the mount.
356 */
NeilBrown23bfc2a2014-10-13 15:52:14 -0700357 status = do_expire_wait(dentry, 0);
Ian Kent10584212011-01-14 18:45:58 +0000358 if (status && status != -EAGAIN)
359 return NULL;
360
361 /* Callback to the daemon to perform the mount or wait */
362 spin_lock(&sbi->fs_lock);
363 if (ino->flags & AUTOFS_INF_PENDING) {
364 spin_unlock(&sbi->fs_lock);
NeilBrown23bfc2a2014-10-13 15:52:14 -0700365 status = autofs4_mount_wait(dentry, 0);
Ian Kent10584212011-01-14 18:45:58 +0000366 if (status)
367 return ERR_PTR(status);
Ian Kent10584212011-01-14 18:45:58 +0000368 goto done;
369 }
370
371 /*
372 * If the dentry is a symlink it's equivalent to a directory
Ian Kentb5b80172011-01-14 18:46:03 +0000373 * having d_mountpoint() true, so there's no need to call back
Ian Kent10584212011-01-14 18:45:58 +0000374 * to the daemon.
375 */
David Howells2b0143b2015-03-17 22:25:59 +0000376 if (d_really_is_positive(dentry) && d_is_symlink(dentry)) {
Ian Kentf55fb0c2012-12-14 10:23:23 +0800377 spin_unlock(&sbi->fs_lock);
Ian Kent10584212011-01-14 18:45:58 +0000378 goto done;
Ian Kentf55fb0c2012-12-14 10:23:23 +0800379 }
380
Ian Kentb5b80172011-01-14 18:46:03 +0000381 if (!d_mountpoint(dentry)) {
382 /*
383 * It's possible that user space hasn't removed directories
384 * after umounting a rootless multi-mount, although it
385 * should. For v5 have_submounts() is sufficient to handle
386 * this because the leaves of the directory tree under the
387 * mount never trigger mounts themselves (they have an autofs
388 * trigger mount mounted on them). But v4 pseudo direct mounts
NeilBrown3b97dd02014-08-08 14:19:58 -0700389 * do need the leaves to trigger mounts. In this case we
Ian Kentb5b80172011-01-14 18:46:03 +0000390 * have no choice but to use the list_empty() check and
391 * require user space behave.
392 */
393 if (sbi->version > 4) {
Ian Kentf55fb0c2012-12-14 10:23:23 +0800394 if (have_submounts(dentry)) {
395 spin_unlock(&sbi->fs_lock);
Ian Kentb5b80172011-01-14 18:46:03 +0000396 goto done;
Ian Kentf55fb0c2012-12-14 10:23:23 +0800397 }
Ian Kentb5b80172011-01-14 18:46:03 +0000398 } else {
Peter Huewe9d8072e2013-03-01 19:46:40 +0800399 if (!simple_empty(dentry)) {
400 spin_unlock(&sbi->fs_lock);
Ian Kentb5b80172011-01-14 18:46:03 +0000401 goto done;
Peter Huewe9d8072e2013-03-01 19:46:40 +0800402 }
Ian Kentb5b80172011-01-14 18:46:03 +0000403 }
Ian Kent10584212011-01-14 18:45:58 +0000404 ino->flags |= AUTOFS_INF_PENDING;
Ian Kent10584212011-01-14 18:45:58 +0000405 spin_unlock(&sbi->fs_lock);
NeilBrown23bfc2a2014-10-13 15:52:14 -0700406 status = autofs4_mount_wait(dentry, 0);
Ian Kent10584212011-01-14 18:45:58 +0000407 spin_lock(&sbi->fs_lock);
408 ino->flags &= ~AUTOFS_INF_PENDING;
Ian Kent49999ab2012-10-11 08:00:33 +0800409 if (status) {
410 spin_unlock(&sbi->fs_lock);
411 return ERR_PTR(status);
412 }
Ian Kent10584212011-01-14 18:45:58 +0000413 }
Ian Kent10584212011-01-14 18:45:58 +0000414 spin_unlock(&sbi->fs_lock);
Ian Kentf55fb0c2012-12-14 10:23:23 +0800415done:
Ian Kent10584212011-01-14 18:45:58 +0000416 /* Mount succeeded, check if we ended up with a new dentry */
417 dentry = autofs4_mountpoint_changed(path);
418 if (!dentry)
419 return ERR_PTR(-ENOENT);
420
421 return NULL;
422}
423
Claudiu Ghioc95482982013-05-06 13:47:16 +0800424static int autofs4_d_manage(struct dentry *dentry, bool rcu_walk)
Ian Kentb5b80172011-01-14 18:46:03 +0000425{
426 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
Ian Kentf55fb0c2012-12-14 10:23:23 +0800427 struct autofs_info *ino = autofs4_dentry_ino(dentry);
428 int status;
Ian Kentb5b80172011-01-14 18:46:03 +0000429
Ian Kent8a78d592016-03-15 14:58:45 -0700430 pr_debug("dentry=%p %pd\n", dentry, dentry);
Ian Kentb5b80172011-01-14 18:46:03 +0000431
432 /* The daemon never waits. */
Al Viro1aed3e42011-03-18 09:09:02 -0400433 if (autofs4_oz_mode(sbi)) {
Ian Kentb5b80172011-01-14 18:46:03 +0000434 if (!d_mountpoint(dentry))
435 return -EISDIR;
436 return 0;
437 }
438
439 /* Wait for pending expires */
NeilBrown23bfc2a2014-10-13 15:52:14 -0700440 if (do_expire_wait(dentry, rcu_walk) == -ECHILD)
441 return -ECHILD;
Ian Kentb5b80172011-01-14 18:46:03 +0000442
443 /*
444 * This dentry may be under construction so wait on mount
445 * completion.
446 */
NeilBrown23bfc2a2014-10-13 15:52:14 -0700447 status = autofs4_mount_wait(dentry, rcu_walk);
Ian Kentf55fb0c2012-12-14 10:23:23 +0800448 if (status)
449 return status;
450
NeilBrownef16cc52014-10-13 15:52:22 -0700451 if (rcu_walk) {
452 /* We don't need fs_lock in rcu_walk mode,
453 * just testing 'AUTOFS_INFO_NO_RCU' is enough.
454 * simple_empty() takes a spinlock, so leave it
455 * to last.
456 * We only return -EISDIR when certain this isn't
457 * a mount-trap.
NeilBrown23bfc2a2014-10-13 15:52:14 -0700458 */
NeilBrownef16cc52014-10-13 15:52:22 -0700459 struct inode *inode;
Ian Kente9a7c2f2016-03-15 14:58:25 -0700460
Al Viroea01a182016-06-12 11:24:46 -0400461 if (ino->flags & AUTOFS_INF_WANT_EXPIRE)
NeilBrownef16cc52014-10-13 15:52:22 -0700462 return 0;
463 if (d_mountpoint(dentry))
464 return 0;
David Howells2b0143b2015-03-17 22:25:59 +0000465 inode = d_inode_rcu(dentry);
NeilBrownef16cc52014-10-13 15:52:22 -0700466 if (inode && S_ISLNK(inode->i_mode))
467 return -EISDIR;
468 if (list_empty(&dentry->d_subdirs))
469 return 0;
470 if (!simple_empty(dentry))
471 return -EISDIR;
NeilBrown23bfc2a2014-10-13 15:52:14 -0700472 return 0;
NeilBrownef16cc52014-10-13 15:52:22 -0700473 }
NeilBrown23bfc2a2014-10-13 15:52:14 -0700474
Ian Kentf55fb0c2012-12-14 10:23:23 +0800475 spin_lock(&sbi->fs_lock);
476 /*
477 * If the dentry has been selected for expire while we slept
478 * on the lock then it might go away. We'll deal with that in
479 * ->d_automount() and wait on a new mount if the expire
480 * succeeds or return here if it doesn't (since there's no
481 * mount to follow with a rootless multi-mount).
482 */
483 if (!(ino->flags & AUTOFS_INF_EXPIRING)) {
484 /*
485 * Any needed mounting has been completed and the path
486 * updated so check if this is a rootless multi-mount so
487 * we can avoid needless calls ->d_automount() and avoid
488 * an incorrect ELOOP error return.
489 */
490 if ((!d_mountpoint(dentry) && !simple_empty(dentry)) ||
David Howells2b0143b2015-03-17 22:25:59 +0000491 (d_really_is_positive(dentry) && d_is_symlink(dentry)))
Ian Kentf55fb0c2012-12-14 10:23:23 +0800492 status = -EISDIR;
493 }
494 spin_unlock(&sbi->fs_lock);
495
496 return status;
Ian Kentb5b80172011-01-14 18:46:03 +0000497}
498
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499/* Lookups in the root directory */
Ian Kente9a7c2f2016-03-15 14:58:25 -0700500static struct dentry *autofs4_lookup(struct inode *dir,
501 struct dentry *dentry, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502{
503 struct autofs_sb_info *sbi;
Ian Kent25767372008-07-23 21:30:12 -0700504 struct autofs_info *ino;
Ian Kent10584212011-01-14 18:45:58 +0000505 struct dentry *active;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
Ian Kent8a78d592016-03-15 14:58:45 -0700507 pr_debug("name = %pd\n", dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508
Ian Kent718c6042006-03-27 01:14:42 -0800509 /* File name too long to exist */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 if (dentry->d_name.len > NAME_MAX)
Ian Kent718c6042006-03-27 01:14:42 -0800511 return ERR_PTR(-ENAMETOOLONG);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512
513 sbi = autofs4_sbi(dir->i_sb);
Ian Kent718c6042006-03-27 01:14:42 -0800514
Ian Kent8a78d592016-03-15 14:58:45 -0700515 pr_debug("pid = %u, pgrp = %u, catatonic = %d, oz_mode = %d\n",
516 current->pid, task_pgrp_nr(current), sbi->catatonic,
517 autofs4_oz_mode(sbi));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518
Ian Kent6510c9d2009-12-15 16:45:47 -0800519 active = autofs4_lookup_active(dentry);
Ian Kente9a7c2f2016-03-15 14:58:25 -0700520 if (active)
Ian Kent10584212011-01-14 18:45:58 +0000521 return active;
Ian Kente9a7c2f2016-03-15 14:58:25 -0700522 else {
Al Viro4b1ae272010-03-03 12:58:31 -0500523 /*
Ian Kent10584212011-01-14 18:45:58 +0000524 * A dentry that is not within the root can never trigger a
525 * mount operation, unless the directory already exists, so we
526 * can return fail immediately. The daemon however does need
527 * to create directories within the file system.
Al Viro4b1ae272010-03-03 12:58:31 -0500528 */
Ian Kent10584212011-01-14 18:45:58 +0000529 if (!autofs4_oz_mode(sbi) && !IS_ROOT(dentry->d_parent))
530 return ERR_PTR(-ENOENT);
531
532 /* Mark entries in the root as mount triggers */
Ian Kente9a7c2f2016-03-15 14:58:25 -0700533 if (IS_ROOT(dentry->d_parent) &&
534 autofs_type_indirect(sbi->type))
Ian Kentb5b80172011-01-14 18:46:03 +0000535 __managed_dentry_set_managed(dentry);
Ian Kent10584212011-01-14 18:45:58 +0000536
Al Viro26e6c912011-01-16 18:43:40 -0500537 ino = autofs4_new_ino(sbi);
Al Viro4b1ae272010-03-03 12:58:31 -0500538 if (!ino)
539 return ERR_PTR(-ENOMEM);
540
541 dentry->d_fsdata = ino;
542 ino->dentry = dentry;
543
544 autofs4_add_active(dentry);
Ian Kent25767372008-07-23 21:30:12 -0700545 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 return NULL;
547}
548
549static int autofs4_dir_symlink(struct inode *dir,
550 struct dentry *dentry,
551 const char *symname)
552{
553 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
554 struct autofs_info *ino = autofs4_dentry_ino(dentry);
Ian Kent1aff3c82006-03-27 01:14:46 -0800555 struct autofs_info *p_ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 struct inode *inode;
Al Viro0bf71d42011-01-16 17:39:15 -0500557 size_t size = strlen(symname);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 char *cp;
559
Ian Kent8a78d592016-03-15 14:58:45 -0700560 pr_debug("%s <- %pd\n", symname, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561
562 if (!autofs4_oz_mode(sbi))
563 return -EACCES;
564
Al Viro5a37db32011-01-16 18:29:35 -0500565 BUG_ON(!ino);
566
Al Viro26e6c912011-01-16 18:43:40 -0500567 autofs4_clean_ino(ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568
Al Viro4b1ae272010-03-03 12:58:31 -0500569 autofs4_del_active(dentry);
570
Al Viro0bf71d42011-01-16 17:39:15 -0500571 cp = kmalloc(size + 1, GFP_KERNEL);
Al Viro5a37db32011-01-16 18:29:35 -0500572 if (!cp)
Ian Kent25767372008-07-23 21:30:12 -0700573 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574
575 strcpy(cp, symname);
576
Al Viro726a5e02011-01-16 17:43:52 -0500577 inode = autofs4_get_inode(dir->i_sb, S_IFLNK | 0555);
Ian Kent25767372008-07-23 21:30:12 -0700578 if (!inode) {
579 kfree(cp);
Ian Kent25767372008-07-23 21:30:12 -0700580 return -ENOMEM;
581 }
Al Viro292c5ee2011-01-17 00:47:38 -0500582 inode->i_private = cp;
Al Viro0bf71d42011-01-16 17:39:15 -0500583 inode->i_size = size;
Ian Kent1864f7b2007-08-22 14:01:54 -0700584 d_add(dentry, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585
Al Viro5a37db32011-01-16 18:29:35 -0500586 dget(dentry);
Ian Kent1aff3c82006-03-27 01:14:46 -0800587 atomic_inc(&ino->count);
588 p_ino = autofs4_dentry_ino(dentry->d_parent);
Rui Xiangc24930a2014-01-23 15:55:00 -0800589 if (p_ino && !IS_ROOT(dentry))
Ian Kent1aff3c82006-03-27 01:14:46 -0800590 atomic_inc(&p_ino->count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591
Deepa Dinamani078cd822016-09-14 07:48:04 -0700592 dir->i_mtime = current_time(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593
594 return 0;
595}
596
597/*
598 * NOTE!
599 *
600 * Normal filesystems would do a "d_delete()" to tell the VFS dcache
601 * that the file no longer exists. However, doing that means that the
602 * VFS layer can turn the dentry into a negative dentry. We don't want
Ian Kentf50b6f82007-02-20 13:58:10 -0800603 * this, because the unlink is probably the result of an expire.
Ian Kent5f6f4f22008-07-23 21:30:09 -0700604 * We simply d_drop it and add it to a expiring list in the super block,
605 * which allows the dentry lookup to check for an incomplete expire.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 *
607 * If a process is blocked on the dentry waiting for the expire to finish,
608 * it will invalidate the dentry and try to mount with a new one.
609 *
610 * Also see autofs4_dir_rmdir()..
611 */
612static int autofs4_dir_unlink(struct inode *dir, struct dentry *dentry)
613{
614 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
615 struct autofs_info *ino = autofs4_dentry_ino(dentry);
Ian Kent1aff3c82006-03-27 01:14:46 -0800616 struct autofs_info *p_ino;
Ian Kent02667252016-03-15 14:58:36 -0700617
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 /* This allows root to remove symlinks */
Sukadev Bhattiprolud78e53c2007-05-10 22:23:06 -0700619 if (!autofs4_oz_mode(sbi) && !capable(CAP_SYS_ADMIN))
Zhao Hongjiang41735812013-02-20 13:13:55 +1100620 return -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621
Ian Kent1aff3c82006-03-27 01:14:46 -0800622 if (atomic_dec_and_test(&ino->count)) {
623 p_ino = autofs4_dentry_ino(dentry->d_parent);
Rui Xiangc24930a2014-01-23 15:55:00 -0800624 if (p_ino && !IS_ROOT(dentry))
Ian Kent1aff3c82006-03-27 01:14:46 -0800625 atomic_dec(&p_ino->count);
626 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 dput(ino->dentry);
628
David Howells2b0143b2015-03-17 22:25:59 +0000629 d_inode(dentry)->i_size = 0;
630 clear_nlink(d_inode(dentry));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631
Deepa Dinamani078cd822016-09-14 07:48:04 -0700632 dir->i_mtime = current_time(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633
Ian Kente7854722011-03-25 01:51:31 +0800634 spin_lock(&sbi->lookup_lock);
635 __autofs4_add_expiring(dentry);
Ian Kent0259cb02012-12-14 10:23:29 +0800636 d_drop(dentry);
Ian Kente7854722011-03-25 01:51:31 +0800637 spin_unlock(&sbi->lookup_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638
639 return 0;
640}
641
Ian Kentdd89f902011-01-14 18:46:35 +0000642/*
643 * Version 4 of autofs provides a pseudo direct mount implementation
644 * that relies on directories at the leaves of a directory tree under
645 * an indirect mount to trigger mounts. To allow for this we need to
646 * set the DMANAGED_AUTOMOUNT and DMANAGED_TRANSIT flags on the leaves
647 * of the directory tree. There is no need to clear the automount flag
648 * following a mount or restore it after an expire because these mounts
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300649 * are always covered. However, it is necessary to ensure that these
Ian Kentdd89f902011-01-14 18:46:35 +0000650 * flags are clear on non-empty directories to avoid unnecessary calls
651 * during path walks.
652 */
653static void autofs_set_leaf_automount_flags(struct dentry *dentry)
654{
655 struct dentry *parent;
656
657 /* root and dentrys in the root are already handled */
658 if (IS_ROOT(dentry->d_parent))
659 return;
660
661 managed_dentry_set_managed(dentry);
662
663 parent = dentry->d_parent;
664 /* only consider parents below dentrys in the root */
665 if (IS_ROOT(parent->d_parent))
666 return;
667 managed_dentry_clear_managed(parent);
Ian Kentdd89f902011-01-14 18:46:35 +0000668}
669
670static void autofs_clear_leaf_automount_flags(struct dentry *dentry)
671{
672 struct list_head *d_child;
673 struct dentry *parent;
674
675 /* flags for dentrys in the root are handled elsewhere */
676 if (IS_ROOT(dentry->d_parent))
677 return;
678
679 managed_dentry_clear_managed(dentry);
680
681 parent = dentry->d_parent;
682 /* only consider parents below dentrys in the root */
683 if (IS_ROOT(parent->d_parent))
684 return;
Al Viro946e51f2014-10-26 19:19:16 -0400685 d_child = &dentry->d_child;
Ian Kentdd89f902011-01-14 18:46:35 +0000686 /* Set parent managed if it's becoming empty */
687 if (d_child->next == &parent->d_subdirs &&
688 d_child->prev == &parent->d_subdirs)
689 managed_dentry_set_managed(parent);
Ian Kentdd89f902011-01-14 18:46:35 +0000690}
691
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692static int autofs4_dir_rmdir(struct inode *dir, struct dentry *dentry)
693{
694 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
695 struct autofs_info *ino = autofs4_dentry_ino(dentry);
Ian Kent1aff3c82006-03-27 01:14:46 -0800696 struct autofs_info *p_ino;
Ian Kent02667252016-03-15 14:58:36 -0700697
Ian Kent8a78d592016-03-15 14:58:45 -0700698 pr_debug("dentry %p, removing %pd\n", dentry, dentry);
Ian Kentf50b6f82007-02-20 13:58:10 -0800699
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 if (!autofs4_oz_mode(sbi))
701 return -EACCES;
702
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100703 spin_lock(&sbi->lookup_lock);
Ian Kent0259cb02012-12-14 10:23:29 +0800704 if (!simple_empty(dentry)) {
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100705 spin_unlock(&sbi->lookup_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 return -ENOTEMPTY;
707 }
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100708 __autofs4_add_expiring(dentry);
Ian Kent0259cb02012-12-14 10:23:29 +0800709 d_drop(dentry);
Ian Kente7854722011-03-25 01:51:31 +0800710 spin_unlock(&sbi->lookup_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711
Ian Kentdd89f902011-01-14 18:46:35 +0000712 if (sbi->version < 5)
713 autofs_clear_leaf_automount_flags(dentry);
714
Ian Kent1aff3c82006-03-27 01:14:46 -0800715 if (atomic_dec_and_test(&ino->count)) {
716 p_ino = autofs4_dentry_ino(dentry->d_parent);
717 if (p_ino && dentry->d_parent != dentry)
718 atomic_dec(&p_ino->count);
719 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 dput(ino->dentry);
David Howells2b0143b2015-03-17 22:25:59 +0000721 d_inode(dentry)->i_size = 0;
722 clear_nlink(d_inode(dentry));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723
724 if (dir->i_nlink)
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700725 drop_nlink(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726
727 return 0;
728}
729
Ian Kente9a7c2f2016-03-15 14:58:25 -0700730static int autofs4_dir_mkdir(struct inode *dir,
731 struct dentry *dentry, umode_t mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732{
733 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
734 struct autofs_info *ino = autofs4_dentry_ino(dentry);
Ian Kent1aff3c82006-03-27 01:14:46 -0800735 struct autofs_info *p_ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 struct inode *inode;
737
Sukadev Bhattiprolud78e53c2007-05-10 22:23:06 -0700738 if (!autofs4_oz_mode(sbi))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 return -EACCES;
740
Ian Kent8a78d592016-03-15 14:58:45 -0700741 pr_debug("dentry %p, creating %pd\n", dentry, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742
Al Viro5a37db32011-01-16 18:29:35 -0500743 BUG_ON(!ino);
744
Al Viro26e6c912011-01-16 18:43:40 -0500745 autofs4_clean_ino(ino);
Ian Kent25767372008-07-23 21:30:12 -0700746
Al Viro4b1ae272010-03-03 12:58:31 -0500747 autofs4_del_active(dentry);
748
Al Viro726a5e02011-01-16 17:43:52 -0500749 inode = autofs4_get_inode(dir->i_sb, S_IFDIR | 0555);
Al Viro5a37db32011-01-16 18:29:35 -0500750 if (!inode)
Ian Kent25767372008-07-23 21:30:12 -0700751 return -ENOMEM;
Ian Kent1864f7b2007-08-22 14:01:54 -0700752 d_add(dentry, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753
Ian Kentdd89f902011-01-14 18:46:35 +0000754 if (sbi->version < 5)
755 autofs_set_leaf_automount_flags(dentry);
756
Al Viro5a37db32011-01-16 18:29:35 -0500757 dget(dentry);
Ian Kent1aff3c82006-03-27 01:14:46 -0800758 atomic_inc(&ino->count);
759 p_ino = autofs4_dentry_ino(dentry->d_parent);
Rui Xiangc24930a2014-01-23 15:55:00 -0800760 if (p_ino && !IS_ROOT(dentry))
Ian Kent1aff3c82006-03-27 01:14:46 -0800761 atomic_inc(&p_ino->count);
Dave Hansend8c76e62006-09-30 23:29:04 -0700762 inc_nlink(dir);
Deepa Dinamani078cd822016-09-14 07:48:04 -0700763 dir->i_mtime = current_time(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764
765 return 0;
766}
767
768/* Get/set timeout ioctl() operation */
Arnd Bergmannc9243f52010-07-04 00:15:07 +0200769#ifdef CONFIG_COMPAT
770static inline int autofs4_compat_get_set_timeout(struct autofs_sb_info *sbi,
Ian Kente9a7c2f2016-03-15 14:58:25 -0700771 compat_ulong_t __user *p)
Arnd Bergmannc9243f52010-07-04 00:15:07 +0200772{
Arnd Bergmannc9243f52010-07-04 00:15:07 +0200773 unsigned long ntimeout;
Ian Kentaa330dd2016-03-15 14:58:28 -0700774 int rv;
Arnd Bergmannc9243f52010-07-04 00:15:07 +0200775
Ian Kentaa330dd2016-03-15 14:58:28 -0700776 rv = get_user(ntimeout, p);
777 if (rv)
778 goto error;
779
780 rv = put_user(sbi->exp_timeout/HZ, p);
781 if (rv)
782 goto error;
Arnd Bergmannc9243f52010-07-04 00:15:07 +0200783
784 if (ntimeout > UINT_MAX/HZ)
785 sbi->exp_timeout = 0;
786 else
787 sbi->exp_timeout = ntimeout * HZ;
788
789 return 0;
Ian Kentaa330dd2016-03-15 14:58:28 -0700790error:
791 return rv;
Arnd Bergmannc9243f52010-07-04 00:15:07 +0200792}
793#endif
794
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795static inline int autofs4_get_set_timeout(struct autofs_sb_info *sbi,
Ian Kente9a7c2f2016-03-15 14:58:25 -0700796 unsigned long __user *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 unsigned long ntimeout;
Ian Kentaa330dd2016-03-15 14:58:28 -0700799 int rv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800
Ian Kentaa330dd2016-03-15 14:58:28 -0700801 rv = get_user(ntimeout, p);
802 if (rv)
803 goto error;
804
805 rv = put_user(sbi->exp_timeout/HZ, p);
806 if (rv)
807 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808
Sukadev Bhattiprolud78e53c2007-05-10 22:23:06 -0700809 if (ntimeout > ULONG_MAX/HZ)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 sbi->exp_timeout = 0;
811 else
812 sbi->exp_timeout = ntimeout * HZ;
813
814 return 0;
Ian Kentaa330dd2016-03-15 14:58:28 -0700815error:
816 return rv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817}
818
819/* Return protocol version */
Ian Kente9a7c2f2016-03-15 14:58:25 -0700820static inline int autofs4_get_protover(struct autofs_sb_info *sbi,
821 int __user *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822{
823 return put_user(sbi->version, p);
824}
825
826/* Return protocol sub version */
Ian Kente9a7c2f2016-03-15 14:58:25 -0700827static inline int autofs4_get_protosubver(struct autofs_sb_info *sbi,
828 int __user *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829{
830 return put_user(sbi->sub_version, p);
831}
832
833/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834* Tells the daemon whether it can umount the autofs mount.
835*/
836static inline int autofs4_ask_umount(struct vfsmount *mnt, int __user *p)
837{
838 int status = 0;
839
Ian Kente3474a82006-03-27 01:14:51 -0800840 if (may_umount(mnt))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 status = 1;
842
Ian Kent8a78d592016-03-15 14:58:45 -0700843 pr_debug("returning %d\n", status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844
845 status = put_user(status, p);
846
847 return status;
848}
849
850/* Identify autofs4_dentries - this is so we can tell if there's
Ian Kente9a7c2f2016-03-15 14:58:25 -0700851 * an extra dentry refcount or not. We only hold a refcount on the
852 * dentry if its non-negative (ie, d_inode != NULL)
853 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854int is_autofs4_dentry(struct dentry *dentry)
855{
David Howells2b0143b2015-03-17 22:25:59 +0000856 return dentry && d_really_is_positive(dentry) &&
David Howellsb650c852011-01-15 10:51:57 +0000857 dentry->d_op == &autofs4_dentry_operations &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 dentry->d_fsdata != NULL;
859}
860
861/*
862 * ioctl()'s on the root directory is the chief method for the daemon to
863 * generate kernel reactions
864 */
Frederic Weisbecker3663df72010-05-19 15:08:17 +0200865static int autofs4_root_ioctl_unlocked(struct inode *inode, struct file *filp,
866 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867{
868 struct autofs_sb_info *sbi = autofs4_sbi(inode->i_sb);
869 void __user *p = (void __user *)arg;
870
Ian Kent8a78d592016-03-15 14:58:45 -0700871 pr_debug("cmd = 0x%08x, arg = 0x%08lx, sbi = %p, pgrp = %u\n",
872 cmd, arg, sbi, task_pgrp_nr(current));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873
Sukadev Bhattiprolud78e53c2007-05-10 22:23:06 -0700874 if (_IOC_TYPE(cmd) != _IOC_TYPE(AUTOFS_IOC_FIRST) ||
875 _IOC_NR(cmd) - _IOC_NR(AUTOFS_IOC_FIRST) >= AUTOFS_IOC_COUNT)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 return -ENOTTY;
Ian Kent02667252016-03-15 14:58:36 -0700877
Sukadev Bhattiprolud78e53c2007-05-10 22:23:06 -0700878 if (!autofs4_oz_mode(sbi) && !capable(CAP_SYS_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 return -EPERM;
Ian Kent02667252016-03-15 14:58:36 -0700880
Ian Kente9a7c2f2016-03-15 14:58:25 -0700881 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 case AUTOFS_IOC_READY: /* Wait queue: go ahead and retry */
Ian Kente9a7c2f2016-03-15 14:58:25 -0700883 return autofs4_wait_release(sbi, (autofs_wqt_t) arg, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 case AUTOFS_IOC_FAIL: /* Wait queue: fail with ENOENT */
Ian Kente9a7c2f2016-03-15 14:58:25 -0700885 return autofs4_wait_release(sbi, (autofs_wqt_t) arg, -ENOENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 case AUTOFS_IOC_CATATONIC: /* Enter catatonic mode (daemon shutdown) */
887 autofs4_catatonic_mode(sbi);
888 return 0;
889 case AUTOFS_IOC_PROTOVER: /* Get protocol version */
890 return autofs4_get_protover(sbi, p);
891 case AUTOFS_IOC_PROTOSUBVER: /* Get protocol sub version */
892 return autofs4_get_protosubver(sbi, p);
893 case AUTOFS_IOC_SETTIMEOUT:
894 return autofs4_get_set_timeout(sbi, p);
Arnd Bergmannc9243f52010-07-04 00:15:07 +0200895#ifdef CONFIG_COMPAT
896 case AUTOFS_IOC_SETTIMEOUT32:
897 return autofs4_compat_get_set_timeout(sbi, p);
898#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 case AUTOFS_IOC_ASKUMOUNT:
Josef "Jeff" Sipeka4669ed2006-12-08 02:36:46 -0800901 return autofs4_ask_umount(filp->f_path.mnt, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902
903 /* return a single thing to expire */
904 case AUTOFS_IOC_EXPIRE:
Ian Kente9a7c2f2016-03-15 14:58:25 -0700905 return autofs4_expire_run(inode->i_sb,
906 filp->f_path.mnt, sbi, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 /* same as above, but can send multiple expires through pipe */
908 case AUTOFS_IOC_EXPIRE_MULTI:
Ian Kente9a7c2f2016-03-15 14:58:25 -0700909 return autofs4_expire_multi(inode->i_sb,
910 filp->f_path.mnt, sbi, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911
912 default:
Ian Kente3cd8062016-03-15 14:58:33 -0700913 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 }
915}
Frederic Weisbecker3663df72010-05-19 15:08:17 +0200916
917static long autofs4_root_ioctl(struct file *filp,
918 unsigned int cmd, unsigned long arg)
919{
Al Viro496ad9a2013-01-23 17:07:38 -0500920 struct inode *inode = file_inode(filp);
Ian Kente9a7c2f2016-03-15 14:58:25 -0700921
Ian Kentde47de72010-12-07 13:04:00 +0800922 return autofs4_root_ioctl_unlocked(inode, filp, cmd, arg);
Frederic Weisbecker3663df72010-05-19 15:08:17 +0200923}
Arnd Bergmannc9243f52010-07-04 00:15:07 +0200924
925#ifdef CONFIG_COMPAT
926static long autofs4_root_compat_ioctl(struct file *filp,
Ian Kente9a7c2f2016-03-15 14:58:25 -0700927 unsigned int cmd, unsigned long arg)
Arnd Bergmannc9243f52010-07-04 00:15:07 +0200928{
Al Viro496ad9a2013-01-23 17:07:38 -0500929 struct inode *inode = file_inode(filp);
Arnd Bergmannc9243f52010-07-04 00:15:07 +0200930 int ret;
931
Arnd Bergmannc9243f52010-07-04 00:15:07 +0200932 if (cmd == AUTOFS_IOC_READY || cmd == AUTOFS_IOC_FAIL)
933 ret = autofs4_root_ioctl_unlocked(inode, filp, cmd, arg);
934 else
935 ret = autofs4_root_ioctl_unlocked(inode, filp, cmd,
Ian Kente9a7c2f2016-03-15 14:58:25 -0700936 (unsigned long) compat_ptr(arg));
Arnd Bergmannc9243f52010-07-04 00:15:07 +0200937
938 return ret;
939}
940#endif