2005-04-17 00:20:36 +02:00
|
|
|
/* -*- c -*- --------------------------------------------------------------- *
|
|
|
|
*
|
|
|
|
* linux/fs/autofs/waitq.c
|
|
|
|
*
|
|
|
|
* Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
|
2006-03-27 11:14:55 +02:00
|
|
|
* Copyright 2001-2006 Ian Kent <raven@themaw.net>
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
|
|
|
* This file is part of the Linux kernel and is made available under
|
|
|
|
* the terms of the GNU General Public License, version 2, or at your
|
|
|
|
* option, any later version, incorporated herein by reference.
|
|
|
|
*
|
|
|
|
* ------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/time.h>
|
|
|
|
#include <linux/signal.h>
|
|
|
|
#include <linux/file.h>
|
|
|
|
#include "autofs_i.h"
|
|
|
|
|
|
|
|
/* We make this a static variable rather than a part of the superblock; it
|
|
|
|
is better if we don't reassign numbers easily even across filesystems */
|
|
|
|
static autofs_wqt_t autofs4_next_wait_queue = 1;
|
|
|
|
|
|
|
|
/* These are the signals we allow interrupting a pending mount */
|
|
|
|
#define SHUTDOWN_SIGS (sigmask(SIGKILL) | sigmask(SIGINT) | sigmask(SIGQUIT))
|
|
|
|
|
|
|
|
void autofs4_catatonic_mode(struct autofs_sb_info *sbi)
|
|
|
|
{
|
|
|
|
struct autofs_wait_queue *wq, *nwq;
|
|
|
|
|
2008-07-24 06:30:17 +02:00
|
|
|
mutex_lock(&sbi->wq_mutex);
|
|
|
|
if (sbi->catatonic) {
|
|
|
|
mutex_unlock(&sbi->wq_mutex);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
DPRINTK("entering catatonic mode");
|
|
|
|
|
|
|
|
sbi->catatonic = 1;
|
|
|
|
wq = sbi->queues;
|
|
|
|
sbi->queues = NULL; /* Erase all wait queues */
|
2006-03-27 11:14:49 +02:00
|
|
|
while (wq) {
|
2005-04-17 00:20:36 +02:00
|
|
|
nwq = wq->next;
|
|
|
|
wq->status = -ENOENT; /* Magic is gone - report failure */
|
2008-07-24 06:30:16 +02:00
|
|
|
if (wq->name.name) {
|
|
|
|
kfree(wq->name.name);
|
|
|
|
wq->name.name = NULL;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
wake_up_interruptible(&wq->queue);
|
|
|
|
wq = nwq;
|
|
|
|
}
|
2006-11-14 11:03:29 +01:00
|
|
|
fput(sbi->pipe); /* Close the pipe */
|
|
|
|
sbi->pipe = NULL;
|
2008-07-24 06:30:17 +02:00
|
|
|
sbi->pipefd = -1;
|
|
|
|
mutex_unlock(&sbi->wq_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int autofs4_write(struct file *file, const void *addr, int bytes)
|
|
|
|
{
|
|
|
|
unsigned long sigpipe, flags;
|
|
|
|
mm_segment_t fs;
|
|
|
|
const char *data = (const char *)addr;
|
|
|
|
ssize_t wr = 0;
|
|
|
|
|
|
|
|
/** WARNING: this is not safe for writing more than PIPE_BUF bytes! **/
|
|
|
|
|
|
|
|
sigpipe = sigismember(¤t->pending.signal, SIGPIPE);
|
|
|
|
|
|
|
|
/* Save pointer to user space and point back to kernel space */
|
|
|
|
fs = get_fs();
|
|
|
|
set_fs(KERNEL_DS);
|
|
|
|
|
|
|
|
while (bytes &&
|
|
|
|
(wr = file->f_op->write(file,data,bytes,&file->f_pos)) > 0) {
|
|
|
|
data += wr;
|
|
|
|
bytes -= wr;
|
|
|
|
}
|
|
|
|
|
|
|
|
set_fs(fs);
|
|
|
|
|
|
|
|
/* Keep the currently executing process from receiving a
|
|
|
|
SIGPIPE unless it was already supposed to get one */
|
|
|
|
if (wr == -EPIPE && !sigpipe) {
|
|
|
|
spin_lock_irqsave(¤t->sighand->siglock, flags);
|
|
|
|
sigdelset(¤t->pending.signal, SIGPIPE);
|
|
|
|
recalc_sigpending();
|
|
|
|
spin_unlock_irqrestore(¤t->sighand->siglock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (bytes > 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void autofs4_notify_daemon(struct autofs_sb_info *sbi,
|
|
|
|
struct autofs_wait_queue *wq,
|
|
|
|
int type)
|
|
|
|
{
|
2007-02-20 22:58:09 +01:00
|
|
|
union {
|
|
|
|
struct autofs_packet_hdr hdr;
|
|
|
|
union autofs_packet_union v4_pkt;
|
|
|
|
union autofs_v5_packet_union v5_pkt;
|
|
|
|
} pkt;
|
2008-07-24 06:30:20 +02:00
|
|
|
struct file *pipe = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
size_t pktsz;
|
|
|
|
|
|
|
|
DPRINTK("wait id = 0x%08lx, name = %.*s, type=%d",
|
2008-07-24 06:30:16 +02:00
|
|
|
wq->wait_queue_token, wq->name.len, wq->name.name, type);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
memset(&pkt,0,sizeof pkt); /* For security reasons */
|
|
|
|
|
|
|
|
pkt.hdr.proto_version = sbi->version;
|
|
|
|
pkt.hdr.type = type;
|
2006-03-27 11:14:55 +02:00
|
|
|
switch (type) {
|
|
|
|
/* Kernel protocol v4 missing and expire packets */
|
|
|
|
case autofs_ptype_missing:
|
|
|
|
{
|
2007-02-20 22:58:09 +01:00
|
|
|
struct autofs_packet_missing *mp = &pkt.v4_pkt.missing;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
pktsz = sizeof(*mp);
|
|
|
|
|
|
|
|
mp->wait_queue_token = wq->wait_queue_token;
|
2008-07-24 06:30:16 +02:00
|
|
|
mp->len = wq->name.len;
|
|
|
|
memcpy(mp->name, wq->name.name, wq->name.len);
|
|
|
|
mp->name[wq->name.len] = '\0';
|
2006-03-27 11:14:55 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case autofs_ptype_expire_multi:
|
|
|
|
{
|
2007-02-20 22:58:09 +01:00
|
|
|
struct autofs_packet_expire_multi *ep = &pkt.v4_pkt.expire_multi;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
pktsz = sizeof(*ep);
|
|
|
|
|
|
|
|
ep->wait_queue_token = wq->wait_queue_token;
|
2008-07-24 06:30:16 +02:00
|
|
|
ep->len = wq->name.len;
|
|
|
|
memcpy(ep->name, wq->name.name, wq->name.len);
|
|
|
|
ep->name[wq->name.len] = '\0';
|
2006-03-27 11:14:55 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Kernel protocol v5 packet for handling indirect and direct
|
|
|
|
* mount missing and expire requests
|
|
|
|
*/
|
|
|
|
case autofs_ptype_missing_indirect:
|
|
|
|
case autofs_ptype_expire_indirect:
|
|
|
|
case autofs_ptype_missing_direct:
|
|
|
|
case autofs_ptype_expire_direct:
|
|
|
|
{
|
2007-02-20 22:58:09 +01:00
|
|
|
struct autofs_v5_packet *packet = &pkt.v5_pkt.v5_packet;
|
2006-03-27 11:14:55 +02:00
|
|
|
|
|
|
|
pktsz = sizeof(*packet);
|
|
|
|
|
|
|
|
packet->wait_queue_token = wq->wait_queue_token;
|
2008-07-24 06:30:16 +02:00
|
|
|
packet->len = wq->name.len;
|
|
|
|
memcpy(packet->name, wq->name.name, wq->name.len);
|
|
|
|
packet->name[wq->name.len] = '\0';
|
2006-03-27 11:14:55 +02:00
|
|
|
packet->dev = wq->dev;
|
|
|
|
packet->ino = wq->ino;
|
|
|
|
packet->uid = wq->uid;
|
|
|
|
packet->gid = wq->gid;
|
|
|
|
packet->pid = wq->pid;
|
|
|
|
packet->tgid = wq->tgid;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
2005-04-17 00:20:36 +02:00
|
|
|
printk("autofs4_notify_daemon: bad type %d!\n", type);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-07-24 06:30:20 +02:00
|
|
|
/* Check if we have become catatonic */
|
|
|
|
mutex_lock(&sbi->wq_mutex);
|
|
|
|
if (!sbi->catatonic) {
|
|
|
|
pipe = sbi->pipe;
|
|
|
|
get_file(pipe);
|
|
|
|
}
|
|
|
|
mutex_unlock(&sbi->wq_mutex);
|
|
|
|
|
|
|
|
if (pipe) {
|
|
|
|
if (autofs4_write(pipe, &pkt, pktsz))
|
|
|
|
autofs4_catatonic_mode(sbi);
|
|
|
|
fput(pipe);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int autofs4_getpath(struct autofs_sb_info *sbi,
|
|
|
|
struct dentry *dentry, char **name)
|
|
|
|
{
|
|
|
|
struct dentry *root = sbi->sb->s_root;
|
|
|
|
struct dentry *tmp;
|
|
|
|
char *buf = *name;
|
|
|
|
char *p;
|
|
|
|
int len = 0;
|
|
|
|
|
|
|
|
spin_lock(&dcache_lock);
|
|
|
|
for (tmp = dentry ; tmp != root ; tmp = tmp->d_parent)
|
|
|
|
len += tmp->d_name.len + 1;
|
|
|
|
|
2008-05-01 13:35:07 +02:00
|
|
|
if (!len || --len > NAME_MAX) {
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_unlock(&dcache_lock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
*(buf + len) = '\0';
|
|
|
|
p = buf + len - dentry->d_name.len;
|
|
|
|
strncpy(p, dentry->d_name.name, dentry->d_name.len);
|
|
|
|
|
|
|
|
for (tmp = dentry->d_parent; tmp != root ; tmp = tmp->d_parent) {
|
|
|
|
*(--p) = '/';
|
|
|
|
p -= tmp->d_name.len;
|
|
|
|
strncpy(p, tmp->d_name.name, tmp->d_name.len);
|
|
|
|
}
|
|
|
|
spin_unlock(&dcache_lock);
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2006-05-15 18:43:51 +02:00
|
|
|
static struct autofs_wait_queue *
|
2008-07-24 06:30:16 +02:00
|
|
|
autofs4_find_wait(struct autofs_sb_info *sbi, struct qstr *qstr)
|
2006-05-15 18:43:51 +02:00
|
|
|
{
|
|
|
|
struct autofs_wait_queue *wq;
|
|
|
|
|
|
|
|
for (wq = sbi->queues; wq; wq = wq->next) {
|
2008-07-24 06:30:16 +02:00
|
|
|
if (wq->name.hash == qstr->hash &&
|
|
|
|
wq->name.len == qstr->len &&
|
|
|
|
wq->name.name &&
|
|
|
|
!memcmp(wq->name.name, qstr->name, qstr->len))
|
2006-05-15 18:43:51 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
return wq;
|
|
|
|
}
|
|
|
|
|
autofs4: fix pending mount race
Close a race between a pending mount that is about to finish and a new
lookup for the same directory.
Process P1 triggers a mount of directory foo. It sets
DCACHE_AUTOFS_PENDING in the ->lookup routine, creates a waitq entry for
'foo', and calls out to the daemon to perform the mount. The autofs
daemon will then create the directory 'foo', using a new dentry that will
be hashed in the dcache.
Before the mount completes, another process, P2, tries to walk into the
'foo' directory. The vfs path walking code finds an entry for 'foo' and
calls the revalidate method. Revalidate finds that the entry is not
PENDING (because PENDING was never set on the dentry created by the
mkdir), but it does find the directory is empty. Revalidate calls
try_to_fill_dentry, which sets the PENDING flag and then calls into the
autofs4 wait code to trigger or wait for a mount of 'foo'. The wait code
finds the entry for 'foo' and goes to sleep waiting for the completion of
the mount.
Yet another process, P3, tries to walk into the 'foo' directory. This
process again finds a dentry in the dcache for 'foo', and calls into the
autofs revalidate code.
The revalidate code finds that the PENDING flag is set, and so calls
try_to_fill_dentry.
a) try_to_fill_dentry sets the PENDING flag redundantly for this
dentry, then calls into the autofs4 wait code.
b) the autofs4 wait code takes the waitq mutex and searches for an
entry for 'foo'
Between a and b, P1 is woken up because the mount completed. P1 takes the
wait queue mutex, clears the PENDING flag from the dentry, and removes the
waitqueue entry for 'foo' from the list.
When it releases the waitq mutex, P3 (eventually) acquires it. At this
time, it looks for an existing waitq for 'foo', finds none, and so creates
a new one and calls out to the daemon to mount the 'foo' directory.
Now, the reason that three processes are required to trigger this race is
that, because the PENDING flag is not set on the dentry created by mkdir,
the window for the race would be way to slim for it to ever occur.
Basically, between the testing of d_mountpoint(dentry) and the taking of
the waitq mutex, the mount would have to complete and the daemon would
have to be woken up, and that in turn would have to wake up P1. This is
simply impossible. Add the third process, though, and it becomes slightly
more likely.
Signed-off-by: Jeff Moyer <jmoyer@redhat.com>
Signed-off-by: Ian Kent <raven@themaw.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-07-24 06:30:19 +02:00
|
|
|
/*
|
|
|
|
* Check if we have a valid request.
|
|
|
|
* Returns
|
|
|
|
* 1 if the request should continue.
|
|
|
|
* In this case we can return an autofs_wait_queue entry if one is
|
|
|
|
* found or NULL to idicate a new wait needs to be created.
|
|
|
|
* 0 or a negative errno if the request shouldn't continue.
|
|
|
|
*/
|
|
|
|
static int validate_request(struct autofs_wait_queue **wait,
|
|
|
|
struct autofs_sb_info *sbi,
|
|
|
|
struct qstr *qstr,
|
|
|
|
struct dentry*dentry, enum autofs_notify notify)
|
|
|
|
{
|
|
|
|
struct autofs_wait_queue *wq;
|
|
|
|
struct autofs_info *ino;
|
|
|
|
|
|
|
|
/* Wait in progress, continue; */
|
|
|
|
wq = autofs4_find_wait(sbi, qstr);
|
|
|
|
if (wq) {
|
|
|
|
*wait = wq;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
*wait = NULL;
|
|
|
|
|
|
|
|
/* If we don't yet have any info this is a new request */
|
|
|
|
ino = autofs4_dentry_ino(dentry);
|
|
|
|
if (!ino)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we've been asked to wait on an existing expire (NFY_NONE)
|
|
|
|
* but there is no wait in the queue ...
|
|
|
|
*/
|
|
|
|
if (notify == NFY_NONE) {
|
|
|
|
/*
|
|
|
|
* Either we've betean the pending expire to post it's
|
|
|
|
* wait or it finished while we waited on the mutex.
|
|
|
|
* So we need to wait till either, the wait appears
|
|
|
|
* or the expire finishes.
|
|
|
|
*/
|
|
|
|
|
|
|
|
while (ino->flags & AUTOFS_INF_EXPIRING) {
|
|
|
|
mutex_unlock(&sbi->wq_mutex);
|
|
|
|
schedule_timeout_interruptible(HZ/10);
|
|
|
|
if (mutex_lock_interruptible(&sbi->wq_mutex))
|
|
|
|
return -EINTR;
|
|
|
|
|
|
|
|
wq = autofs4_find_wait(sbi, qstr);
|
|
|
|
if (wq) {
|
|
|
|
*wait = wq;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Not ideal but the status has already gone. Of the two
|
|
|
|
* cases where we wait on NFY_NONE neither depend on the
|
|
|
|
* return status of the wait.
|
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we've been asked to trigger a mount and the request
|
|
|
|
* completed while we waited on the mutex ...
|
|
|
|
*/
|
|
|
|
if (notify == NFY_MOUNT) {
|
|
|
|
/*
|
|
|
|
* If the dentry isn't hashed just go ahead and try the
|
|
|
|
* mount again with a new wait (not much else we can do).
|
|
|
|
*/
|
|
|
|
if (!d_unhashed(dentry)) {
|
|
|
|
/*
|
|
|
|
* But if the dentry is hashed, that means that we
|
|
|
|
* got here through the revalidate path. Thus, we
|
|
|
|
* need to check if the dentry has been mounted
|
|
|
|
* while we waited on the wq_mutex. If it has,
|
|
|
|
* simply return success.
|
|
|
|
*/
|
|
|
|
if (d_mountpoint(dentry))
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
int autofs4_wait(struct autofs_sb_info *sbi, struct dentry *dentry,
|
|
|
|
enum autofs_notify notify)
|
|
|
|
{
|
|
|
|
struct autofs_wait_queue *wq;
|
2008-07-24 06:30:16 +02:00
|
|
|
struct qstr qstr;
|
2005-04-17 00:20:36 +02:00
|
|
|
char *name;
|
autofs4: fix pending mount race
Close a race between a pending mount that is about to finish and a new
lookup for the same directory.
Process P1 triggers a mount of directory foo. It sets
DCACHE_AUTOFS_PENDING in the ->lookup routine, creates a waitq entry for
'foo', and calls out to the daemon to perform the mount. The autofs
daemon will then create the directory 'foo', using a new dentry that will
be hashed in the dcache.
Before the mount completes, another process, P2, tries to walk into the
'foo' directory. The vfs path walking code finds an entry for 'foo' and
calls the revalidate method. Revalidate finds that the entry is not
PENDING (because PENDING was never set on the dentry created by the
mkdir), but it does find the directory is empty. Revalidate calls
try_to_fill_dentry, which sets the PENDING flag and then calls into the
autofs4 wait code to trigger or wait for a mount of 'foo'. The wait code
finds the entry for 'foo' and goes to sleep waiting for the completion of
the mount.
Yet another process, P3, tries to walk into the 'foo' directory. This
process again finds a dentry in the dcache for 'foo', and calls into the
autofs revalidate code.
The revalidate code finds that the PENDING flag is set, and so calls
try_to_fill_dentry.
a) try_to_fill_dentry sets the PENDING flag redundantly for this
dentry, then calls into the autofs4 wait code.
b) the autofs4 wait code takes the waitq mutex and searches for an
entry for 'foo'
Between a and b, P1 is woken up because the mount completed. P1 takes the
wait queue mutex, clears the PENDING flag from the dentry, and removes the
waitqueue entry for 'foo' from the list.
When it releases the waitq mutex, P3 (eventually) acquires it. At this
time, it looks for an existing waitq for 'foo', finds none, and so creates
a new one and calls out to the daemon to mount the 'foo' directory.
Now, the reason that three processes are required to trigger this race is
that, because the PENDING flag is not set on the dentry created by mkdir,
the window for the race would be way to slim for it to ever occur.
Basically, between the testing of d_mountpoint(dentry) and the taking of
the waitq mutex, the mount would have to complete and the daemon would
have to be woken up, and that in turn would have to wake up P1. This is
simply impossible. Add the third process, though, and it becomes slightly
more likely.
Signed-off-by: Jeff Moyer <jmoyer@redhat.com>
Signed-off-by: Ian Kent <raven@themaw.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-07-24 06:30:19 +02:00
|
|
|
int status, ret, type;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* In catatonic mode, we don't wait for nobody */
|
2006-03-27 11:14:49 +02:00
|
|
|
if (sbi->catatonic)
|
2005-04-17 00:20:36 +02:00
|
|
|
return -ENOENT;
|
autofs4: fix pending mount race
Close a race between a pending mount that is about to finish and a new
lookup for the same directory.
Process P1 triggers a mount of directory foo. It sets
DCACHE_AUTOFS_PENDING in the ->lookup routine, creates a waitq entry for
'foo', and calls out to the daemon to perform the mount. The autofs
daemon will then create the directory 'foo', using a new dentry that will
be hashed in the dcache.
Before the mount completes, another process, P2, tries to walk into the
'foo' directory. The vfs path walking code finds an entry for 'foo' and
calls the revalidate method. Revalidate finds that the entry is not
PENDING (because PENDING was never set on the dentry created by the
mkdir), but it does find the directory is empty. Revalidate calls
try_to_fill_dentry, which sets the PENDING flag and then calls into the
autofs4 wait code to trigger or wait for a mount of 'foo'. The wait code
finds the entry for 'foo' and goes to sleep waiting for the completion of
the mount.
Yet another process, P3, tries to walk into the 'foo' directory. This
process again finds a dentry in the dcache for 'foo', and calls into the
autofs revalidate code.
The revalidate code finds that the PENDING flag is set, and so calls
try_to_fill_dentry.
a) try_to_fill_dentry sets the PENDING flag redundantly for this
dentry, then calls into the autofs4 wait code.
b) the autofs4 wait code takes the waitq mutex and searches for an
entry for 'foo'
Between a and b, P1 is woken up because the mount completed. P1 takes the
wait queue mutex, clears the PENDING flag from the dentry, and removes the
waitqueue entry for 'foo' from the list.
When it releases the waitq mutex, P3 (eventually) acquires it. At this
time, it looks for an existing waitq for 'foo', finds none, and so creates
a new one and calls out to the daemon to mount the 'foo' directory.
Now, the reason that three processes are required to trigger this race is
that, because the PENDING flag is not set on the dentry created by mkdir,
the window for the race would be way to slim for it to ever occur.
Basically, between the testing of d_mountpoint(dentry) and the taking of
the waitq mutex, the mount would have to complete and the daemon would
have to be woken up, and that in turn would have to wake up P1. This is
simply impossible. Add the third process, though, and it becomes slightly
more likely.
Signed-off-by: Jeff Moyer <jmoyer@redhat.com>
Signed-off-by: Ian Kent <raven@themaw.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-07-24 06:30:19 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
name = kmalloc(NAME_MAX + 1, GFP_KERNEL);
|
|
|
|
if (!name)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2006-03-27 11:14:55 +02:00
|
|
|
/* If this is a direct mount request create a dummy name */
|
2006-03-27 11:14:56 +02:00
|
|
|
if (IS_ROOT(dentry) && (sbi->type & AUTOFS_TYPE_DIRECT))
|
2008-07-24 06:30:16 +02:00
|
|
|
qstr.len = sprintf(name, "%p", dentry);
|
2006-03-27 11:14:55 +02:00
|
|
|
else {
|
2008-07-24 06:30:16 +02:00
|
|
|
qstr.len = autofs4_getpath(sbi, dentry, &name);
|
|
|
|
if (!qstr.len) {
|
2006-03-27 11:14:55 +02:00
|
|
|
kfree(name);
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-07-24 06:30:16 +02:00
|
|
|
qstr.name = name;
|
|
|
|
qstr.hash = full_name_hash(name, qstr.len);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-07-24 06:30:19 +02:00
|
|
|
if (mutex_lock_interruptible(&sbi->wq_mutex)) {
|
|
|
|
kfree(qstr.name);
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EINTR;
|
2008-07-24 06:30:19 +02:00
|
|
|
}
|
2006-05-15 18:43:51 +02:00
|
|
|
|
autofs4: fix pending mount race
Close a race between a pending mount that is about to finish and a new
lookup for the same directory.
Process P1 triggers a mount of directory foo. It sets
DCACHE_AUTOFS_PENDING in the ->lookup routine, creates a waitq entry for
'foo', and calls out to the daemon to perform the mount. The autofs
daemon will then create the directory 'foo', using a new dentry that will
be hashed in the dcache.
Before the mount completes, another process, P2, tries to walk into the
'foo' directory. The vfs path walking code finds an entry for 'foo' and
calls the revalidate method. Revalidate finds that the entry is not
PENDING (because PENDING was never set on the dentry created by the
mkdir), but it does find the directory is empty. Revalidate calls
try_to_fill_dentry, which sets the PENDING flag and then calls into the
autofs4 wait code to trigger or wait for a mount of 'foo'. The wait code
finds the entry for 'foo' and goes to sleep waiting for the completion of
the mount.
Yet another process, P3, tries to walk into the 'foo' directory. This
process again finds a dentry in the dcache for 'foo', and calls into the
autofs revalidate code.
The revalidate code finds that the PENDING flag is set, and so calls
try_to_fill_dentry.
a) try_to_fill_dentry sets the PENDING flag redundantly for this
dentry, then calls into the autofs4 wait code.
b) the autofs4 wait code takes the waitq mutex and searches for an
entry for 'foo'
Between a and b, P1 is woken up because the mount completed. P1 takes the
wait queue mutex, clears the PENDING flag from the dentry, and removes the
waitqueue entry for 'foo' from the list.
When it releases the waitq mutex, P3 (eventually) acquires it. At this
time, it looks for an existing waitq for 'foo', finds none, and so creates
a new one and calls out to the daemon to mount the 'foo' directory.
Now, the reason that three processes are required to trigger this race is
that, because the PENDING flag is not set on the dentry created by mkdir,
the window for the race would be way to slim for it to ever occur.
Basically, between the testing of d_mountpoint(dentry) and the taking of
the waitq mutex, the mount would have to complete and the daemon would
have to be woken up, and that in turn would have to wake up P1. This is
simply impossible. Add the third process, though, and it becomes slightly
more likely.
Signed-off-by: Jeff Moyer <jmoyer@redhat.com>
Signed-off-by: Ian Kent <raven@themaw.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-07-24 06:30:19 +02:00
|
|
|
ret = validate_request(&wq, sbi, &qstr, dentry, notify);
|
|
|
|
if (ret <= 0) {
|
|
|
|
if (ret == 0)
|
2006-03-23 12:00:41 +01:00
|
|
|
mutex_unlock(&sbi->wq_mutex);
|
autofs4: fix pending mount race
Close a race between a pending mount that is about to finish and a new
lookup for the same directory.
Process P1 triggers a mount of directory foo. It sets
DCACHE_AUTOFS_PENDING in the ->lookup routine, creates a waitq entry for
'foo', and calls out to the daemon to perform the mount. The autofs
daemon will then create the directory 'foo', using a new dentry that will
be hashed in the dcache.
Before the mount completes, another process, P2, tries to walk into the
'foo' directory. The vfs path walking code finds an entry for 'foo' and
calls the revalidate method. Revalidate finds that the entry is not
PENDING (because PENDING was never set on the dentry created by the
mkdir), but it does find the directory is empty. Revalidate calls
try_to_fill_dentry, which sets the PENDING flag and then calls into the
autofs4 wait code to trigger or wait for a mount of 'foo'. The wait code
finds the entry for 'foo' and goes to sleep waiting for the completion of
the mount.
Yet another process, P3, tries to walk into the 'foo' directory. This
process again finds a dentry in the dcache for 'foo', and calls into the
autofs revalidate code.
The revalidate code finds that the PENDING flag is set, and so calls
try_to_fill_dentry.
a) try_to_fill_dentry sets the PENDING flag redundantly for this
dentry, then calls into the autofs4 wait code.
b) the autofs4 wait code takes the waitq mutex and searches for an
entry for 'foo'
Between a and b, P1 is woken up because the mount completed. P1 takes the
wait queue mutex, clears the PENDING flag from the dentry, and removes the
waitqueue entry for 'foo' from the list.
When it releases the waitq mutex, P3 (eventually) acquires it. At this
time, it looks for an existing waitq for 'foo', finds none, and so creates
a new one and calls out to the daemon to mount the 'foo' directory.
Now, the reason that three processes are required to trigger this race is
that, because the PENDING flag is not set on the dentry created by mkdir,
the window for the race would be way to slim for it to ever occur.
Basically, between the testing of d_mountpoint(dentry) and the taking of
the waitq mutex, the mount would have to complete and the daemon would
have to be woken up, and that in turn would have to wake up P1. This is
simply impossible. Add the third process, though, and it becomes slightly
more likely.
Signed-off-by: Jeff Moyer <jmoyer@redhat.com>
Signed-off-by: Ian Kent <raven@themaw.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-07-24 06:30:19 +02:00
|
|
|
kfree(qstr.name);
|
|
|
|
return ret;
|
2006-05-15 18:43:51 +02:00
|
|
|
}
|
2005-06-22 02:16:39 +02:00
|
|
|
|
2006-05-15 18:43:51 +02:00
|
|
|
if (!wq) {
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Create a new wait queue */
|
|
|
|
wq = kmalloc(sizeof(struct autofs_wait_queue),GFP_KERNEL);
|
2006-03-27 11:14:49 +02:00
|
|
|
if (!wq) {
|
2008-07-24 06:30:16 +02:00
|
|
|
kfree(qstr.name);
|
2006-03-23 12:00:41 +01:00
|
|
|
mutex_unlock(&sbi->wq_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
wq->wait_queue_token = autofs4_next_wait_queue;
|
|
|
|
if (++autofs4_next_wait_queue == 0)
|
|
|
|
autofs4_next_wait_queue = 1;
|
|
|
|
wq->next = sbi->queues;
|
|
|
|
sbi->queues = wq;
|
|
|
|
init_waitqueue_head(&wq->queue);
|
2008-07-24 06:30:16 +02:00
|
|
|
memcpy(&wq->name, &qstr, sizeof(struct qstr));
|
2006-03-27 11:14:55 +02:00
|
|
|
wq->dev = autofs4_get_dev(sbi);
|
|
|
|
wq->ino = autofs4_get_ino(sbi);
|
|
|
|
wq->uid = current->uid;
|
|
|
|
wq->gid = current->gid;
|
|
|
|
wq->pid = current->pid;
|
|
|
|
wq->tgid = current->tgid;
|
2005-04-17 00:20:36 +02:00
|
|
|
wq->status = -EINTR; /* Status return if interrupted */
|
|
|
|
atomic_set(&wq->wait_ctr, 2);
|
2006-03-23 12:00:41 +01:00
|
|
|
mutex_unlock(&sbi->wq_mutex);
|
2006-03-27 11:14:59 +02:00
|
|
|
|
2006-03-27 11:14:55 +02:00
|
|
|
if (sbi->version < 5) {
|
|
|
|
if (notify == NFY_MOUNT)
|
|
|
|
type = autofs_ptype_missing;
|
|
|
|
else
|
|
|
|
type = autofs_ptype_expire_multi;
|
|
|
|
} else {
|
|
|
|
if (notify == NFY_MOUNT)
|
2006-03-27 11:14:56 +02:00
|
|
|
type = (sbi->type & AUTOFS_TYPE_DIRECT) ?
|
2006-03-27 11:14:55 +02:00
|
|
|
autofs_ptype_missing_direct :
|
|
|
|
autofs_ptype_missing_indirect;
|
|
|
|
else
|
2006-03-27 11:14:56 +02:00
|
|
|
type = (sbi->type & AUTOFS_TYPE_DIRECT) ?
|
2006-03-27 11:14:55 +02:00
|
|
|
autofs_ptype_expire_direct :
|
|
|
|
autofs_ptype_expire_indirect;
|
|
|
|
}
|
2005-05-01 17:59:16 +02:00
|
|
|
|
2005-07-08 02:57:02 +02:00
|
|
|
DPRINTK("new wait id = 0x%08lx, name = %.*s, nfy=%d\n",
|
2008-07-24 06:30:16 +02:00
|
|
|
(unsigned long) wq->wait_queue_token, wq->name.len,
|
|
|
|
wq->name.name, notify);
|
2005-05-01 17:59:16 +02:00
|
|
|
|
|
|
|
/* autofs4_notify_daemon() may block */
|
|
|
|
autofs4_notify_daemon(sbi, wq, type);
|
2006-05-15 18:43:51 +02:00
|
|
|
} else {
|
|
|
|
atomic_inc(&wq->wait_ctr);
|
|
|
|
mutex_unlock(&sbi->wq_mutex);
|
2008-07-24 06:30:16 +02:00
|
|
|
kfree(qstr.name);
|
2006-05-15 18:43:51 +02:00
|
|
|
DPRINTK("existing wait id = 0x%08lx, name = %.*s, nfy=%d",
|
2008-07-24 06:30:16 +02:00
|
|
|
(unsigned long) wq->wait_queue_token, wq->name.len,
|
|
|
|
wq->name.name, notify);
|
2005-05-01 17:59:16 +02:00
|
|
|
}
|
|
|
|
|
2008-07-24 06:30:17 +02:00
|
|
|
/*
|
|
|
|
* wq->name.name is NULL iff the lock is already released
|
|
|
|
* or the mount has been made catatonic.
|
|
|
|
*/
|
2008-07-24 06:30:16 +02:00
|
|
|
if (wq->name.name) {
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Block all but "shutdown" signals while waiting */
|
|
|
|
sigset_t oldset;
|
|
|
|
unsigned long irqflags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(¤t->sighand->siglock, irqflags);
|
|
|
|
oldset = current->blocked;
|
|
|
|
siginitsetinv(¤t->blocked, SHUTDOWN_SIGS & ~oldset.sig[0]);
|
|
|
|
recalc_sigpending();
|
|
|
|
spin_unlock_irqrestore(¤t->sighand->siglock, irqflags);
|
|
|
|
|
2008-07-24 06:30:16 +02:00
|
|
|
wait_event_interruptible(wq->queue, wq->name.name == NULL);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
spin_lock_irqsave(¤t->sighand->siglock, irqflags);
|
|
|
|
current->blocked = oldset;
|
|
|
|
recalc_sigpending();
|
|
|
|
spin_unlock_irqrestore(¤t->sighand->siglock, irqflags);
|
|
|
|
} else {
|
|
|
|
DPRINTK("skipped sleeping");
|
|
|
|
}
|
|
|
|
|
|
|
|
status = wq->status;
|
|
|
|
|
|
|
|
/* Are we the last process to need status? */
|
|
|
|
if (atomic_dec_and_test(&wq->wait_ctr))
|
|
|
|
kfree(wq);
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int autofs4_wait_release(struct autofs_sb_info *sbi, autofs_wqt_t wait_queue_token, int status)
|
|
|
|
{
|
|
|
|
struct autofs_wait_queue *wq, **wql;
|
|
|
|
|
2006-03-23 12:00:41 +01:00
|
|
|
mutex_lock(&sbi->wq_mutex);
|
2007-10-18 12:07:05 +02:00
|
|
|
for (wql = &sbi->queues; (wq = *wql) != NULL; wql = &wq->next) {
|
2006-03-27 11:14:49 +02:00
|
|
|
if (wq->wait_queue_token == wait_queue_token)
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2006-03-27 11:14:49 +02:00
|
|
|
if (!wq) {
|
2006-03-23 12:00:41 +01:00
|
|
|
mutex_unlock(&sbi->wq_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
*wql = wq->next; /* Unlink from chain */
|
2008-07-24 06:30:16 +02:00
|
|
|
kfree(wq->name.name);
|
|
|
|
wq->name.name = NULL; /* Do not wait on this queue */
|
autofs4: fix pending mount race
Close a race between a pending mount that is about to finish and a new
lookup for the same directory.
Process P1 triggers a mount of directory foo. It sets
DCACHE_AUTOFS_PENDING in the ->lookup routine, creates a waitq entry for
'foo', and calls out to the daemon to perform the mount. The autofs
daemon will then create the directory 'foo', using a new dentry that will
be hashed in the dcache.
Before the mount completes, another process, P2, tries to walk into the
'foo' directory. The vfs path walking code finds an entry for 'foo' and
calls the revalidate method. Revalidate finds that the entry is not
PENDING (because PENDING was never set on the dentry created by the
mkdir), but it does find the directory is empty. Revalidate calls
try_to_fill_dentry, which sets the PENDING flag and then calls into the
autofs4 wait code to trigger or wait for a mount of 'foo'. The wait code
finds the entry for 'foo' and goes to sleep waiting for the completion of
the mount.
Yet another process, P3, tries to walk into the 'foo' directory. This
process again finds a dentry in the dcache for 'foo', and calls into the
autofs revalidate code.
The revalidate code finds that the PENDING flag is set, and so calls
try_to_fill_dentry.
a) try_to_fill_dentry sets the PENDING flag redundantly for this
dentry, then calls into the autofs4 wait code.
b) the autofs4 wait code takes the waitq mutex and searches for an
entry for 'foo'
Between a and b, P1 is woken up because the mount completed. P1 takes the
wait queue mutex, clears the PENDING flag from the dentry, and removes the
waitqueue entry for 'foo' from the list.
When it releases the waitq mutex, P3 (eventually) acquires it. At this
time, it looks for an existing waitq for 'foo', finds none, and so creates
a new one and calls out to the daemon to mount the 'foo' directory.
Now, the reason that three processes are required to trigger this race is
that, because the PENDING flag is not set on the dentry created by mkdir,
the window for the race would be way to slim for it to ever occur.
Basically, between the testing of d_mountpoint(dentry) and the taking of
the waitq mutex, the mount would have to complete and the daemon would
have to be woken up, and that in turn would have to wake up P1. This is
simply impossible. Add the third process, though, and it becomes slightly
more likely.
Signed-off-by: Jeff Moyer <jmoyer@redhat.com>
Signed-off-by: Ian Kent <raven@themaw.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-07-24 06:30:19 +02:00
|
|
|
mutex_unlock(&sbi->wq_mutex);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
wq->status = status;
|
|
|
|
|
|
|
|
if (atomic_dec_and_test(&wq->wait_ctr)) /* Is anyone still waiting for this guy? */
|
|
|
|
kfree(wq);
|
|
|
|
else
|
|
|
|
wake_up_interruptible(&wq->queue);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|