2005-11-07 01:58:51 -07:00
|
|
|
/*
|
2005-04-16 15:20:36 -07:00
|
|
|
* Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
|
|
|
|
* Licensed under the GPL
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <sched.h>
|
2006-11-25 12:09:39 -07:00
|
|
|
#include <limits.h>
|
2005-04-16 15:20:36 -07:00
|
|
|
#include <sys/signal.h>
|
|
|
|
#include <sys/wait.h>
|
2007-10-16 01:27:11 -07:00
|
|
|
#include <sys/socket.h>
|
2005-04-16 15:20:36 -07:00
|
|
|
#include "user.h"
|
|
|
|
#include "kern_util.h"
|
|
|
|
#include "os.h"
|
2006-11-25 12:09:39 -07:00
|
|
|
#include "um_malloc.h"
|
2007-05-06 14:51:22 -07:00
|
|
|
#include "kern_constants.h"
|
2005-04-16 15:20:36 -07:00
|
|
|
|
|
|
|
struct helper_data {
|
|
|
|
void (*pre_exec)(void*);
|
|
|
|
void *pre_data;
|
|
|
|
char **argv;
|
|
|
|
int fd;
|
2006-11-25 12:09:39 -07:00
|
|
|
char *buf;
|
2005-04-16 15:20:36 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
static int helper_child(void *arg)
|
|
|
|
{
|
|
|
|
struct helper_data *data = arg;
|
|
|
|
char **argv = data->argv;
|
|
|
|
int errval;
|
|
|
|
|
2006-10-19 23:28:21 -07:00
|
|
|
if (data->pre_exec != NULL)
|
2005-04-16 15:20:36 -07:00
|
|
|
(*data->pre_exec)(data->pre_data);
|
2006-11-25 12:09:39 -07:00
|
|
|
errval = execvp_noalloc(data->buf, argv[0], argv);
|
2007-05-06 14:51:33 -07:00
|
|
|
printk("helper_child - execvp of '%s' failed - errno = %d\n", argv[0],
|
|
|
|
-errval);
|
2007-05-06 14:51:35 -07:00
|
|
|
write(data->fd, &errval, sizeof(errval));
|
2005-11-07 01:58:51 -07:00
|
|
|
kill(os_getpid(), SIGKILL);
|
2006-10-19 23:28:21 -07:00
|
|
|
return 0;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Returns either the pid of the child process we run or -E* on failure.
|
2006-10-19 23:28:24 -07:00
|
|
|
* XXX The alloc_stack here breaks if this is called in the tracing thread, so
|
|
|
|
* we need to receive a preallocated stack (a local buffer is ok). */
|
2007-07-15 23:38:56 -07:00
|
|
|
int run_helper(void (*pre_exec)(void *), void *pre_data, char **argv)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
struct helper_data data;
|
|
|
|
unsigned long stack, sp;
|
|
|
|
int pid, fds[2], ret, n;
|
|
|
|
|
2007-07-15 23:38:56 -07:00
|
|
|
stack = alloc_stack(0, __cant_sleep());
|
2006-10-19 23:28:21 -07:00
|
|
|
if (stack == 0)
|
2006-09-25 23:33:02 -07:00
|
|
|
return -ENOMEM;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2007-10-16 01:27:11 -07:00
|
|
|
ret = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
|
2006-10-19 23:28:21 -07:00
|
|
|
if (ret < 0) {
|
2007-10-16 01:27:11 -07:00
|
|
|
ret = -errno;
|
|
|
|
printk("run_helper : pipe failed, errno = %d\n", errno);
|
2005-04-16 15:20:36 -07:00
|
|
|
goto out_free;
|
|
|
|
}
|
|
|
|
|
2007-10-16 01:27:11 -07:00
|
|
|
ret = os_set_exec_close(fds[1]);
|
2006-10-19 23:28:21 -07:00
|
|
|
if (ret < 0) {
|
2005-04-16 15:20:36 -07:00
|
|
|
printk("run_helper : setting FD_CLOEXEC failed, ret = %d\n",
|
|
|
|
-ret);
|
|
|
|
goto out_close;
|
|
|
|
}
|
|
|
|
|
2007-05-06 14:51:22 -07:00
|
|
|
sp = stack + UM_KERN_PAGE_SIZE - sizeof(void *);
|
2005-04-16 15:20:36 -07:00
|
|
|
data.pre_exec = pre_exec;
|
|
|
|
data.pre_data = pre_data;
|
|
|
|
data.argv = argv;
|
|
|
|
data.fd = fds[1];
|
2007-07-15 23:38:56 -07:00
|
|
|
data.buf = __cant_sleep() ? kmalloc(PATH_MAX, UM_GFP_ATOMIC) :
|
|
|
|
kmalloc(PATH_MAX, UM_GFP_KERNEL);
|
2005-04-16 15:20:36 -07:00
|
|
|
pid = clone(helper_child, (void *) sp, CLONE_VM | SIGCHLD, &data);
|
2006-10-19 23:28:21 -07:00
|
|
|
if (pid < 0) {
|
2005-04-16 15:20:36 -07:00
|
|
|
ret = -errno;
|
[PATCH] uml: preserve errno in error paths
The poster child for this patch is the third tuntap_user hunk. When an ioctl
fails, it properly closes the opened file descriptor and returns. However,
the close resets errno to 0, and the 'return errno' that follows returns 0
rather than the value that ioctl set. This caused the caller to believe that
the device open succeeded and had opened file descriptor 0, which caused no
end of interesting behavior.
The rest of this patch is a pass through the UML sources looking for places
where errno could be reset before being passed back out. A common culprit is
printk, which could call write, being called before errno is returned.
In some cases, where the code ends up being much smaller, I just deleted the
printk.
There was another case where a caller of run_helper looked at errno after a
failure, rather than the return value of run_helper, which was the errno value
that it wanted.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-09-16 19:27:49 -07:00
|
|
|
printk("run_helper : clone failed, errno = %d\n", errno);
|
2006-11-25 12:09:39 -07:00
|
|
|
goto out_free2;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
2005-11-07 01:58:51 -07:00
|
|
|
close(fds[1]);
|
2005-04-16 15:20:36 -07:00
|
|
|
fds[1] = -1;
|
|
|
|
|
2007-05-06 14:51:33 -07:00
|
|
|
/*
|
|
|
|
* Read the errno value from the child, if the exec failed, or get 0 if
|
|
|
|
* the exec succeeded because the pipe fd was set as close-on-exec.
|
|
|
|
*/
|
2007-05-06 14:51:35 -07:00
|
|
|
n = read(fds[0], &ret, sizeof(ret));
|
2006-10-19 23:28:21 -07:00
|
|
|
if (n == 0) {
|
2005-04-16 15:20:36 -07:00
|
|
|
ret = pid;
|
2006-10-19 23:28:21 -07:00
|
|
|
} else {
|
|
|
|
if (n < 0) {
|
2007-05-06 14:51:35 -07:00
|
|
|
n = -errno;
|
2006-09-25 23:33:02 -07:00
|
|
|
printk("run_helper : read on pipe failed, ret = %d\n",
|
|
|
|
-n);
|
|
|
|
ret = n;
|
|
|
|
kill(pid, SIGKILL);
|
|
|
|
}
|
|
|
|
CATCH_EINTR(waitpid(pid, NULL, 0));
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
2006-11-25 12:09:39 -07:00
|
|
|
out_free2:
|
|
|
|
kfree(data.buf);
|
2005-04-16 15:20:36 -07:00
|
|
|
out_close:
|
|
|
|
if (fds[1] != -1)
|
2005-11-07 01:58:51 -07:00
|
|
|
close(fds[1]);
|
|
|
|
close(fds[0]);
|
2005-04-16 15:20:36 -07:00
|
|
|
out_free:
|
2007-07-15 23:38:56 -07:00
|
|
|
free_stack(stack, 0);
|
2006-10-19 23:28:21 -07:00
|
|
|
return ret;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
2005-11-07 01:58:51 -07:00
|
|
|
int run_helper_thread(int (*proc)(void *), void *arg, unsigned int flags,
|
2007-07-15 23:38:56 -07:00
|
|
|
unsigned long *stack_out)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
unsigned long stack, sp;
|
[PATCH] uml: preserve errno in error paths
The poster child for this patch is the third tuntap_user hunk. When an ioctl
fails, it properly closes the opened file descriptor and returns. However,
the close resets errno to 0, and the 'return errno' that follows returns 0
rather than the value that ioctl set. This caused the caller to believe that
the device open succeeded and had opened file descriptor 0, which caused no
end of interesting behavior.
The rest of this patch is a pass through the UML sources looking for places
where errno could be reset before being passed back out. A common culprit is
printk, which could call write, being called before errno is returned.
In some cases, where the code ends up being much smaller, I just deleted the
printk.
There was another case where a caller of run_helper looked at errno after a
failure, rather than the return value of run_helper, which was the errno value
that it wanted.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-09-16 19:27:49 -07:00
|
|
|
int pid, status, err;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2007-07-15 23:38:56 -07:00
|
|
|
stack = alloc_stack(0, __cant_sleep());
|
2006-10-19 23:28:21 -07:00
|
|
|
if (stack == 0)
|
|
|
|
return -ENOMEM;
|
2005-04-16 15:20:36 -07:00
|
|
|
|
2007-07-15 23:38:56 -07:00
|
|
|
sp = stack + UM_KERN_PAGE_SIZE - sizeof(void *);
|
2005-04-16 15:20:36 -07:00
|
|
|
pid = clone(proc, (void *) sp, flags | SIGCHLD, arg);
|
2006-10-19 23:28:21 -07:00
|
|
|
if (pid < 0) {
|
[PATCH] uml: preserve errno in error paths
The poster child for this patch is the third tuntap_user hunk. When an ioctl
fails, it properly closes the opened file descriptor and returns. However,
the close resets errno to 0, and the 'return errno' that follows returns 0
rather than the value that ioctl set. This caused the caller to believe that
the device open succeeded and had opened file descriptor 0, which caused no
end of interesting behavior.
The rest of this patch is a pass through the UML sources looking for places
where errno could be reset before being passed back out. A common culprit is
printk, which could call write, being called before errno is returned.
In some cases, where the code ends up being much smaller, I just deleted the
printk.
There was another case where a caller of run_helper looked at errno after a
failure, rather than the return value of run_helper, which was the errno value
that it wanted.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-09-16 19:27:49 -07:00
|
|
|
err = -errno;
|
2005-11-07 01:58:51 -07:00
|
|
|
printk("run_helper_thread : clone failed, errno = %d\n",
|
2005-04-16 15:20:36 -07:00
|
|
|
errno);
|
[PATCH] uml: preserve errno in error paths
The poster child for this patch is the third tuntap_user hunk. When an ioctl
fails, it properly closes the opened file descriptor and returns. However,
the close resets errno to 0, and the 'return errno' that follows returns 0
rather than the value that ioctl set. This caused the caller to believe that
the device open succeeded and had opened file descriptor 0, which caused no
end of interesting behavior.
The rest of this patch is a pass through the UML sources looking for places
where errno could be reset before being passed back out. A common culprit is
printk, which could call write, being called before errno is returned.
In some cases, where the code ends up being much smaller, I just deleted the
printk.
There was another case where a caller of run_helper looked at errno after a
failure, rather than the return value of run_helper, which was the errno value
that it wanted.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-09-16 19:27:49 -07:00
|
|
|
return err;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
2006-10-19 23:28:21 -07:00
|
|
|
if (stack_out == NULL) {
|
2005-04-16 15:20:36 -07:00
|
|
|
CATCH_EINTR(pid = waitpid(pid, &status, 0));
|
2006-10-19 23:28:21 -07:00
|
|
|
if (pid < 0) {
|
[PATCH] uml: preserve errno in error paths
The poster child for this patch is the third tuntap_user hunk. When an ioctl
fails, it properly closes the opened file descriptor and returns. However,
the close resets errno to 0, and the 'return errno' that follows returns 0
rather than the value that ioctl set. This caused the caller to believe that
the device open succeeded and had opened file descriptor 0, which caused no
end of interesting behavior.
The rest of this patch is a pass through the UML sources looking for places
where errno could be reset before being passed back out. A common culprit is
printk, which could call write, being called before errno is returned.
In some cases, where the code ends up being much smaller, I just deleted the
printk.
There was another case where a caller of run_helper looked at errno after a
failure, rather than the return value of run_helper, which was the errno value
that it wanted.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-09-16 19:27:49 -07:00
|
|
|
err = -errno;
|
2005-04-16 15:20:36 -07:00
|
|
|
printk("run_helper_thread - wait failed, errno = %d\n",
|
|
|
|
errno);
|
[PATCH] uml: preserve errno in error paths
The poster child for this patch is the third tuntap_user hunk. When an ioctl
fails, it properly closes the opened file descriptor and returns. However,
the close resets errno to 0, and the 'return errno' that follows returns 0
rather than the value that ioctl set. This caused the caller to believe that
the device open succeeded and had opened file descriptor 0, which caused no
end of interesting behavior.
The rest of this patch is a pass through the UML sources looking for places
where errno could be reset before being passed back out. A common culprit is
printk, which could call write, being called before errno is returned.
In some cases, where the code ends up being much smaller, I just deleted the
printk.
There was another case where a caller of run_helper looked at errno after a
failure, rather than the return value of run_helper, which was the errno value
that it wanted.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-09-16 19:27:49 -07:00
|
|
|
pid = err;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
2006-10-19 23:28:21 -07:00
|
|
|
if (!WIFEXITED(status) || (WEXITSTATUS(status) != 0))
|
2005-04-16 15:20:36 -07:00
|
|
|
printk("run_helper_thread - thread returned status "
|
|
|
|
"0x%x\n", status);
|
2007-07-15 23:38:56 -07:00
|
|
|
free_stack(stack, 0);
|
2006-10-19 23:28:21 -07:00
|
|
|
} else
|
|
|
|
*stack_out = stack;
|
|
|
|
return pid;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|
|
|
|
|
2005-07-27 11:43:33 -07:00
|
|
|
int helper_wait(int pid)
|
2005-04-16 15:20:36 -07:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
CATCH_EINTR(ret = waitpid(pid, NULL, WNOHANG));
|
2006-10-19 23:28:21 -07:00
|
|
|
if (ret < 0) {
|
[PATCH] uml: preserve errno in error paths
The poster child for this patch is the third tuntap_user hunk. When an ioctl
fails, it properly closes the opened file descriptor and returns. However,
the close resets errno to 0, and the 'return errno' that follows returns 0
rather than the value that ioctl set. This caused the caller to believe that
the device open succeeded and had opened file descriptor 0, which caused no
end of interesting behavior.
The rest of this patch is a pass through the UML sources looking for places
where errno could be reset before being passed back out. A common culprit is
printk, which could call write, being called before errno is returned.
In some cases, where the code ends up being much smaller, I just deleted the
printk.
There was another case where a caller of run_helper looked at errno after a
failure, rather than the return value of run_helper, which was the errno value
that it wanted.
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-09-16 19:27:49 -07:00
|
|
|
ret = -errno;
|
2005-04-16 15:20:36 -07:00
|
|
|
printk("helper_wait : waitpid failed, errno = %d\n", errno);
|
|
|
|
}
|
2006-10-19 23:28:21 -07:00
|
|
|
return ret;
|
2005-04-16 15:20:36 -07:00
|
|
|
}
|