blob: d34896cfb19f1512855d907b9d4c8c6b4cac2e09 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* -*- 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>
Ian Kent34ca9592006-03-27 01:14:54 -08007 * Copyright 2001-2006 Ian Kent <raven@themaw.net>
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 *
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
Randy Dunlap16f7e0f2006-01-11 12:17:46 -080015#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/errno.h>
17#include <linux/stat.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090018#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/param.h>
20#include <linux/time.h>
Arnd Bergmannc9243f52010-07-04 00:15:07 +020021#include <linux/compat.h>
Arnd Bergmann00e300e2010-09-14 23:00:34 +020022#include <linux/mutex.h>
Arnd Bergmannc9243f52010-07-04 00:15:07 +020023
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include "autofs_i.h"
25
26static int autofs4_dir_symlink(struct inode *,struct dentry *,const char *);
27static int autofs4_dir_unlink(struct inode *,struct dentry *);
28static int autofs4_dir_rmdir(struct inode *,struct dentry *);
29static int autofs4_dir_mkdir(struct inode *,struct dentry *,int);
Frederic Weisbecker3663df72010-05-19 15:08:17 +020030static long autofs4_root_ioctl(struct file *,unsigned int,unsigned long);
Felipe Contreras5a44a732010-09-24 15:22:23 +020031#ifdef CONFIG_COMPAT
Arnd Bergmannc9243f52010-07-04 00:15:07 +020032static long autofs4_root_compat_ioctl(struct file *,unsigned int,unsigned long);
Felipe Contreras5a44a732010-09-24 15:22:23 +020033#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070034static int autofs4_dir_open(struct inode *inode, struct file *file);
Linus Torvalds1da177e2005-04-16 15:20:36 -070035static struct dentry *autofs4_lookup(struct inode *,struct dentry *, struct nameidata *);
Ian Kent34ca9592006-03-27 01:14:54 -080036static void *autofs4_follow_link(struct dentry *, struct nameidata *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
Ian Kent6d5cb922008-07-23 21:30:15 -070038#define TRIGGER_FLAGS (LOOKUP_CONTINUE | LOOKUP_DIRECTORY)
39#define TRIGGER_INTENTS (LOOKUP_OPEN | LOOKUP_CREATE)
40
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -080041const struct file_operations autofs4_root_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070042 .open = dcache_dir_open,
43 .release = dcache_dir_close,
44 .read = generic_read_dir,
Ian Kentaa55ddf2008-07-23 21:30:29 -070045 .readdir = dcache_readdir,
Al Viro59af1582008-08-24 07:24:41 -040046 .llseek = dcache_dir_lseek,
Frederic Weisbecker3663df72010-05-19 15:08:17 +020047 .unlocked_ioctl = autofs4_root_ioctl,
Arnd Bergmannc9243f52010-07-04 00:15:07 +020048#ifdef CONFIG_COMPAT
49 .compat_ioctl = autofs4_root_compat_ioctl,
50#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070051};
52
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -080053const struct file_operations autofs4_dir_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070054 .open = autofs4_dir_open,
Ian Kentff9cd492008-07-23 21:30:24 -070055 .release = dcache_dir_close,
Linus Torvalds1da177e2005-04-16 15:20:36 -070056 .read = generic_read_dir,
Ian Kentff9cd492008-07-23 21:30:24 -070057 .readdir = dcache_readdir,
Al Viro59af1582008-08-24 07:24:41 -040058 .llseek = dcache_dir_lseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -070059};
60
Arjan van de Ven754661f2007-02-12 00:55:38 -080061const struct inode_operations autofs4_indirect_root_inode_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 .lookup = autofs4_lookup,
63 .unlink = autofs4_dir_unlink,
64 .symlink = autofs4_dir_symlink,
65 .mkdir = autofs4_dir_mkdir,
66 .rmdir = autofs4_dir_rmdir,
67};
68
Arjan van de Ven754661f2007-02-12 00:55:38 -080069const struct inode_operations autofs4_direct_root_inode_operations = {
Ian Kent34ca9592006-03-27 01:14:54 -080070 .lookup = autofs4_lookup,
Ian Kent871f9432006-03-27 01:14:58 -080071 .unlink = autofs4_dir_unlink,
72 .mkdir = autofs4_dir_mkdir,
73 .rmdir = autofs4_dir_rmdir,
Ian Kent34ca9592006-03-27 01:14:54 -080074 .follow_link = autofs4_follow_link,
75};
76
Arjan van de Ven754661f2007-02-12 00:55:38 -080077const struct inode_operations autofs4_dir_inode_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 .lookup = autofs4_lookup,
79 .unlink = autofs4_dir_unlink,
80 .symlink = autofs4_dir_symlink,
81 .mkdir = autofs4_dir_mkdir,
82 .rmdir = autofs4_dir_rmdir,
83};
84
Ian Kent4f8427d2009-12-15 16:45:42 -080085static void autofs4_add_active(struct dentry *dentry)
86{
87 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
88 struct autofs_info *ino = autofs4_dentry_ino(dentry);
89 if (ino) {
90 spin_lock(&sbi->lookup_lock);
91 if (!ino->active_count) {
92 if (list_empty(&ino->active))
93 list_add(&ino->active, &sbi->active_list);
94 }
95 ino->active_count++;
96 spin_unlock(&sbi->lookup_lock);
97 }
98 return;
99}
100
101static void autofs4_del_active(struct dentry *dentry)
102{
103 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
104 struct autofs_info *ino = autofs4_dentry_ino(dentry);
105 if (ino) {
106 spin_lock(&sbi->lookup_lock);
107 ino->active_count--;
108 if (!ino->active_count) {
109 if (!list_empty(&ino->active))
110 list_del_init(&ino->active);
111 }
112 spin_unlock(&sbi->lookup_lock);
113 }
114 return;
115}
116
Ian Kent36b64132009-12-15 16:45:44 -0800117static unsigned int autofs4_need_mount(unsigned int flags)
118{
119 unsigned int res = 0;
120 if (flags & (TRIGGER_FLAGS | TRIGGER_INTENTS))
121 res = 1;
122 return res;
123}
124
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125static int autofs4_dir_open(struct inode *inode, struct file *file)
126{
Josef "Jeff" Sipeka4669ed2006-12-08 02:36:46 -0800127 struct dentry *dentry = file->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
Ian Kentf360ce32006-03-27 01:14:43 -0800129
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 DPRINTK("file=%p dentry=%p %.*s",
131 file, dentry, dentry->d_name.len, dentry->d_name.name);
132
133 if (autofs4_oz_mode(sbi))
134 goto out;
135
Ian Kentff9cd492008-07-23 21:30:24 -0700136 /*
137 * An empty directory in an autofs file system is always a
138 * mount point. The daemon must have failed to mount this
139 * during lookup so it doesn't exist. This can happen, for
140 * example, if user space returns an incorrect status for a
141 * mount request. Otherwise we're doing a readdir on the
142 * autofs file system so just let the libfs routines handle
143 * it.
144 */
145 spin_lock(&dcache_lock);
Ian Kentc42c7f72009-12-15 16:45:48 -0800146 if (!d_mountpoint(dentry) && list_empty(&dentry->d_subdirs)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 spin_unlock(&dcache_lock);
Ian Kentff9cd492008-07-23 21:30:24 -0700148 return -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 }
Ian Kentff9cd492008-07-23 21:30:24 -0700150 spin_unlock(&dcache_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151
Ian Kentf360ce32006-03-27 01:14:43 -0800152out:
Ian Kentff9cd492008-07-23 21:30:24 -0700153 return dcache_dir_open(inode, file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154}
155
Al Viro4b1ae272010-03-03 12:58:31 -0500156static int try_to_fill_dentry(struct dentry *dentry, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157{
Ian Kent862b1102006-03-27 01:14:48 -0800158 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
Ian Kent718c6042006-03-27 01:14:42 -0800159 struct autofs_info *ino = autofs4_dentry_ino(dentry);
Jeff Moyer9d2de6a2008-05-01 04:35:09 -0700160 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 DPRINTK("dentry=%p %.*s ino=%p",
163 dentry, dentry->d_name.len, dentry->d_name.name, dentry->d_inode);
164
Ian Kent718c6042006-03-27 01:14:42 -0800165 /*
166 * Wait for a pending mount, triggering one if there
167 * isn't one already
168 */
Al Viro4b1ae272010-03-03 12:58:31 -0500169 if (dentry->d_inode == NULL) {
170 DPRINTK("waiting for mount name=%.*s",
171 dentry->d_name.len, dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172
Al Viro4b1ae272010-03-03 12:58:31 -0500173 status = autofs4_wait(sbi, dentry, NFY_MOUNT);
Ian Kent718c6042006-03-27 01:14:42 -0800174
Al Viro4b1ae272010-03-03 12:58:31 -0500175 DPRINTK("mount done status=%d", status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176
Al Viro4b1ae272010-03-03 12:58:31 -0500177 /* Turn this into a real negative dentry? */
178 if (status == -ENOENT) {
179 spin_lock(&sbi->fs_lock);
180 ino->flags &= ~AUTOFS_INF_PENDING;
181 spin_unlock(&sbi->fs_lock);
182 return status;
183 } else if (status) {
184 /* Return a negative dentry, but leave it "pending" */
185 return status;
186 }
187 /* Trigger mount for path component or follow link */
188 } else if (ino->flags & AUTOFS_INF_PENDING ||
Ian Kentf7422462010-05-10 16:46:08 +0800189 autofs4_need_mount(flags)) {
Al Viro4b1ae272010-03-03 12:58:31 -0500190 DPRINTK("waiting for mount name=%.*s",
191 dentry->d_name.len, dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192
Al Viro4b1ae272010-03-03 12:58:31 -0500193 spin_lock(&sbi->fs_lock);
194 ino->flags |= AUTOFS_INF_PENDING;
195 spin_unlock(&sbi->fs_lock);
196 status = autofs4_wait(sbi, dentry, NFY_MOUNT);
197
198 DPRINTK("mount done status=%d", status);
199
200 if (status) {
201 spin_lock(&sbi->fs_lock);
202 ino->flags &= ~AUTOFS_INF_PENDING;
203 spin_unlock(&sbi->fs_lock);
204 return status;
205 }
206 }
207
208 /* Initialize expiry counter after successful mount */
Dan Carpenter5fc79d82010-08-10 18:02:04 -0700209 ino->last_used = jiffies;
Al Viro4b1ae272010-03-03 12:58:31 -0500210
211 spin_lock(&sbi->fs_lock);
212 ino->flags &= ~AUTOFS_INF_PENDING;
213 spin_unlock(&sbi->fs_lock);
214
215 return 0;
Ian Kent34ca9592006-03-27 01:14:54 -0800216}
217
218/* For autofs direct mounts the follow link triggers the mount */
219static void *autofs4_follow_link(struct dentry *dentry, struct nameidata *nd)
220{
221 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
Ian Kenta5370552006-05-15 09:43:51 -0700222 struct autofs_info *ino = autofs4_dentry_ino(dentry);
Ian Kent34ca9592006-03-27 01:14:54 -0800223 int oz_mode = autofs4_oz_mode(sbi);
224 unsigned int lookup_type;
225 int status;
226
227 DPRINTK("dentry=%p %.*s oz_mode=%d nd->flags=%d",
228 dentry, dentry->d_name.len, dentry->d_name.name, oz_mode,
229 nd->flags);
Ian Kent6e60a9a2008-07-23 21:30:27 -0700230 /*
231 * For an expire of a covered direct or offset mount we need
Al Viro9393bd02009-04-18 13:58:15 -0400232 * to break out of follow_down() at the autofs mount trigger
Ian Kent6e60a9a2008-07-23 21:30:27 -0700233 * (d_mounted--), so we can see the expiring flag, and manage
234 * the blocking and following here until the expire is completed.
235 */
236 if (oz_mode) {
237 spin_lock(&sbi->fs_lock);
238 if (ino->flags & AUTOFS_INF_EXPIRING) {
239 spin_unlock(&sbi->fs_lock);
240 /* Follow down to our covering mount. */
Al Viro9393bd02009-04-18 13:58:15 -0400241 if (!follow_down(&nd->path))
Ian Kent6e60a9a2008-07-23 21:30:27 -0700242 goto done;
Ian Kentec6e8c72008-07-23 21:30:28 -0700243 goto follow;
Ian Kent6e60a9a2008-07-23 21:30:27 -0700244 }
245 spin_unlock(&sbi->fs_lock);
Ian Kent34ca9592006-03-27 01:14:54 -0800246 goto done;
Ian Kent6e60a9a2008-07-23 21:30:27 -0700247 }
Ian Kent34ca9592006-03-27 01:14:54 -0800248
Ian Kent6e60a9a2008-07-23 21:30:27 -0700249 /* If an expire request is pending everyone must wait. */
Ian Kent06a35982008-07-23 21:30:28 -0700250 autofs4_expire_wait(dentry);
Ian Kent97e74492008-07-23 21:30:26 -0700251
Ian Kent6e60a9a2008-07-23 21:30:27 -0700252 /* We trigger a mount for almost all flags */
Ian Kent36b64132009-12-15 16:45:44 -0800253 lookup_type = autofs4_need_mount(nd->flags);
Ian Kentaa952eb2009-12-15 16:45:45 -0800254 spin_lock(&sbi->fs_lock);
255 spin_lock(&dcache_lock);
256 if (!(lookup_type || ino->flags & AUTOFS_INF_PENDING)) {
257 spin_unlock(&dcache_lock);
258 spin_unlock(&sbi->fs_lock);
Ian Kentec6e8c72008-07-23 21:30:28 -0700259 goto follow;
Ian Kentaa952eb2009-12-15 16:45:45 -0800260 }
Ian Kent6e60a9a2008-07-23 21:30:27 -0700261
Ian Kent871f9432006-03-27 01:14:58 -0800262 /*
Ian Kent6e60a9a2008-07-23 21:30:27 -0700263 * If the dentry contains directories then it is an autofs
264 * multi-mount with no root mount offset. So don't try to
265 * mount it again.
Ian Kent871f9432006-03-27 01:14:58 -0800266 */
Ian Kentaa952eb2009-12-15 16:45:45 -0800267 if (ino->flags & AUTOFS_INF_PENDING ||
Ian Kentc42c7f72009-12-15 16:45:48 -0800268 (!d_mountpoint(dentry) && list_empty(&dentry->d_subdirs))) {
Ian Kent871f9432006-03-27 01:14:58 -0800269 spin_unlock(&dcache_lock);
Ian Kentaa952eb2009-12-15 16:45:45 -0800270 spin_unlock(&sbi->fs_lock);
Ian Kent871f9432006-03-27 01:14:58 -0800271
Ian Kentf7422462010-05-10 16:46:08 +0800272 status = try_to_fill_dentry(dentry, nd->flags);
Ian Kent871f9432006-03-27 01:14:58 -0800273 if (status)
274 goto out_error;
275
Ian Kent6e60a9a2008-07-23 21:30:27 -0700276 goto follow;
Ian Kent871f9432006-03-27 01:14:58 -0800277 }
278 spin_unlock(&dcache_lock);
Ian Kentaa952eb2009-12-15 16:45:45 -0800279 spin_unlock(&sbi->fs_lock);
Ian Kent6e60a9a2008-07-23 21:30:27 -0700280follow:
281 /*
282 * If there is no root mount it must be an autofs
283 * multi-mount with no root offset so we don't need
284 * to follow it.
285 */
286 if (d_mountpoint(dentry)) {
Al Viro9393bd02009-04-18 13:58:15 -0400287 if (!autofs4_follow_mount(&nd->path)) {
Ian Kent6e60a9a2008-07-23 21:30:27 -0700288 status = -ENOENT;
289 goto out_error;
290 }
291 }
Ian Kent871f9432006-03-27 01:14:58 -0800292
Ian Kent34ca9592006-03-27 01:14:54 -0800293done:
294 return NULL;
295
296out_error:
Jan Blunck1d957f92008-02-14 19:34:35 -0800297 path_put(&nd->path);
Ian Kent34ca9592006-03-27 01:14:54 -0800298 return ERR_PTR(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299}
300
301/*
302 * Revalidate is called on every cache lookup. Some of those
303 * cache lookups may actually happen while the dentry is not
304 * yet completely filled in, and revalidate has to delay such
305 * lookups..
306 */
Ian Kent718c6042006-03-27 01:14:42 -0800307static int autofs4_revalidate(struct dentry *dentry, struct nameidata *nd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308{
Ian Kent718c6042006-03-27 01:14:42 -0800309 struct inode *dir = dentry->d_parent->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
Al Viro4b1ae272010-03-03 12:58:31 -0500311 int oz_mode = autofs4_oz_mode(sbi);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 int flags = nd ? nd->flags : 0;
Al Viro4b1ae272010-03-03 12:58:31 -0500313 int status = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314
Ian Kent213614d2009-12-15 16:45:51 -0800315 /* Pending dentry */
Al Viro4b1ae272010-03-03 12:58:31 -0500316 spin_lock(&sbi->fs_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 if (autofs4_ispending(dentry)) {
Al Viro4b1ae272010-03-03 12:58:31 -0500318 /* The daemon never causes a mount to trigger */
Ian Kent213614d2009-12-15 16:45:51 -0800319 spin_unlock(&sbi->fs_lock);
Al Viro4b1ae272010-03-03 12:58:31 -0500320
321 if (oz_mode)
322 return 1;
Ian Kentbcdc5e02006-09-27 01:50:44 -0700323
324 /*
Ian Kent06a35982008-07-23 21:30:28 -0700325 * If the directory has gone away due to an expire
326 * we have been called as ->d_revalidate() and so
327 * we need to return false and proceed to ->lookup().
328 */
329 if (autofs4_expire_wait(dentry) == -EAGAIN)
330 return 0;
331
332 /*
Ian Kentbcdc5e02006-09-27 01:50:44 -0700333 * A zero status is success otherwise we have a
334 * negative error code.
335 */
Al Viro4b1ae272010-03-03 12:58:31 -0500336 status = try_to_fill_dentry(dentry, flags);
Ian Kentbcdc5e02006-09-27 01:50:44 -0700337 if (status == 0)
Ian Kentf50b6f82007-02-20 13:58:10 -0800338 return 1;
339
Ian Kentbcdc5e02006-09-27 01:50:44 -0700340 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 }
Al Viro4b1ae272010-03-03 12:58:31 -0500342 spin_unlock(&sbi->fs_lock);
343
344 /* Negative dentry.. invalidate if "old" */
345 if (dentry->d_inode == NULL)
346 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347
348 /* Check for a non-mountpoint directory with no contents */
Al Viro4b1ae272010-03-03 12:58:31 -0500349 spin_lock(&dcache_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 if (S_ISDIR(dentry->d_inode->i_mode) &&
Ian Kentc42c7f72009-12-15 16:45:48 -0800351 !d_mountpoint(dentry) && list_empty(&dentry->d_subdirs)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 DPRINTK("dentry=%p %.*s, emptydir",
353 dentry, dentry->d_name.len, dentry->d_name.name);
Al Viro4b1ae272010-03-03 12:58:31 -0500354 spin_unlock(&dcache_lock);
Ian Kent97e74492008-07-23 21:30:26 -0700355
Al Viro4b1ae272010-03-03 12:58:31 -0500356 /* The daemon never causes a mount to trigger */
357 if (oz_mode)
358 return 1;
Ian Kentbcdc5e02006-09-27 01:50:44 -0700359
Al Viro4b1ae272010-03-03 12:58:31 -0500360 /*
361 * A zero status is success otherwise we have a
362 * negative error code.
363 */
364 status = try_to_fill_dentry(dentry, flags);
365 if (status == 0)
366 return 1;
Ian Kentbcdc5e02006-09-27 01:50:44 -0700367
Al Viro4b1ae272010-03-03 12:58:31 -0500368 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 }
370 spin_unlock(&dcache_lock);
371
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 return 1;
373}
374
Ian Kent34ca9592006-03-27 01:14:54 -0800375void autofs4_dentry_release(struct dentry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376{
377 struct autofs_info *inf;
378
379 DPRINTK("releasing %p", de);
380
381 inf = autofs4_dentry_ino(de);
382 de->d_fsdata = NULL;
383
384 if (inf) {
Ian Kentf50b6f82007-02-20 13:58:10 -0800385 struct autofs_sb_info *sbi = autofs4_sbi(de->d_sb);
386
Ian Kentf50b6f82007-02-20 13:58:10 -0800387 if (sbi) {
Ian Kent5f6f4f22008-07-23 21:30:09 -0700388 spin_lock(&sbi->lookup_lock);
Ian Kent25767372008-07-23 21:30:12 -0700389 if (!list_empty(&inf->active))
390 list_del(&inf->active);
Ian Kent5f6f4f22008-07-23 21:30:09 -0700391 if (!list_empty(&inf->expiring))
392 list_del(&inf->expiring);
393 spin_unlock(&sbi->lookup_lock);
Ian Kentf50b6f82007-02-20 13:58:10 -0800394 }
395
Jeff Mahoneyc3724b12007-04-11 23:28:46 -0700396 inf->dentry = NULL;
397 inf->inode = NULL;
398
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 autofs4_free_ino(inf);
400 }
401}
402
403/* For dentries of directories in the root dir */
Al Viro08f11512009-02-20 05:56:19 +0000404static const struct dentry_operations autofs4_root_dentry_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 .d_revalidate = autofs4_revalidate,
406 .d_release = autofs4_dentry_release,
407};
408
409/* For other dentries */
Al Viro08f11512009-02-20 05:56:19 +0000410static const struct dentry_operations autofs4_dentry_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 .d_revalidate = autofs4_revalidate,
412 .d_release = autofs4_dentry_release,
413};
414
Ian Kent6510c9d2009-12-15 16:45:47 -0800415static struct dentry *autofs4_lookup_active(struct dentry *dentry)
Ian Kent25767372008-07-23 21:30:12 -0700416{
Ian Kent6510c9d2009-12-15 16:45:47 -0800417 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
418 struct dentry *parent = dentry->d_parent;
419 struct qstr *name = &dentry->d_name;
Ian Kent25767372008-07-23 21:30:12 -0700420 unsigned int len = name->len;
421 unsigned int hash = name->hash;
422 const unsigned char *str = name->name;
423 struct list_head *p, *head;
424
425 spin_lock(&dcache_lock);
426 spin_lock(&sbi->lookup_lock);
427 head = &sbi->active_list;
428 list_for_each(p, head) {
429 struct autofs_info *ino;
Ian Kente4d5ade2009-12-15 16:45:49 -0800430 struct dentry *active;
Ian Kent25767372008-07-23 21:30:12 -0700431 struct qstr *qstr;
432
433 ino = list_entry(p, struct autofs_info, active);
Ian Kente4d5ade2009-12-15 16:45:49 -0800434 active = ino->dentry;
Ian Kent25767372008-07-23 21:30:12 -0700435
Ian Kente4d5ade2009-12-15 16:45:49 -0800436 spin_lock(&active->d_lock);
Ian Kent25767372008-07-23 21:30:12 -0700437
438 /* Already gone? */
Ian Kente4d5ade2009-12-15 16:45:49 -0800439 if (atomic_read(&active->d_count) == 0)
Ian Kent25767372008-07-23 21:30:12 -0700440 goto next;
441
Ian Kente4d5ade2009-12-15 16:45:49 -0800442 qstr = &active->d_name;
Ian Kent25767372008-07-23 21:30:12 -0700443
Ian Kente4d5ade2009-12-15 16:45:49 -0800444 if (active->d_name.hash != hash)
Ian Kent25767372008-07-23 21:30:12 -0700445 goto next;
Ian Kente4d5ade2009-12-15 16:45:49 -0800446 if (active->d_parent != parent)
Ian Kent25767372008-07-23 21:30:12 -0700447 goto next;
448
449 if (qstr->len != len)
450 goto next;
451 if (memcmp(qstr->name, str, len))
452 goto next;
453
Al Viro4b1ae272010-03-03 12:58:31 -0500454 if (d_unhashed(active)) {
455 dget(active);
456 spin_unlock(&active->d_lock);
457 spin_unlock(&sbi->lookup_lock);
458 spin_unlock(&dcache_lock);
459 return active;
460 }
Ian Kent25767372008-07-23 21:30:12 -0700461next:
Ian Kente4d5ade2009-12-15 16:45:49 -0800462 spin_unlock(&active->d_lock);
Ian Kent25767372008-07-23 21:30:12 -0700463 }
464 spin_unlock(&sbi->lookup_lock);
465 spin_unlock(&dcache_lock);
466
467 return NULL;
468}
469
Ian Kent6510c9d2009-12-15 16:45:47 -0800470static struct dentry *autofs4_lookup_expiring(struct dentry *dentry)
Ian Kentf50b6f82007-02-20 13:58:10 -0800471{
Ian Kent6510c9d2009-12-15 16:45:47 -0800472 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
473 struct dentry *parent = dentry->d_parent;
474 struct qstr *name = &dentry->d_name;
Ian Kentf50b6f82007-02-20 13:58:10 -0800475 unsigned int len = name->len;
476 unsigned int hash = name->hash;
477 const unsigned char *str = name->name;
478 struct list_head *p, *head;
479
480 spin_lock(&dcache_lock);
Ian Kent5f6f4f22008-07-23 21:30:09 -0700481 spin_lock(&sbi->lookup_lock);
482 head = &sbi->expiring_list;
Ian Kentf50b6f82007-02-20 13:58:10 -0800483 list_for_each(p, head) {
484 struct autofs_info *ino;
Ian Kentcb4b4922009-12-15 16:45:50 -0800485 struct dentry *expiring;
Ian Kentf50b6f82007-02-20 13:58:10 -0800486 struct qstr *qstr;
487
Ian Kent5f6f4f22008-07-23 21:30:09 -0700488 ino = list_entry(p, struct autofs_info, expiring);
Ian Kentcb4b4922009-12-15 16:45:50 -0800489 expiring = ino->dentry;
Ian Kentf50b6f82007-02-20 13:58:10 -0800490
Ian Kentcb4b4922009-12-15 16:45:50 -0800491 spin_lock(&expiring->d_lock);
Ian Kentf50b6f82007-02-20 13:58:10 -0800492
493 /* Bad luck, we've already been dentry_iput */
Ian Kentcb4b4922009-12-15 16:45:50 -0800494 if (!expiring->d_inode)
Ian Kentf50b6f82007-02-20 13:58:10 -0800495 goto next;
496
Ian Kentcb4b4922009-12-15 16:45:50 -0800497 qstr = &expiring->d_name;
Ian Kentf50b6f82007-02-20 13:58:10 -0800498
Ian Kentcb4b4922009-12-15 16:45:50 -0800499 if (expiring->d_name.hash != hash)
Ian Kentf50b6f82007-02-20 13:58:10 -0800500 goto next;
Ian Kentcb4b4922009-12-15 16:45:50 -0800501 if (expiring->d_parent != parent)
Ian Kentf50b6f82007-02-20 13:58:10 -0800502 goto next;
503
504 if (qstr->len != len)
505 goto next;
506 if (memcmp(qstr->name, str, len))
507 goto next;
508
Al Viro4b1ae272010-03-03 12:58:31 -0500509 if (d_unhashed(expiring)) {
510 dget(expiring);
511 spin_unlock(&expiring->d_lock);
512 spin_unlock(&sbi->lookup_lock);
513 spin_unlock(&dcache_lock);
514 return expiring;
515 }
Ian Kentf50b6f82007-02-20 13:58:10 -0800516next:
Ian Kentcb4b4922009-12-15 16:45:50 -0800517 spin_unlock(&expiring->d_lock);
Ian Kentf50b6f82007-02-20 13:58:10 -0800518 }
Ian Kent5f6f4f22008-07-23 21:30:09 -0700519 spin_unlock(&sbi->lookup_lock);
Ian Kentf50b6f82007-02-20 13:58:10 -0800520 spin_unlock(&dcache_lock);
521
522 return NULL;
523}
524
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525/* Lookups in the root directory */
526static struct dentry *autofs4_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
527{
528 struct autofs_sb_info *sbi;
Ian Kent25767372008-07-23 21:30:12 -0700529 struct autofs_info *ino;
Ian Kent90387c92009-12-15 16:45:46 -0800530 struct dentry *expiring, *active;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 int oz_mode;
532
533 DPRINTK("name = %.*s",
534 dentry->d_name.len, dentry->d_name.name);
535
Ian Kent718c6042006-03-27 01:14:42 -0800536 /* File name too long to exist */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 if (dentry->d_name.len > NAME_MAX)
Ian Kent718c6042006-03-27 01:14:42 -0800538 return ERR_PTR(-ENAMETOOLONG);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539
540 sbi = autofs4_sbi(dir->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 oz_mode = autofs4_oz_mode(sbi);
Ian Kent718c6042006-03-27 01:14:42 -0800542
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 DPRINTK("pid = %u, pgrp = %u, catatonic = %d, oz_mode = %d",
Pavel Emelianova47afb02007-10-18 23:39:46 -0700544 current->pid, task_pgrp_nr(current), sbi->catatonic, oz_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545
Ian Kent6510c9d2009-12-15 16:45:47 -0800546 active = autofs4_lookup_active(dentry);
Ian Kent90387c92009-12-15 16:45:46 -0800547 if (active) {
548 dentry = active;
Ian Kentaa952eb2009-12-15 16:45:45 -0800549 ino = autofs4_dentry_ino(dentry);
550 } else {
Al Viro4b1ae272010-03-03 12:58:31 -0500551 /*
552 * Mark the dentry incomplete but don't hash it. We do this
553 * to serialize our inode creation operations (symlink and
554 * mkdir) which prevents deadlock during the callback to
555 * the daemon. Subsequent user space lookups for the same
556 * dentry are placed on the wait queue while the daemon
557 * itself is allowed passage unresticted so the create
558 * operation itself can then hash the dentry. Finally,
559 * we check for the hashed dentry and return the newly
560 * hashed dentry.
561 */
562 dentry->d_op = &autofs4_root_dentry_operations;
563
564 /*
565 * And we need to ensure that the same dentry is used for
566 * all following lookup calls until it is hashed so that
567 * the dentry flags are persistent throughout the request.
568 */
569 ino = autofs4_init_ino(NULL, sbi, 0555);
570 if (!ino)
571 return ERR_PTR(-ENOMEM);
572
573 dentry->d_fsdata = ino;
574 ino->dentry = dentry;
575
576 autofs4_add_active(dentry);
577
578 d_instantiate(dentry, NULL);
Ian Kent25767372008-07-23 21:30:12 -0700579 }
Ian Kent5f6f4f22008-07-23 21:30:09 -0700580
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 if (!oz_mode) {
Ian Kent213614d2009-12-15 16:45:51 -0800582 mutex_unlock(&dir->i_mutex);
Al Viro4b1ae272010-03-03 12:58:31 -0500583 expiring = autofs4_lookup_expiring(dentry);
Ian Kent8f63aaa8b2009-03-31 15:24:45 -0700584 if (expiring) {
585 /*
586 * If we are racing with expire the request might not
587 * be quite complete but the directory has been removed
588 * so it must have been successful, so just wait for it.
589 */
Ian Kent8f63aaa8b2009-03-31 15:24:45 -0700590 autofs4_expire_wait(expiring);
Al Viro4b1ae272010-03-03 12:58:31 -0500591 autofs4_del_expiring(expiring);
Ian Kent8f63aaa8b2009-03-31 15:24:45 -0700592 dput(expiring);
593 }
Al Viro4b1ae272010-03-03 12:58:31 -0500594
Ian Kent213614d2009-12-15 16:45:51 -0800595 spin_lock(&sbi->fs_lock);
Al Viro4b1ae272010-03-03 12:58:31 -0500596 ino->flags |= AUTOFS_INF_PENDING;
Ian Kent213614d2009-12-15 16:45:51 -0800597 spin_unlock(&sbi->fs_lock);
Al Viro4b1ae272010-03-03 12:58:31 -0500598 if (dentry->d_op && dentry->d_op->d_revalidate)
599 (dentry->d_op->d_revalidate)(dentry, nd);
600 mutex_lock(&dir->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 }
602
603 /*
Al Viro4b1ae272010-03-03 12:58:31 -0500604 * If we are still pending, check if we had to handle
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 * a signal. If so we can force a restart..
606 */
Al Viro4b1ae272010-03-03 12:58:31 -0500607 if (ino->flags & AUTOFS_INF_PENDING) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 /* See if we were interrupted */
609 if (signal_pending(current)) {
610 sigset_t *sigset = &current->pending.signal;
611 if (sigismember (sigset, SIGKILL) ||
612 sigismember (sigset, SIGQUIT) ||
613 sigismember (sigset, SIGINT)) {
Ian Kent90387c92009-12-15 16:45:46 -0800614 if (active)
615 dput(active);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 return ERR_PTR(-ERESTARTNOINTR);
617 }
618 }
Al Viro4b1ae272010-03-03 12:58:31 -0500619 if (!oz_mode) {
620 spin_lock(&sbi->fs_lock);
621 ino->flags &= ~AUTOFS_INF_PENDING;
622 spin_unlock(&sbi->fs_lock);
Ian Kent25767372008-07-23 21:30:12 -0700623 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 }
625
626 /*
Al Viro4b1ae272010-03-03 12:58:31 -0500627 * If this dentry is unhashed, then we shouldn't honour this
628 * lookup. Returning ENOENT here doesn't do the right thing
629 * for all system calls, but it should be OK for the operations
630 * we permit from an autofs.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 */
Al Viro4b1ae272010-03-03 12:58:31 -0500632 if (!oz_mode && d_unhashed(dentry)) {
633 /*
634 * A user space application can (and has done in the past)
635 * remove and re-create this directory during the callback.
636 * This can leave us with an unhashed dentry, but a
637 * successful mount! So we need to perform another
638 * cached lookup in case the dentry now exists.
639 */
640 struct dentry *parent = dentry->d_parent;
641 struct dentry *new = d_lookup(parent, &dentry->d_name);
642 if (new != NULL)
643 dentry = new;
644 else
645 dentry = ERR_PTR(-ENOENT);
646
Ian Kent90387c92009-12-15 16:45:46 -0800647 if (active)
648 dput(active);
Al Viro4b1ae272010-03-03 12:58:31 -0500649
Ian Kentc9ffec42007-02-20 13:58:10 -0800650 return dentry;
Ian Kentf50b6f82007-02-20 13:58:10 -0800651 }
652
Al Viro4b1ae272010-03-03 12:58:31 -0500653 if (active)
654 return active;
655
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 return NULL;
657}
658
659static int autofs4_dir_symlink(struct inode *dir,
660 struct dentry *dentry,
661 const char *symname)
662{
663 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
664 struct autofs_info *ino = autofs4_dentry_ino(dentry);
Ian Kent1aff3c82006-03-27 01:14:46 -0800665 struct autofs_info *p_ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 struct inode *inode;
667 char *cp;
668
669 DPRINTK("%s <- %.*s", symname,
670 dentry->d_name.len, dentry->d_name.name);
671
672 if (!autofs4_oz_mode(sbi))
673 return -EACCES;
674
675 ino = autofs4_init_ino(ino, sbi, S_IFLNK | 0555);
Ian Kent25767372008-07-23 21:30:12 -0700676 if (!ino)
677 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678
Al Viro4b1ae272010-03-03 12:58:31 -0500679 autofs4_del_active(dentry);
680
Ian Kentef581a72008-07-23 21:30:13 -0700681 ino->size = strlen(symname);
Ian Kent25767372008-07-23 21:30:12 -0700682 cp = kmalloc(ino->size + 1, GFP_KERNEL);
683 if (!cp) {
684 if (!dentry->d_fsdata)
685 kfree(ino);
686 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 }
688
689 strcpy(cp, symname);
690
691 inode = autofs4_get_inode(dir->i_sb, ino);
Ian Kent25767372008-07-23 21:30:12 -0700692 if (!inode) {
693 kfree(cp);
694 if (!dentry->d_fsdata)
695 kfree(ino);
696 return -ENOMEM;
697 }
Ian Kent1864f7b2007-08-22 14:01:54 -0700698 d_add(dentry, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699
700 if (dir == dir->i_sb->s_root->d_inode)
701 dentry->d_op = &autofs4_root_dentry_operations;
702 else
703 dentry->d_op = &autofs4_dentry_operations;
704
705 dentry->d_fsdata = ino;
706 ino->dentry = dget(dentry);
Ian Kent1aff3c82006-03-27 01:14:46 -0800707 atomic_inc(&ino->count);
708 p_ino = autofs4_dentry_ino(dentry->d_parent);
709 if (p_ino && dentry->d_parent != dentry)
710 atomic_inc(&p_ino->count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 ino->inode = inode;
712
Ian Kent25767372008-07-23 21:30:12 -0700713 ino->u.symlink = cp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 dir->i_mtime = CURRENT_TIME;
715
716 return 0;
717}
718
719/*
720 * NOTE!
721 *
722 * Normal filesystems would do a "d_delete()" to tell the VFS dcache
723 * that the file no longer exists. However, doing that means that the
724 * VFS layer can turn the dentry into a negative dentry. We don't want
Ian Kentf50b6f82007-02-20 13:58:10 -0800725 * this, because the unlink is probably the result of an expire.
Ian Kent5f6f4f22008-07-23 21:30:09 -0700726 * We simply d_drop it and add it to a expiring list in the super block,
727 * which allows the dentry lookup to check for an incomplete expire.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 *
729 * If a process is blocked on the dentry waiting for the expire to finish,
730 * it will invalidate the dentry and try to mount with a new one.
731 *
732 * Also see autofs4_dir_rmdir()..
733 */
734static int autofs4_dir_unlink(struct inode *dir, struct dentry *dentry)
735{
736 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
737 struct autofs_info *ino = autofs4_dentry_ino(dentry);
Ian Kent1aff3c82006-03-27 01:14:46 -0800738 struct autofs_info *p_ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739
740 /* This allows root to remove symlinks */
Sukadev Bhattiprolud78e53c2007-05-10 22:23:06 -0700741 if (!autofs4_oz_mode(sbi) && !capable(CAP_SYS_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 return -EACCES;
743
Ian Kent1aff3c82006-03-27 01:14:46 -0800744 if (atomic_dec_and_test(&ino->count)) {
745 p_ino = autofs4_dentry_ino(dentry->d_parent);
746 if (p_ino && dentry->d_parent != dentry)
747 atomic_dec(&p_ino->count);
748 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 dput(ino->dentry);
750
751 dentry->d_inode->i_size = 0;
Dave Hansence71ec32006-09-30 23:29:06 -0700752 clear_nlink(dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753
754 dir->i_mtime = CURRENT_TIME;
755
Ian Kentf50b6f82007-02-20 13:58:10 -0800756 spin_lock(&dcache_lock);
Al Viro4b1ae272010-03-03 12:58:31 -0500757 autofs4_add_expiring(dentry);
Ian Kentf50b6f82007-02-20 13:58:10 -0800758 spin_lock(&dentry->d_lock);
759 __d_drop(dentry);
760 spin_unlock(&dentry->d_lock);
761 spin_unlock(&dcache_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762
763 return 0;
764}
765
766static int autofs4_dir_rmdir(struct inode *dir, struct dentry *dentry)
767{
768 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
769 struct autofs_info *ino = autofs4_dentry_ino(dentry);
Ian Kent1aff3c82006-03-27 01:14:46 -0800770 struct autofs_info *p_ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771
Ian Kentf50b6f82007-02-20 13:58:10 -0800772 DPRINTK("dentry %p, removing %.*s",
773 dentry, dentry->d_name.len, dentry->d_name.name);
774
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 if (!autofs4_oz_mode(sbi))
776 return -EACCES;
777
778 spin_lock(&dcache_lock);
779 if (!list_empty(&dentry->d_subdirs)) {
780 spin_unlock(&dcache_lock);
781 return -ENOTEMPTY;
782 }
Al Viro4b1ae272010-03-03 12:58:31 -0500783 autofs4_add_expiring(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 spin_lock(&dentry->d_lock);
785 __d_drop(dentry);
786 spin_unlock(&dentry->d_lock);
787 spin_unlock(&dcache_lock);
788
Ian Kent1aff3c82006-03-27 01:14:46 -0800789 if (atomic_dec_and_test(&ino->count)) {
790 p_ino = autofs4_dentry_ino(dentry->d_parent);
791 if (p_ino && dentry->d_parent != dentry)
792 atomic_dec(&p_ino->count);
793 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 dput(ino->dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 dentry->d_inode->i_size = 0;
Dave Hansence71ec32006-09-30 23:29:06 -0700796 clear_nlink(dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797
798 if (dir->i_nlink)
Dave Hansen9a53c3a2006-09-30 23:29:03 -0700799 drop_nlink(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800
801 return 0;
802}
803
804static int autofs4_dir_mkdir(struct inode *dir, struct dentry *dentry, int mode)
805{
806 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
807 struct autofs_info *ino = autofs4_dentry_ino(dentry);
Ian Kent1aff3c82006-03-27 01:14:46 -0800808 struct autofs_info *p_ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 struct inode *inode;
810
Sukadev Bhattiprolud78e53c2007-05-10 22:23:06 -0700811 if (!autofs4_oz_mode(sbi))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 return -EACCES;
813
814 DPRINTK("dentry %p, creating %.*s",
815 dentry, dentry->d_name.len, dentry->d_name.name);
816
817 ino = autofs4_init_ino(ino, sbi, S_IFDIR | 0555);
Ian Kent25767372008-07-23 21:30:12 -0700818 if (!ino)
819 return -ENOMEM;
820
Al Viro4b1ae272010-03-03 12:58:31 -0500821 autofs4_del_active(dentry);
822
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 inode = autofs4_get_inode(dir->i_sb, ino);
Ian Kent25767372008-07-23 21:30:12 -0700824 if (!inode) {
825 if (!dentry->d_fsdata)
826 kfree(ino);
827 return -ENOMEM;
828 }
Ian Kent1864f7b2007-08-22 14:01:54 -0700829 d_add(dentry, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830
831 if (dir == dir->i_sb->s_root->d_inode)
832 dentry->d_op = &autofs4_root_dentry_operations;
833 else
834 dentry->d_op = &autofs4_dentry_operations;
835
836 dentry->d_fsdata = ino;
837 ino->dentry = dget(dentry);
Ian Kent1aff3c82006-03-27 01:14:46 -0800838 atomic_inc(&ino->count);
839 p_ino = autofs4_dentry_ino(dentry->d_parent);
840 if (p_ino && dentry->d_parent != dentry)
841 atomic_inc(&p_ino->count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 ino->inode = inode;
Dave Hansend8c76e62006-09-30 23:29:04 -0700843 inc_nlink(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 dir->i_mtime = CURRENT_TIME;
845
846 return 0;
847}
848
849/* Get/set timeout ioctl() operation */
Arnd Bergmannc9243f52010-07-04 00:15:07 +0200850#ifdef CONFIG_COMPAT
851static inline int autofs4_compat_get_set_timeout(struct autofs_sb_info *sbi,
852 compat_ulong_t __user *p)
853{
854 int rv;
855 unsigned long ntimeout;
856
857 if ((rv = get_user(ntimeout, p)) ||
858 (rv = put_user(sbi->exp_timeout/HZ, p)))
859 return rv;
860
861 if (ntimeout > UINT_MAX/HZ)
862 sbi->exp_timeout = 0;
863 else
864 sbi->exp_timeout = ntimeout * HZ;
865
866 return 0;
867}
868#endif
869
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870static inline int autofs4_get_set_timeout(struct autofs_sb_info *sbi,
871 unsigned long __user *p)
872{
873 int rv;
874 unsigned long ntimeout;
875
Sukadev Bhattiprolud78e53c2007-05-10 22:23:06 -0700876 if ((rv = get_user(ntimeout, p)) ||
877 (rv = put_user(sbi->exp_timeout/HZ, p)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 return rv;
879
Sukadev Bhattiprolud78e53c2007-05-10 22:23:06 -0700880 if (ntimeout > ULONG_MAX/HZ)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 sbi->exp_timeout = 0;
882 else
883 sbi->exp_timeout = ntimeout * HZ;
884
885 return 0;
886}
887
888/* Return protocol version */
889static inline int autofs4_get_protover(struct autofs_sb_info *sbi, int __user *p)
890{
891 return put_user(sbi->version, p);
892}
893
894/* Return protocol sub version */
895static inline int autofs4_get_protosubver(struct autofs_sb_info *sbi, int __user *p)
896{
897 return put_user(sbi->sub_version, p);
898}
899
900/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901* Tells the daemon whether it can umount the autofs mount.
902*/
903static inline int autofs4_ask_umount(struct vfsmount *mnt, int __user *p)
904{
905 int status = 0;
906
Ian Kente3474a82006-03-27 01:14:51 -0800907 if (may_umount(mnt))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 status = 1;
909
910 DPRINTK("returning %d", status);
911
912 status = put_user(status, p);
913
914 return status;
915}
916
917/* Identify autofs4_dentries - this is so we can tell if there's
918 an extra dentry refcount or not. We only hold a refcount on the
919 dentry if its non-negative (ie, d_inode != NULL)
920*/
921int is_autofs4_dentry(struct dentry *dentry)
922{
923 return dentry && dentry->d_inode &&
924 (dentry->d_op == &autofs4_root_dentry_operations ||
925 dentry->d_op == &autofs4_dentry_operations) &&
926 dentry->d_fsdata != NULL;
927}
928
929/*
930 * ioctl()'s on the root directory is the chief method for the daemon to
931 * generate kernel reactions
932 */
Frederic Weisbecker3663df72010-05-19 15:08:17 +0200933static int autofs4_root_ioctl_unlocked(struct inode *inode, struct file *filp,
934 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935{
936 struct autofs_sb_info *sbi = autofs4_sbi(inode->i_sb);
937 void __user *p = (void __user *)arg;
938
939 DPRINTK("cmd = 0x%08x, arg = 0x%08lx, sbi = %p, pgrp = %u",
Pavel Emelianova47afb02007-10-18 23:39:46 -0700940 cmd,arg,sbi,task_pgrp_nr(current));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941
Sukadev Bhattiprolud78e53c2007-05-10 22:23:06 -0700942 if (_IOC_TYPE(cmd) != _IOC_TYPE(AUTOFS_IOC_FIRST) ||
943 _IOC_NR(cmd) - _IOC_NR(AUTOFS_IOC_FIRST) >= AUTOFS_IOC_COUNT)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 return -ENOTTY;
945
Sukadev Bhattiprolud78e53c2007-05-10 22:23:06 -0700946 if (!autofs4_oz_mode(sbi) && !capable(CAP_SYS_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 return -EPERM;
948
949 switch(cmd) {
950 case AUTOFS_IOC_READY: /* Wait queue: go ahead and retry */
951 return autofs4_wait_release(sbi,(autofs_wqt_t)arg,0);
952 case AUTOFS_IOC_FAIL: /* Wait queue: fail with ENOENT */
953 return autofs4_wait_release(sbi,(autofs_wqt_t)arg,-ENOENT);
954 case AUTOFS_IOC_CATATONIC: /* Enter catatonic mode (daemon shutdown) */
955 autofs4_catatonic_mode(sbi);
956 return 0;
957 case AUTOFS_IOC_PROTOVER: /* Get protocol version */
958 return autofs4_get_protover(sbi, p);
959 case AUTOFS_IOC_PROTOSUBVER: /* Get protocol sub version */
960 return autofs4_get_protosubver(sbi, p);
961 case AUTOFS_IOC_SETTIMEOUT:
962 return autofs4_get_set_timeout(sbi, p);
Arnd Bergmannc9243f52010-07-04 00:15:07 +0200963#ifdef CONFIG_COMPAT
964 case AUTOFS_IOC_SETTIMEOUT32:
965 return autofs4_compat_get_set_timeout(sbi, p);
966#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 case AUTOFS_IOC_ASKUMOUNT:
Josef "Jeff" Sipeka4669ed2006-12-08 02:36:46 -0800969 return autofs4_ask_umount(filp->f_path.mnt, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970
971 /* return a single thing to expire */
972 case AUTOFS_IOC_EXPIRE:
Josef "Jeff" Sipeka4669ed2006-12-08 02:36:46 -0800973 return autofs4_expire_run(inode->i_sb,filp->f_path.mnt,sbi, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 /* same as above, but can send multiple expires through pipe */
975 case AUTOFS_IOC_EXPIRE_MULTI:
Josef "Jeff" Sipeka4669ed2006-12-08 02:36:46 -0800976 return autofs4_expire_multi(inode->i_sb,filp->f_path.mnt,sbi, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977
978 default:
979 return -ENOSYS;
980 }
981}
Frederic Weisbecker3663df72010-05-19 15:08:17 +0200982
983static long autofs4_root_ioctl(struct file *filp,
984 unsigned int cmd, unsigned long arg)
985{
Frederic Weisbecker3663df72010-05-19 15:08:17 +0200986 struct inode *inode = filp->f_dentry->d_inode;
Ian Kentde47de72010-12-07 13:04:00 +0800987 return autofs4_root_ioctl_unlocked(inode, filp, cmd, arg);
Frederic Weisbecker3663df72010-05-19 15:08:17 +0200988}
Arnd Bergmannc9243f52010-07-04 00:15:07 +0200989
990#ifdef CONFIG_COMPAT
991static long autofs4_root_compat_ioctl(struct file *filp,
992 unsigned int cmd, unsigned long arg)
993{
994 struct inode *inode = filp->f_path.dentry->d_inode;
995 int ret;
996
Arnd Bergmannc9243f52010-07-04 00:15:07 +0200997 if (cmd == AUTOFS_IOC_READY || cmd == AUTOFS_IOC_FAIL)
998 ret = autofs4_root_ioctl_unlocked(inode, filp, cmd, arg);
999 else
1000 ret = autofs4_root_ioctl_unlocked(inode, filp, cmd,
1001 (unsigned long)compat_ptr(arg));
Arnd Bergmannc9243f52010-07-04 00:15:07 +02001002
1003 return ret;
1004}
1005#endif