]>
Commit | Line | Data |
---|---|---|
1 | /* -*- c -*- --------------------------------------------------------------- * | |
2 | * | |
3 | * linux/fs/autofs/root.c | |
4 | * | |
5 | * Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved | |
6 | * Copyright 1999-2000 Jeremy Fitzhardinge <jeremy@goop.org> | |
7 | * Copyright 2001-2006 Ian Kent <raven@themaw.net> | |
8 | * | |
9 | * This file is part of the Linux kernel and is made available under | |
10 | * the terms of the GNU General Public License, version 2, or at your | |
11 | * option, any later version, incorporated herein by reference. | |
12 | * | |
13 | * ------------------------------------------------------------------------- */ | |
14 | ||
15 | #include <linux/capability.h> | |
16 | #include <linux/errno.h> | |
17 | #include <linux/stat.h> | |
18 | #include <linux/slab.h> | |
19 | #include <linux/param.h> | |
20 | #include <linux/time.h> | |
21 | #include <linux/compat.h> | |
22 | #include <linux/mutex.h> | |
23 | ||
24 | #include "autofs_i.h" | |
25 | ||
26 | static int autofs4_dir_symlink(struct inode *,struct dentry *,const char *); | |
27 | static int autofs4_dir_unlink(struct inode *,struct dentry *); | |
28 | 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 | |
34 | static int autofs4_dir_open(struct inode *inode, struct file *file); | |
35 | static struct dentry *autofs4_lookup(struct inode *,struct dentry *, unsigned int); | |
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 *); | |
39 | ||
40 | const struct file_operations autofs4_root_operations = { | |
41 | .open = dcache_dir_open, | |
42 | .release = dcache_dir_close, | |
43 | .read = generic_read_dir, | |
44 | .iterate = dcache_readdir, | |
45 | .llseek = dcache_dir_lseek, | |
46 | .unlocked_ioctl = autofs4_root_ioctl, | |
47 | #ifdef CONFIG_COMPAT | |
48 | .compat_ioctl = autofs4_root_compat_ioctl, | |
49 | #endif | |
50 | }; | |
51 | ||
52 | const struct file_operations autofs4_dir_operations = { | |
53 | .open = autofs4_dir_open, | |
54 | .release = dcache_dir_close, | |
55 | .read = generic_read_dir, | |
56 | .iterate = dcache_readdir, | |
57 | .llseek = dcache_dir_lseek, | |
58 | }; | |
59 | ||
60 | const struct inode_operations autofs4_dir_inode_operations = { | |
61 | .lookup = autofs4_lookup, | |
62 | .unlink = autofs4_dir_unlink, | |
63 | .symlink = autofs4_dir_symlink, | |
64 | .mkdir = autofs4_dir_mkdir, | |
65 | .rmdir = autofs4_dir_rmdir, | |
66 | }; | |
67 | ||
68 | const struct dentry_operations autofs4_dentry_operations = { | |
69 | .d_automount = autofs4_d_automount, | |
70 | .d_manage = autofs4_d_manage, | |
71 | .d_release = autofs4_dentry_release, | |
72 | }; | |
73 | ||
74 | static void autofs4_add_active(struct dentry *dentry) | |
75 | { | |
76 | struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); | |
77 | struct autofs_info *ino = autofs4_dentry_ino(dentry); | |
78 | 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 | } | |
87 | return; | |
88 | } | |
89 | ||
90 | static void autofs4_del_active(struct dentry *dentry) | |
91 | { | |
92 | struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); | |
93 | struct autofs_info *ino = autofs4_dentry_ino(dentry); | |
94 | if (ino) { | |
95 | spin_lock(&sbi->lookup_lock); | |
96 | ino->active_count--; | |
97 | if (!ino->active_count) { | |
98 | if (!list_empty(&ino->active)) | |
99 | list_del_init(&ino->active); | |
100 | } | |
101 | spin_unlock(&sbi->lookup_lock); | |
102 | } | |
103 | return; | |
104 | } | |
105 | ||
106 | static int autofs4_dir_open(struct inode *inode, struct file *file) | |
107 | { | |
108 | struct dentry *dentry = file->f_path.dentry; | |
109 | struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); | |
110 | ||
111 | DPRINTK("file=%p dentry=%p %.*s", | |
112 | file, dentry, dentry->d_name.len, dentry->d_name.name); | |
113 | ||
114 | if (autofs4_oz_mode(sbi)) | |
115 | goto out; | |
116 | ||
117 | /* | |
118 | * An empty directory in an autofs file system is always a | |
119 | * mount point. The daemon must have failed to mount this | |
120 | * during lookup so it doesn't exist. This can happen, for | |
121 | * example, if user space returns an incorrect status for a | |
122 | * mount request. Otherwise we're doing a readdir on the | |
123 | * autofs file system so just let the libfs routines handle | |
124 | * it. | |
125 | */ | |
126 | spin_lock(&sbi->lookup_lock); | |
127 | if (!d_mountpoint(dentry) && simple_empty(dentry)) { | |
128 | spin_unlock(&sbi->lookup_lock); | |
129 | return -ENOENT; | |
130 | } | |
131 | spin_unlock(&sbi->lookup_lock); | |
132 | ||
133 | out: | |
134 | return dcache_dir_open(inode, file); | |
135 | } | |
136 | ||
137 | static void autofs4_dentry_release(struct dentry *de) | |
138 | { | |
139 | struct autofs_info *ino = autofs4_dentry_ino(de); | |
140 | struct autofs_sb_info *sbi = autofs4_sbi(de->d_sb); | |
141 | ||
142 | DPRINTK("releasing %p", de); | |
143 | ||
144 | if (!ino) | |
145 | return; | |
146 | ||
147 | if (sbi) { | |
148 | spin_lock(&sbi->lookup_lock); | |
149 | if (!list_empty(&ino->active)) | |
150 | list_del(&ino->active); | |
151 | if (!list_empty(&ino->expiring)) | |
152 | list_del(&ino->expiring); | |
153 | spin_unlock(&sbi->lookup_lock); | |
154 | } | |
155 | ||
156 | autofs4_free_ino(ino); | |
157 | } | |
158 | ||
159 | static struct dentry *autofs4_lookup_active(struct dentry *dentry) | |
160 | { | |
161 | struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); | |
162 | struct dentry *parent = dentry->d_parent; | |
163 | struct qstr *name = &dentry->d_name; | |
164 | unsigned int len = name->len; | |
165 | unsigned int hash = name->hash; | |
166 | const unsigned char *str = name->name; | |
167 | struct list_head *p, *head; | |
168 | ||
169 | spin_lock(&sbi->lookup_lock); | |
170 | head = &sbi->active_list; | |
171 | list_for_each(p, head) { | |
172 | struct autofs_info *ino; | |
173 | struct dentry *active; | |
174 | struct qstr *qstr; | |
175 | ||
176 | ino = list_entry(p, struct autofs_info, active); | |
177 | active = ino->dentry; | |
178 | ||
179 | spin_lock(&active->d_lock); | |
180 | ||
181 | /* Already gone? */ | |
182 | if (!d_count(active)) | |
183 | goto next; | |
184 | ||
185 | qstr = &active->d_name; | |
186 | ||
187 | if (active->d_name.hash != hash) | |
188 | goto next; | |
189 | if (active->d_parent != parent) | |
190 | goto next; | |
191 | ||
192 | if (qstr->len != len) | |
193 | goto next; | |
194 | if (memcmp(qstr->name, str, len)) | |
195 | goto next; | |
196 | ||
197 | if (d_unhashed(active)) { | |
198 | dget_dlock(active); | |
199 | spin_unlock(&active->d_lock); | |
200 | spin_unlock(&sbi->lookup_lock); | |
201 | return active; | |
202 | } | |
203 | next: | |
204 | spin_unlock(&active->d_lock); | |
205 | } | |
206 | spin_unlock(&sbi->lookup_lock); | |
207 | ||
208 | return NULL; | |
209 | } | |
210 | ||
211 | static struct dentry *autofs4_lookup_expiring(struct dentry *dentry) | |
212 | { | |
213 | struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); | |
214 | struct dentry *parent = dentry->d_parent; | |
215 | struct qstr *name = &dentry->d_name; | |
216 | unsigned int len = name->len; | |
217 | unsigned int hash = name->hash; | |
218 | const unsigned char *str = name->name; | |
219 | struct list_head *p, *head; | |
220 | ||
221 | spin_lock(&sbi->lookup_lock); | |
222 | head = &sbi->expiring_list; | |
223 | list_for_each(p, head) { | |
224 | struct autofs_info *ino; | |
225 | struct dentry *expiring; | |
226 | struct qstr *qstr; | |
227 | ||
228 | ino = list_entry(p, struct autofs_info, expiring); | |
229 | expiring = ino->dentry; | |
230 | ||
231 | spin_lock(&expiring->d_lock); | |
232 | ||
233 | /* Bad luck, we've already been dentry_iput */ | |
234 | if (!expiring->d_inode) | |
235 | goto next; | |
236 | ||
237 | qstr = &expiring->d_name; | |
238 | ||
239 | if (expiring->d_name.hash != hash) | |
240 | goto next; | |
241 | if (expiring->d_parent != parent) | |
242 | goto next; | |
243 | ||
244 | if (qstr->len != len) | |
245 | goto next; | |
246 | if (memcmp(qstr->name, str, len)) | |
247 | goto next; | |
248 | ||
249 | if (d_unhashed(expiring)) { | |
250 | dget_dlock(expiring); | |
251 | spin_unlock(&expiring->d_lock); | |
252 | spin_unlock(&sbi->lookup_lock); | |
253 | return expiring; | |
254 | } | |
255 | next: | |
256 | spin_unlock(&expiring->d_lock); | |
257 | } | |
258 | spin_unlock(&sbi->lookup_lock); | |
259 | ||
260 | return NULL; | |
261 | } | |
262 | ||
263 | static int autofs4_mount_wait(struct dentry *dentry) | |
264 | { | |
265 | struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); | |
266 | struct autofs_info *ino = autofs4_dentry_ino(dentry); | |
267 | int status = 0; | |
268 | ||
269 | if (ino->flags & AUTOFS_INF_PENDING) { | |
270 | DPRINTK("waiting for mount name=%.*s", | |
271 | dentry->d_name.len, dentry->d_name.name); | |
272 | status = autofs4_wait(sbi, dentry, NFY_MOUNT); | |
273 | DPRINTK("mount wait done status=%d", status); | |
274 | } | |
275 | ino->last_used = jiffies; | |
276 | return status; | |
277 | } | |
278 | ||
279 | static int do_expire_wait(struct dentry *dentry) | |
280 | { | |
281 | struct dentry *expiring; | |
282 | ||
283 | expiring = autofs4_lookup_expiring(dentry); | |
284 | if (!expiring) | |
285 | return autofs4_expire_wait(dentry); | |
286 | else { | |
287 | /* | |
288 | * If we are racing with expire the request might not | |
289 | * be quite complete, but the directory has been removed | |
290 | * so it must have been successful, just wait for it. | |
291 | */ | |
292 | autofs4_expire_wait(expiring); | |
293 | autofs4_del_expiring(expiring); | |
294 | dput(expiring); | |
295 | } | |
296 | return 0; | |
297 | } | |
298 | ||
299 | static struct dentry *autofs4_mountpoint_changed(struct path *path) | |
300 | { | |
301 | struct dentry *dentry = path->dentry; | |
302 | struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); | |
303 | ||
304 | /* | |
305 | * If this is an indirect mount the dentry could have gone away | |
306 | * as a result of an expire and a new one created. | |
307 | */ | |
308 | if (autofs_type_indirect(sbi->type) && d_unhashed(dentry)) { | |
309 | struct dentry *parent = dentry->d_parent; | |
310 | struct autofs_info *ino; | |
311 | struct dentry *new = d_lookup(parent, &dentry->d_name); | |
312 | if (!new) | |
313 | return NULL; | |
314 | ino = autofs4_dentry_ino(new); | |
315 | ino->last_used = jiffies; | |
316 | dput(path->dentry); | |
317 | path->dentry = new; | |
318 | } | |
319 | return path->dentry; | |
320 | } | |
321 | ||
322 | static struct vfsmount *autofs4_d_automount(struct path *path) | |
323 | { | |
324 | struct dentry *dentry = path->dentry; | |
325 | struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); | |
326 | struct autofs_info *ino = autofs4_dentry_ino(dentry); | |
327 | int status; | |
328 | ||
329 | DPRINTK("dentry=%p %.*s", | |
330 | dentry, dentry->d_name.len, dentry->d_name.name); | |
331 | ||
332 | /* The daemon never triggers a mount. */ | |
333 | if (autofs4_oz_mode(sbi)) | |
334 | return NULL; | |
335 | ||
336 | /* | |
337 | * If an expire request is pending everyone must wait. | |
338 | * If the expire fails we're still mounted so continue | |
339 | * the follow and return. A return of -EAGAIN (which only | |
340 | * happens with indirect mounts) means the expire completed | |
341 | * and the directory was removed, so just go ahead and try | |
342 | * the mount. | |
343 | */ | |
344 | status = do_expire_wait(dentry); | |
345 | if (status && status != -EAGAIN) | |
346 | return NULL; | |
347 | ||
348 | /* Callback to the daemon to perform the mount or wait */ | |
349 | spin_lock(&sbi->fs_lock); | |
350 | if (ino->flags & AUTOFS_INF_PENDING) { | |
351 | spin_unlock(&sbi->fs_lock); | |
352 | status = autofs4_mount_wait(dentry); | |
353 | if (status) | |
354 | return ERR_PTR(status); | |
355 | goto done; | |
356 | } | |
357 | ||
358 | /* | |
359 | * 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 | * to the daemon. | |
362 | */ | |
363 | if (dentry->d_inode && S_ISLNK(dentry->d_inode->i_mode)) { | |
364 | spin_unlock(&sbi->fs_lock); | |
365 | goto done; | |
366 | } | |
367 | ||
368 | if (!d_mountpoint(dentry)) { | |
369 | /* | |
370 | * It's possible that user space hasn't removed directories | |
371 | * after umounting a rootless multi-mount, although it | |
372 | * should. For v5 have_submounts() is sufficient to handle | |
373 | * this because the leaves of the directory tree under the | |
374 | * mount never trigger mounts themselves (they have an autofs | |
375 | * trigger mount mounted on them). But v4 pseudo direct mounts | |
376 | * do need the leaves to to trigger mounts. In this case we | |
377 | * have no choice but to use the list_empty() check and | |
378 | * require user space behave. | |
379 | */ | |
380 | if (sbi->version > 4) { | |
381 | if (have_submounts(dentry)) { | |
382 | spin_unlock(&sbi->fs_lock); | |
383 | goto done; | |
384 | } | |
385 | } else { | |
386 | if (!simple_empty(dentry)) { | |
387 | spin_unlock(&sbi->fs_lock); | |
388 | goto done; | |
389 | } | |
390 | } | |
391 | ino->flags |= AUTOFS_INF_PENDING; | |
392 | spin_unlock(&sbi->fs_lock); | |
393 | status = autofs4_mount_wait(dentry); | |
394 | spin_lock(&sbi->fs_lock); | |
395 | ino->flags &= ~AUTOFS_INF_PENDING; | |
396 | if (status) { | |
397 | spin_unlock(&sbi->fs_lock); | |
398 | return ERR_PTR(status); | |
399 | } | |
400 | } | |
401 | spin_unlock(&sbi->fs_lock); | |
402 | done: | |
403 | /* Mount succeeded, check if we ended up with a new dentry */ | |
404 | dentry = autofs4_mountpoint_changed(path); | |
405 | if (!dentry) | |
406 | return ERR_PTR(-ENOENT); | |
407 | ||
408 | return NULL; | |
409 | } | |
410 | ||
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 | struct autofs_info *ino = autofs4_dentry_ino(dentry); | |
415 | int status; | |
416 | ||
417 | DPRINTK("dentry=%p %.*s", | |
418 | dentry, dentry->d_name.len, dentry->d_name.name); | |
419 | ||
420 | /* The daemon never waits. */ | |
421 | if (autofs4_oz_mode(sbi)) { | |
422 | if (rcu_walk) | |
423 | return 0; | |
424 | if (!d_mountpoint(dentry)) | |
425 | return -EISDIR; | |
426 | return 0; | |
427 | } | |
428 | ||
429 | /* We need to sleep, so we need pathwalk to be in ref-mode */ | |
430 | if (rcu_walk) | |
431 | return -ECHILD; | |
432 | ||
433 | /* Wait for pending expires */ | |
434 | do_expire_wait(dentry); | |
435 | ||
436 | /* | |
437 | * This dentry may be under construction so wait on mount | |
438 | * completion. | |
439 | */ | |
440 | status = autofs4_mount_wait(dentry); | |
441 | if (status) | |
442 | return status; | |
443 | ||
444 | spin_lock(&sbi->fs_lock); | |
445 | /* | |
446 | * If the dentry has been selected for expire while we slept | |
447 | * on the lock then it might go away. We'll deal with that in | |
448 | * ->d_automount() and wait on a new mount if the expire | |
449 | * succeeds or return here if it doesn't (since there's no | |
450 | * mount to follow with a rootless multi-mount). | |
451 | */ | |
452 | if (!(ino->flags & AUTOFS_INF_EXPIRING)) { | |
453 | /* | |
454 | * Any needed mounting has been completed and the path | |
455 | * updated so check if this is a rootless multi-mount so | |
456 | * we can avoid needless calls ->d_automount() and avoid | |
457 | * an incorrect ELOOP error return. | |
458 | */ | |
459 | if ((!d_mountpoint(dentry) && !simple_empty(dentry)) || | |
460 | (dentry->d_inode && S_ISLNK(dentry->d_inode->i_mode))) | |
461 | status = -EISDIR; | |
462 | } | |
463 | spin_unlock(&sbi->fs_lock); | |
464 | ||
465 | return status; | |
466 | } | |
467 | ||
468 | /* Lookups in the root directory */ | |
469 | static struct dentry *autofs4_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags) | |
470 | { | |
471 | struct autofs_sb_info *sbi; | |
472 | struct autofs_info *ino; | |
473 | struct dentry *active; | |
474 | ||
475 | DPRINTK("name = %.*s", dentry->d_name.len, dentry->d_name.name); | |
476 | ||
477 | /* File name too long to exist */ | |
478 | if (dentry->d_name.len > NAME_MAX) | |
479 | return ERR_PTR(-ENAMETOOLONG); | |
480 | ||
481 | sbi = autofs4_sbi(dir->i_sb); | |
482 | ||
483 | DPRINTK("pid = %u, pgrp = %u, catatonic = %d, oz_mode = %d", | |
484 | current->pid, task_pgrp_nr(current), sbi->catatonic, | |
485 | autofs4_oz_mode(sbi)); | |
486 | ||
487 | active = autofs4_lookup_active(dentry); | |
488 | if (active) { | |
489 | return active; | |
490 | } else { | |
491 | /* | |
492 | * A dentry that is not within the root can never trigger a | |
493 | * mount operation, unless the directory already exists, so we | |
494 | * can return fail immediately. The daemon however does need | |
495 | * to create directories within the file system. | |
496 | */ | |
497 | if (!autofs4_oz_mode(sbi) && !IS_ROOT(dentry->d_parent)) | |
498 | return ERR_PTR(-ENOENT); | |
499 | ||
500 | /* 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 | ||
504 | ino = autofs4_new_ino(sbi); | |
505 | if (!ino) | |
506 | return ERR_PTR(-ENOMEM); | |
507 | ||
508 | dentry->d_fsdata = ino; | |
509 | ino->dentry = dentry; | |
510 | ||
511 | autofs4_add_active(dentry); | |
512 | ||
513 | d_instantiate(dentry, NULL); | |
514 | } | |
515 | return NULL; | |
516 | } | |
517 | ||
518 | static int autofs4_dir_symlink(struct inode *dir, | |
519 | struct dentry *dentry, | |
520 | const char *symname) | |
521 | { | |
522 | struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb); | |
523 | struct autofs_info *ino = autofs4_dentry_ino(dentry); | |
524 | struct autofs_info *p_ino; | |
525 | struct inode *inode; | |
526 | size_t size = strlen(symname); | |
527 | char *cp; | |
528 | ||
529 | DPRINTK("%s <- %.*s", symname, | |
530 | dentry->d_name.len, dentry->d_name.name); | |
531 | ||
532 | if (!autofs4_oz_mode(sbi)) | |
533 | return -EACCES; | |
534 | ||
535 | BUG_ON(!ino); | |
536 | ||
537 | autofs4_clean_ino(ino); | |
538 | ||
539 | autofs4_del_active(dentry); | |
540 | ||
541 | cp = kmalloc(size + 1, GFP_KERNEL); | |
542 | if (!cp) | |
543 | return -ENOMEM; | |
544 | ||
545 | strcpy(cp, symname); | |
546 | ||
547 | inode = autofs4_get_inode(dir->i_sb, S_IFLNK | 0555); | |
548 | if (!inode) { | |
549 | kfree(cp); | |
550 | if (!dentry->d_fsdata) | |
551 | kfree(ino); | |
552 | return -ENOMEM; | |
553 | } | |
554 | inode->i_private = cp; | |
555 | inode->i_size = size; | |
556 | d_add(dentry, inode); | |
557 | ||
558 | dget(dentry); | |
559 | atomic_inc(&ino->count); | |
560 | p_ino = autofs4_dentry_ino(dentry->d_parent); | |
561 | if (p_ino && !IS_ROOT(dentry)) | |
562 | atomic_inc(&p_ino->count); | |
563 | ||
564 | dir->i_mtime = CURRENT_TIME; | |
565 | ||
566 | return 0; | |
567 | } | |
568 | ||
569 | /* | |
570 | * NOTE! | |
571 | * | |
572 | * Normal filesystems would do a "d_delete()" to tell the VFS dcache | |
573 | * that the file no longer exists. However, doing that means that the | |
574 | * 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 | * We simply d_drop it and add it to a expiring list in the super block, | |
577 | * which allows the dentry lookup to check for an incomplete expire. | |
578 | * | |
579 | * If a process is blocked on the dentry waiting for the expire to finish, | |
580 | * it will invalidate the dentry and try to mount with a new one. | |
581 | * | |
582 | * Also see autofs4_dir_rmdir().. | |
583 | */ | |
584 | static int autofs4_dir_unlink(struct inode *dir, struct dentry *dentry) | |
585 | { | |
586 | struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb); | |
587 | struct autofs_info *ino = autofs4_dentry_ino(dentry); | |
588 | struct autofs_info *p_ino; | |
589 | ||
590 | /* This allows root to remove symlinks */ | |
591 | if (!autofs4_oz_mode(sbi) && !capable(CAP_SYS_ADMIN)) | |
592 | return -EPERM; | |
593 | ||
594 | if (atomic_dec_and_test(&ino->count)) { | |
595 | p_ino = autofs4_dentry_ino(dentry->d_parent); | |
596 | if (p_ino && !IS_ROOT(dentry)) | |
597 | atomic_dec(&p_ino->count); | |
598 | } | |
599 | dput(ino->dentry); | |
600 | ||
601 | dentry->d_inode->i_size = 0; | |
602 | clear_nlink(dentry->d_inode); | |
603 | ||
604 | dir->i_mtime = CURRENT_TIME; | |
605 | ||
606 | spin_lock(&sbi->lookup_lock); | |
607 | __autofs4_add_expiring(dentry); | |
608 | d_drop(dentry); | |
609 | spin_unlock(&sbi->lookup_lock); | |
610 | ||
611 | return 0; | |
612 | } | |
613 | ||
614 | /* | |
615 | * Version 4 of autofs provides a pseudo direct mount implementation | |
616 | * that relies on directories at the leaves of a directory tree under | |
617 | * an indirect mount to trigger mounts. To allow for this we need to | |
618 | * set the DMANAGED_AUTOMOUNT and DMANAGED_TRANSIT flags on the leaves | |
619 | * of the directory tree. There is no need to clear the automount flag | |
620 | * following a mount or restore it after an expire because these mounts | |
621 | * are always covered. However, it is necessary to ensure that these | |
622 | * flags are clear on non-empty directories to avoid unnecessary calls | |
623 | * during path walks. | |
624 | */ | |
625 | static void autofs_set_leaf_automount_flags(struct dentry *dentry) | |
626 | { | |
627 | struct dentry *parent; | |
628 | ||
629 | /* root and dentrys in the root are already handled */ | |
630 | if (IS_ROOT(dentry->d_parent)) | |
631 | return; | |
632 | ||
633 | managed_dentry_set_managed(dentry); | |
634 | ||
635 | parent = dentry->d_parent; | |
636 | /* only consider parents below dentrys in the root */ | |
637 | if (IS_ROOT(parent->d_parent)) | |
638 | return; | |
639 | managed_dentry_clear_managed(parent); | |
640 | return; | |
641 | } | |
642 | ||
643 | static void autofs_clear_leaf_automount_flags(struct dentry *dentry) | |
644 | { | |
645 | struct list_head *d_child; | |
646 | struct dentry *parent; | |
647 | ||
648 | /* flags for dentrys in the root are handled elsewhere */ | |
649 | if (IS_ROOT(dentry->d_parent)) | |
650 | return; | |
651 | ||
652 | managed_dentry_clear_managed(dentry); | |
653 | ||
654 | parent = dentry->d_parent; | |
655 | /* only consider parents below dentrys in the root */ | |
656 | if (IS_ROOT(parent->d_parent)) | |
657 | return; | |
658 | d_child = &dentry->d_u.d_child; | |
659 | /* Set parent managed if it's becoming empty */ | |
660 | if (d_child->next == &parent->d_subdirs && | |
661 | d_child->prev == &parent->d_subdirs) | |
662 | managed_dentry_set_managed(parent); | |
663 | return; | |
664 | } | |
665 | ||
666 | static int autofs4_dir_rmdir(struct inode *dir, struct dentry *dentry) | |
667 | { | |
668 | struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb); | |
669 | struct autofs_info *ino = autofs4_dentry_ino(dentry); | |
670 | struct autofs_info *p_ino; | |
671 | ||
672 | DPRINTK("dentry %p, removing %.*s", | |
673 | dentry, dentry->d_name.len, dentry->d_name.name); | |
674 | ||
675 | if (!autofs4_oz_mode(sbi)) | |
676 | return -EACCES; | |
677 | ||
678 | spin_lock(&sbi->lookup_lock); | |
679 | if (!simple_empty(dentry)) { | |
680 | spin_unlock(&sbi->lookup_lock); | |
681 | return -ENOTEMPTY; | |
682 | } | |
683 | __autofs4_add_expiring(dentry); | |
684 | d_drop(dentry); | |
685 | spin_unlock(&sbi->lookup_lock); | |
686 | ||
687 | if (sbi->version < 5) | |
688 | autofs_clear_leaf_automount_flags(dentry); | |
689 | ||
690 | if (atomic_dec_and_test(&ino->count)) { | |
691 | p_ino = autofs4_dentry_ino(dentry->d_parent); | |
692 | if (p_ino && dentry->d_parent != dentry) | |
693 | atomic_dec(&p_ino->count); | |
694 | } | |
695 | dput(ino->dentry); | |
696 | dentry->d_inode->i_size = 0; | |
697 | clear_nlink(dentry->d_inode); | |
698 | ||
699 | if (dir->i_nlink) | |
700 | drop_nlink(dir); | |
701 | ||
702 | return 0; | |
703 | } | |
704 | ||
705 | static int autofs4_dir_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) | |
706 | { | |
707 | struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb); | |
708 | struct autofs_info *ino = autofs4_dentry_ino(dentry); | |
709 | struct autofs_info *p_ino; | |
710 | struct inode *inode; | |
711 | ||
712 | if (!autofs4_oz_mode(sbi)) | |
713 | return -EACCES; | |
714 | ||
715 | DPRINTK("dentry %p, creating %.*s", | |
716 | dentry, dentry->d_name.len, dentry->d_name.name); | |
717 | ||
718 | BUG_ON(!ino); | |
719 | ||
720 | autofs4_clean_ino(ino); | |
721 | ||
722 | autofs4_del_active(dentry); | |
723 | ||
724 | inode = autofs4_get_inode(dir->i_sb, S_IFDIR | 0555); | |
725 | if (!inode) | |
726 | return -ENOMEM; | |
727 | d_add(dentry, inode); | |
728 | ||
729 | if (sbi->version < 5) | |
730 | autofs_set_leaf_automount_flags(dentry); | |
731 | ||
732 | dget(dentry); | |
733 | atomic_inc(&ino->count); | |
734 | 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); | |
738 | dir->i_mtime = CURRENT_TIME; | |
739 | ||
740 | return 0; | |
741 | } | |
742 | ||
743 | /* Get/set timeout ioctl() operation */ | |
744 | #ifdef CONFIG_COMPAT | |
745 | static inline int autofs4_compat_get_set_timeout(struct autofs_sb_info *sbi, | |
746 | compat_ulong_t __user *p) | |
747 | { | |
748 | int rv; | |
749 | unsigned long ntimeout; | |
750 | ||
751 | if ((rv = get_user(ntimeout, p)) || | |
752 | (rv = put_user(sbi->exp_timeout/HZ, p))) | |
753 | return rv; | |
754 | ||
755 | if (ntimeout > UINT_MAX/HZ) | |
756 | sbi->exp_timeout = 0; | |
757 | else | |
758 | sbi->exp_timeout = ntimeout * HZ; | |
759 | ||
760 | return 0; | |
761 | } | |
762 | #endif | |
763 | ||
764 | static inline int autofs4_get_set_timeout(struct autofs_sb_info *sbi, | |
765 | unsigned long __user *p) | |
766 | { | |
767 | int rv; | |
768 | unsigned long ntimeout; | |
769 | ||
770 | if ((rv = get_user(ntimeout, p)) || | |
771 | (rv = put_user(sbi->exp_timeout/HZ, p))) | |
772 | return rv; | |
773 | ||
774 | if (ntimeout > ULONG_MAX/HZ) | |
775 | sbi->exp_timeout = 0; | |
776 | else | |
777 | sbi->exp_timeout = ntimeout * HZ; | |
778 | ||
779 | return 0; | |
780 | } | |
781 | ||
782 | /* Return protocol version */ | |
783 | static inline int autofs4_get_protover(struct autofs_sb_info *sbi, int __user *p) | |
784 | { | |
785 | return put_user(sbi->version, p); | |
786 | } | |
787 | ||
788 | /* Return protocol sub version */ | |
789 | static inline int autofs4_get_protosubver(struct autofs_sb_info *sbi, int __user *p) | |
790 | { | |
791 | return put_user(sbi->sub_version, p); | |
792 | } | |
793 | ||
794 | /* | |
795 | * Tells the daemon whether it can umount the autofs mount. | |
796 | */ | |
797 | static inline int autofs4_ask_umount(struct vfsmount *mnt, int __user *p) | |
798 | { | |
799 | int status = 0; | |
800 | ||
801 | if (may_umount(mnt)) | |
802 | status = 1; | |
803 | ||
804 | DPRINTK("returning %d", status); | |
805 | ||
806 | status = put_user(status, p); | |
807 | ||
808 | return status; | |
809 | } | |
810 | ||
811 | /* Identify autofs4_dentries - this is so we can tell if there's | |
812 | an extra dentry refcount or not. We only hold a refcount on the | |
813 | dentry if its non-negative (ie, d_inode != NULL) | |
814 | */ | |
815 | int is_autofs4_dentry(struct dentry *dentry) | |
816 | { | |
817 | return dentry && dentry->d_inode && | |
818 | dentry->d_op == &autofs4_dentry_operations && | |
819 | dentry->d_fsdata != NULL; | |
820 | } | |
821 | ||
822 | /* | |
823 | * ioctl()'s on the root directory is the chief method for the daemon to | |
824 | * generate kernel reactions | |
825 | */ | |
826 | static int autofs4_root_ioctl_unlocked(struct inode *inode, struct file *filp, | |
827 | unsigned int cmd, unsigned long arg) | |
828 | { | |
829 | struct autofs_sb_info *sbi = autofs4_sbi(inode->i_sb); | |
830 | void __user *p = (void __user *)arg; | |
831 | ||
832 | DPRINTK("cmd = 0x%08x, arg = 0x%08lx, sbi = %p, pgrp = %u", | |
833 | cmd,arg,sbi,task_pgrp_nr(current)); | |
834 | ||
835 | if (_IOC_TYPE(cmd) != _IOC_TYPE(AUTOFS_IOC_FIRST) || | |
836 | _IOC_NR(cmd) - _IOC_NR(AUTOFS_IOC_FIRST) >= AUTOFS_IOC_COUNT) | |
837 | return -ENOTTY; | |
838 | ||
839 | if (!autofs4_oz_mode(sbi) && !capable(CAP_SYS_ADMIN)) | |
840 | return -EPERM; | |
841 | ||
842 | switch(cmd) { | |
843 | case AUTOFS_IOC_READY: /* Wait queue: go ahead and retry */ | |
844 | return autofs4_wait_release(sbi,(autofs_wqt_t)arg,0); | |
845 | case AUTOFS_IOC_FAIL: /* Wait queue: fail with ENOENT */ | |
846 | return autofs4_wait_release(sbi,(autofs_wqt_t)arg,-ENOENT); | |
847 | case AUTOFS_IOC_CATATONIC: /* Enter catatonic mode (daemon shutdown) */ | |
848 | autofs4_catatonic_mode(sbi); | |
849 | return 0; | |
850 | case AUTOFS_IOC_PROTOVER: /* Get protocol version */ | |
851 | return autofs4_get_protover(sbi, p); | |
852 | case AUTOFS_IOC_PROTOSUBVER: /* Get protocol sub version */ | |
853 | return autofs4_get_protosubver(sbi, p); | |
854 | case AUTOFS_IOC_SETTIMEOUT: | |
855 | return autofs4_get_set_timeout(sbi, p); | |
856 | #ifdef CONFIG_COMPAT | |
857 | case AUTOFS_IOC_SETTIMEOUT32: | |
858 | return autofs4_compat_get_set_timeout(sbi, p); | |
859 | #endif | |
860 | ||
861 | case AUTOFS_IOC_ASKUMOUNT: | |
862 | return autofs4_ask_umount(filp->f_path.mnt, p); | |
863 | ||
864 | /* return a single thing to expire */ | |
865 | case AUTOFS_IOC_EXPIRE: | |
866 | return autofs4_expire_run(inode->i_sb,filp->f_path.mnt,sbi, p); | |
867 | /* same as above, but can send multiple expires through pipe */ | |
868 | case AUTOFS_IOC_EXPIRE_MULTI: | |
869 | return autofs4_expire_multi(inode->i_sb,filp->f_path.mnt,sbi, p); | |
870 | ||
871 | default: | |
872 | return -ENOSYS; | |
873 | } | |
874 | } | |
875 | ||
876 | static long autofs4_root_ioctl(struct file *filp, | |
877 | unsigned int cmd, unsigned long arg) | |
878 | { | |
879 | struct inode *inode = file_inode(filp); | |
880 | return autofs4_root_ioctl_unlocked(inode, filp, cmd, arg); | |
881 | } | |
882 | ||
883 | #ifdef CONFIG_COMPAT | |
884 | static long autofs4_root_compat_ioctl(struct file *filp, | |
885 | unsigned int cmd, unsigned long arg) | |
886 | { | |
887 | struct inode *inode = file_inode(filp); | |
888 | int ret; | |
889 | ||
890 | if (cmd == AUTOFS_IOC_READY || cmd == AUTOFS_IOC_FAIL) | |
891 | ret = autofs4_root_ioctl_unlocked(inode, filp, cmd, arg); | |
892 | else | |
893 | ret = autofs4_root_ioctl_unlocked(inode, filp, cmd, | |
894 | (unsigned long)compat_ptr(arg)); | |
895 | ||
896 | return ret; | |
897 | } | |
898 | #endif |