Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* -*- c -*- --------------------------------------------------------------- * |
2 | * | |
3 | * linux/fs/autofs/waitq.c | |
4 | * | |
5 | * Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved | |
5c0a32fc | 6 | * Copyright 2001-2006 Ian Kent <raven@themaw.net> |
1da177e4 LT |
7 | * |
8 | * This file is part of the Linux kernel and is made available under | |
9 | * the terms of the GNU General Public License, version 2, or at your | |
10 | * option, any later version, incorporated herein by reference. | |
11 | * | |
12 | * ------------------------------------------------------------------------- */ | |
13 | ||
14 | #include <linux/slab.h> | |
15 | #include <linux/time.h> | |
16 | #include <linux/signal.h> | |
17 | #include <linux/file.h> | |
18 | #include "autofs_i.h" | |
19 | ||
20 | /* We make this a static variable rather than a part of the superblock; it | |
21 | is better if we don't reassign numbers easily even across filesystems */ | |
22 | static autofs_wqt_t autofs4_next_wait_queue = 1; | |
23 | ||
24 | /* These are the signals we allow interrupting a pending mount */ | |
25 | #define SHUTDOWN_SIGS (sigmask(SIGKILL) | sigmask(SIGINT) | sigmask(SIGQUIT)) | |
26 | ||
27 | void autofs4_catatonic_mode(struct autofs_sb_info *sbi) | |
28 | { | |
29 | struct autofs_wait_queue *wq, *nwq; | |
30 | ||
31 | DPRINTK("entering catatonic mode"); | |
32 | ||
33 | sbi->catatonic = 1; | |
34 | wq = sbi->queues; | |
35 | sbi->queues = NULL; /* Erase all wait queues */ | |
e77fbddf | 36 | while (wq) { |
1da177e4 LT |
37 | nwq = wq->next; |
38 | wq->status = -ENOENT; /* Magic is gone - report failure */ | |
39 | kfree(wq->name); | |
40 | wq->name = NULL; | |
41 | wake_up_interruptible(&wq->queue); | |
42 | wq = nwq; | |
43 | } | |
ba8df43c IK |
44 | fput(sbi->pipe); /* Close the pipe */ |
45 | sbi->pipe = NULL; | |
1da177e4 LT |
46 | } |
47 | ||
48 | static int autofs4_write(struct file *file, const void *addr, int bytes) | |
49 | { | |
50 | unsigned long sigpipe, flags; | |
51 | mm_segment_t fs; | |
52 | const char *data = (const char *)addr; | |
53 | ssize_t wr = 0; | |
54 | ||
55 | /** WARNING: this is not safe for writing more than PIPE_BUF bytes! **/ | |
56 | ||
57 | sigpipe = sigismember(¤t->pending.signal, SIGPIPE); | |
58 | ||
59 | /* Save pointer to user space and point back to kernel space */ | |
60 | fs = get_fs(); | |
61 | set_fs(KERNEL_DS); | |
62 | ||
63 | while (bytes && | |
64 | (wr = file->f_op->write(file,data,bytes,&file->f_pos)) > 0) { | |
65 | data += wr; | |
66 | bytes -= wr; | |
67 | } | |
68 | ||
69 | set_fs(fs); | |
70 | ||
71 | /* Keep the currently executing process from receiving a | |
72 | SIGPIPE unless it was already supposed to get one */ | |
73 | if (wr == -EPIPE && !sigpipe) { | |
74 | spin_lock_irqsave(¤t->sighand->siglock, flags); | |
75 | sigdelset(¤t->pending.signal, SIGPIPE); | |
76 | recalc_sigpending(); | |
77 | spin_unlock_irqrestore(¤t->sighand->siglock, flags); | |
78 | } | |
79 | ||
80 | return (bytes > 0); | |
81 | } | |
82 | ||
83 | static void autofs4_notify_daemon(struct autofs_sb_info *sbi, | |
84 | struct autofs_wait_queue *wq, | |
85 | int type) | |
86 | { | |
87 | union autofs_packet_union pkt; | |
88 | size_t pktsz; | |
89 | ||
90 | DPRINTK("wait id = 0x%08lx, name = %.*s, type=%d", | |
91 | wq->wait_queue_token, wq->len, wq->name, type); | |
92 | ||
93 | memset(&pkt,0,sizeof pkt); /* For security reasons */ | |
94 | ||
95 | pkt.hdr.proto_version = sbi->version; | |
96 | pkt.hdr.type = type; | |
5c0a32fc IK |
97 | switch (type) { |
98 | /* Kernel protocol v4 missing and expire packets */ | |
99 | case autofs_ptype_missing: | |
100 | { | |
1da177e4 LT |
101 | struct autofs_packet_missing *mp = &pkt.missing; |
102 | ||
103 | pktsz = sizeof(*mp); | |
104 | ||
105 | mp->wait_queue_token = wq->wait_queue_token; | |
106 | mp->len = wq->len; | |
107 | memcpy(mp->name, wq->name, wq->len); | |
108 | mp->name[wq->len] = '\0'; | |
5c0a32fc IK |
109 | break; |
110 | } | |
111 | case autofs_ptype_expire_multi: | |
112 | { | |
1da177e4 LT |
113 | struct autofs_packet_expire_multi *ep = &pkt.expire_multi; |
114 | ||
115 | pktsz = sizeof(*ep); | |
116 | ||
117 | ep->wait_queue_token = wq->wait_queue_token; | |
118 | ep->len = wq->len; | |
119 | memcpy(ep->name, wq->name, wq->len); | |
120 | ep->name[wq->len] = '\0'; | |
5c0a32fc IK |
121 | break; |
122 | } | |
123 | /* | |
124 | * Kernel protocol v5 packet for handling indirect and direct | |
125 | * mount missing and expire requests | |
126 | */ | |
127 | case autofs_ptype_missing_indirect: | |
128 | case autofs_ptype_expire_indirect: | |
129 | case autofs_ptype_missing_direct: | |
130 | case autofs_ptype_expire_direct: | |
131 | { | |
132 | struct autofs_v5_packet *packet = &pkt.v5_packet; | |
133 | ||
134 | pktsz = sizeof(*packet); | |
135 | ||
136 | packet->wait_queue_token = wq->wait_queue_token; | |
137 | packet->len = wq->len; | |
138 | memcpy(packet->name, wq->name, wq->len); | |
139 | packet->name[wq->len] = '\0'; | |
140 | packet->dev = wq->dev; | |
141 | packet->ino = wq->ino; | |
142 | packet->uid = wq->uid; | |
143 | packet->gid = wq->gid; | |
144 | packet->pid = wq->pid; | |
145 | packet->tgid = wq->tgid; | |
146 | break; | |
147 | } | |
148 | default: | |
1da177e4 LT |
149 | printk("autofs4_notify_daemon: bad type %d!\n", type); |
150 | return; | |
151 | } | |
152 | ||
153 | if (autofs4_write(sbi->pipe, &pkt, pktsz)) | |
154 | autofs4_catatonic_mode(sbi); | |
155 | } | |
156 | ||
157 | static int autofs4_getpath(struct autofs_sb_info *sbi, | |
158 | struct dentry *dentry, char **name) | |
159 | { | |
160 | struct dentry *root = sbi->sb->s_root; | |
161 | struct dentry *tmp; | |
162 | char *buf = *name; | |
163 | char *p; | |
164 | int len = 0; | |
165 | ||
166 | spin_lock(&dcache_lock); | |
167 | for (tmp = dentry ; tmp != root ; tmp = tmp->d_parent) | |
168 | len += tmp->d_name.len + 1; | |
169 | ||
170 | if (--len > NAME_MAX) { | |
171 | spin_unlock(&dcache_lock); | |
172 | return 0; | |
173 | } | |
174 | ||
175 | *(buf + len) = '\0'; | |
176 | p = buf + len - dentry->d_name.len; | |
177 | strncpy(p, dentry->d_name.name, dentry->d_name.len); | |
178 | ||
179 | for (tmp = dentry->d_parent; tmp != root ; tmp = tmp->d_parent) { | |
180 | *(--p) = '/'; | |
181 | p -= tmp->d_name.len; | |
182 | strncpy(p, tmp->d_name.name, tmp->d_name.len); | |
183 | } | |
184 | spin_unlock(&dcache_lock); | |
185 | ||
186 | return len; | |
187 | } | |
188 | ||
a5370553 IK |
189 | static struct autofs_wait_queue * |
190 | autofs4_find_wait(struct autofs_sb_info *sbi, | |
191 | char *name, unsigned int hash, unsigned int len) | |
192 | { | |
193 | struct autofs_wait_queue *wq; | |
194 | ||
195 | for (wq = sbi->queues; wq; wq = wq->next) { | |
196 | if (wq->hash == hash && | |
197 | wq->len == len && | |
198 | wq->name && !memcmp(wq->name, name, len)) | |
199 | break; | |
200 | } | |
201 | return wq; | |
202 | } | |
203 | ||
1da177e4 LT |
204 | int autofs4_wait(struct autofs_sb_info *sbi, struct dentry *dentry, |
205 | enum autofs_notify notify) | |
206 | { | |
a5370553 | 207 | struct autofs_info *ino; |
1da177e4 LT |
208 | struct autofs_wait_queue *wq; |
209 | char *name; | |
5c0a32fc IK |
210 | unsigned int len = 0; |
211 | unsigned int hash = 0; | |
a5370553 | 212 | int status, type; |
1da177e4 LT |
213 | |
214 | /* In catatonic mode, we don't wait for nobody */ | |
e77fbddf | 215 | if (sbi->catatonic) |
1da177e4 LT |
216 | return -ENOENT; |
217 | ||
218 | name = kmalloc(NAME_MAX + 1, GFP_KERNEL); | |
219 | if (!name) | |
220 | return -ENOMEM; | |
221 | ||
5c0a32fc | 222 | /* If this is a direct mount request create a dummy name */ |
44d53eb0 | 223 | if (IS_ROOT(dentry) && (sbi->type & AUTOFS_TYPE_DIRECT)) |
5c0a32fc IK |
224 | len = sprintf(name, "%p", dentry); |
225 | else { | |
226 | len = autofs4_getpath(sbi, dentry, &name); | |
227 | if (!len) { | |
228 | kfree(name); | |
229 | return -ENOENT; | |
230 | } | |
1da177e4 | 231 | } |
5c0a32fc | 232 | hash = full_name_hash(name, len); |
1da177e4 | 233 | |
1d5599e3 | 234 | if (mutex_lock_interruptible(&sbi->wq_mutex)) { |
1da177e4 LT |
235 | kfree(name); |
236 | return -EINTR; | |
237 | } | |
238 | ||
a5370553 IK |
239 | wq = autofs4_find_wait(sbi, name, hash, len); |
240 | ino = autofs4_dentry_ino(dentry); | |
241 | if (!wq && ino && notify == NFY_NONE) { | |
242 | /* | |
243 | * Either we've betean the pending expire to post it's | |
244 | * wait or it finished while we waited on the mutex. | |
245 | * So we need to wait till either, the wait appears | |
246 | * or the expire finishes. | |
247 | */ | |
248 | ||
249 | while (ino->flags & AUTOFS_INF_EXPIRING) { | |
250 | mutex_unlock(&sbi->wq_mutex); | |
251 | schedule_timeout_interruptible(HZ/10); | |
252 | if (mutex_lock_interruptible(&sbi->wq_mutex)) { | |
253 | kfree(name); | |
254 | return -EINTR; | |
255 | } | |
256 | wq = autofs4_find_wait(sbi, name, hash, len); | |
257 | if (wq) | |
258 | break; | |
259 | } | |
1da177e4 | 260 | |
a5370553 IK |
261 | /* |
262 | * Not ideal but the status has already gone. Of the two | |
263 | * cases where we wait on NFY_NONE neither depend on the | |
264 | * return status of the wait. | |
265 | */ | |
266 | if (!wq) { | |
cc9acc88 | 267 | kfree(name); |
1d5599e3 | 268 | mutex_unlock(&sbi->wq_mutex); |
a5370553 | 269 | return 0; |
cc9acc88 | 270 | } |
a5370553 | 271 | } |
cc9acc88 | 272 | |
a5370553 | 273 | if (!wq) { |
1da177e4 LT |
274 | /* Create a new wait queue */ |
275 | wq = kmalloc(sizeof(struct autofs_wait_queue),GFP_KERNEL); | |
e77fbddf | 276 | if (!wq) { |
1da177e4 | 277 | kfree(name); |
1d5599e3 | 278 | mutex_unlock(&sbi->wq_mutex); |
1da177e4 LT |
279 | return -ENOMEM; |
280 | } | |
281 | ||
282 | wq->wait_queue_token = autofs4_next_wait_queue; | |
283 | if (++autofs4_next_wait_queue == 0) | |
284 | autofs4_next_wait_queue = 1; | |
285 | wq->next = sbi->queues; | |
286 | sbi->queues = wq; | |
287 | init_waitqueue_head(&wq->queue); | |
5c0a32fc | 288 | wq->hash = hash; |
1da177e4 LT |
289 | wq->name = name; |
290 | wq->len = len; | |
5c0a32fc IK |
291 | wq->dev = autofs4_get_dev(sbi); |
292 | wq->ino = autofs4_get_ino(sbi); | |
293 | wq->uid = current->uid; | |
294 | wq->gid = current->gid; | |
295 | wq->pid = current->pid; | |
296 | wq->tgid = current->tgid; | |
1da177e4 LT |
297 | wq->status = -EINTR; /* Status return if interrupted */ |
298 | atomic_set(&wq->wait_ctr, 2); | |
1d5599e3 | 299 | mutex_unlock(&sbi->wq_mutex); |
3e7b1919 | 300 | |
5c0a32fc IK |
301 | if (sbi->version < 5) { |
302 | if (notify == NFY_MOUNT) | |
303 | type = autofs_ptype_missing; | |
304 | else | |
305 | type = autofs_ptype_expire_multi; | |
306 | } else { | |
307 | if (notify == NFY_MOUNT) | |
44d53eb0 | 308 | type = (sbi->type & AUTOFS_TYPE_DIRECT) ? |
5c0a32fc IK |
309 | autofs_ptype_missing_direct : |
310 | autofs_ptype_missing_indirect; | |
311 | else | |
44d53eb0 | 312 | type = (sbi->type & AUTOFS_TYPE_DIRECT) ? |
5c0a32fc IK |
313 | autofs_ptype_expire_direct : |
314 | autofs_ptype_expire_indirect; | |
315 | } | |
4dcd00b1 | 316 | |
682d4fc9 IK |
317 | DPRINTK("new wait id = 0x%08lx, name = %.*s, nfy=%d\n", |
318 | (unsigned long) wq->wait_queue_token, wq->len, wq->name, notify); | |
4dcd00b1 IK |
319 | |
320 | /* autofs4_notify_daemon() may block */ | |
321 | autofs4_notify_daemon(sbi, wq, type); | |
a5370553 IK |
322 | } else { |
323 | atomic_inc(&wq->wait_ctr); | |
324 | mutex_unlock(&sbi->wq_mutex); | |
325 | kfree(name); | |
326 | DPRINTK("existing wait id = 0x%08lx, name = %.*s, nfy=%d", | |
327 | (unsigned long) wq->wait_queue_token, wq->len, wq->name, notify); | |
4dcd00b1 IK |
328 | } |
329 | ||
1da177e4 LT |
330 | /* wq->name is NULL if and only if the lock is already released */ |
331 | ||
e77fbddf | 332 | if (sbi->catatonic) { |
1da177e4 LT |
333 | /* We might have slept, so check again for catatonic mode */ |
334 | wq->status = -ENOENT; | |
f99d49ad JJ |
335 | kfree(wq->name); |
336 | wq->name = NULL; | |
1da177e4 LT |
337 | } |
338 | ||
e77fbddf | 339 | if (wq->name) { |
1da177e4 LT |
340 | /* Block all but "shutdown" signals while waiting */ |
341 | sigset_t oldset; | |
342 | unsigned long irqflags; | |
343 | ||
344 | spin_lock_irqsave(¤t->sighand->siglock, irqflags); | |
345 | oldset = current->blocked; | |
346 | siginitsetinv(¤t->blocked, SHUTDOWN_SIGS & ~oldset.sig[0]); | |
347 | recalc_sigpending(); | |
348 | spin_unlock_irqrestore(¤t->sighand->siglock, irqflags); | |
349 | ||
350 | wait_event_interruptible(wq->queue, wq->name == NULL); | |
351 | ||
352 | spin_lock_irqsave(¤t->sighand->siglock, irqflags); | |
353 | current->blocked = oldset; | |
354 | recalc_sigpending(); | |
355 | spin_unlock_irqrestore(¤t->sighand->siglock, irqflags); | |
356 | } else { | |
357 | DPRINTK("skipped sleeping"); | |
358 | } | |
359 | ||
360 | status = wq->status; | |
361 | ||
362 | /* Are we the last process to need status? */ | |
363 | if (atomic_dec_and_test(&wq->wait_ctr)) | |
364 | kfree(wq); | |
365 | ||
366 | return status; | |
367 | } | |
368 | ||
369 | ||
370 | int autofs4_wait_release(struct autofs_sb_info *sbi, autofs_wqt_t wait_queue_token, int status) | |
371 | { | |
372 | struct autofs_wait_queue *wq, **wql; | |
373 | ||
1d5599e3 | 374 | mutex_lock(&sbi->wq_mutex); |
e77fbddf IK |
375 | for (wql = &sbi->queues ; (wq = *wql) != 0 ; wql = &wq->next) { |
376 | if (wq->wait_queue_token == wait_queue_token) | |
1da177e4 LT |
377 | break; |
378 | } | |
379 | ||
e77fbddf | 380 | if (!wq) { |
1d5599e3 | 381 | mutex_unlock(&sbi->wq_mutex); |
1da177e4 LT |
382 | return -EINVAL; |
383 | } | |
384 | ||
385 | *wql = wq->next; /* Unlink from chain */ | |
1d5599e3 | 386 | mutex_unlock(&sbi->wq_mutex); |
1da177e4 LT |
387 | kfree(wq->name); |
388 | wq->name = NULL; /* Do not wait on this queue */ | |
389 | ||
390 | wq->status = status; | |
391 | ||
392 | if (atomic_dec_and_test(&wq->wait_ctr)) /* Is anyone still waiting for this guy? */ | |
393 | kfree(wq); | |
394 | else | |
395 | wake_up_interruptible(&wq->queue); | |
396 | ||
397 | return 0; | |
398 | } | |
399 |