2006-01-19 02:42:41 +01:00
|
|
|
/*
|
2008-02-08 13:22:08 +01:00
|
|
|
* Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
|
2005-04-17 00:20:36 +02:00
|
|
|
* Licensed under the GPL
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
2011-05-18 00:44:11 +02:00
|
|
|
#include <unistd.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <errno.h>
|
2008-02-08 13:22:08 +01:00
|
|
|
#include <signal.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <string.h>
|
2008-02-08 13:22:08 +01:00
|
|
|
#include <termios.h>
|
|
|
|
#include <wait.h>
|
|
|
|
#include <sys/mman.h>
|
|
|
|
#include <sys/utsname.h>
|
2012-10-08 04:27:32 +02:00
|
|
|
#include <os.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
void stack_protections(unsigned long address)
|
|
|
|
{
|
2008-02-08 13:22:08 +01:00
|
|
|
if (mprotect((void *) address, UM_THREAD_SIZE,
|
2007-05-11 07:22:30 +02:00
|
|
|
PROT_READ | PROT_WRITE | PROT_EXEC) < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
panic("protecting stack failed, errno = %d", errno);
|
|
|
|
}
|
|
|
|
|
|
|
|
int raw(int fd)
|
|
|
|
{
|
|
|
|
struct termios tt;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
CATCH_EINTR(err = tcgetattr(fd, &tt));
|
2008-02-08 13:22:08 +01:00
|
|
|
if (err < 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-17 04:27:49 +02:00
|
|
|
return -errno;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
cfmakeraw(&tt);
|
|
|
|
|
2006-01-19 02:42:41 +01:00
|
|
|
CATCH_EINTR(err = tcsetattr(fd, TCSADRAIN, &tt));
|
2008-02-08 13:22:08 +01:00
|
|
|
if (err < 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-17 04:27:49 +02:00
|
|
|
return -errno;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-02-08 13:22:08 +01:00
|
|
|
/*
|
|
|
|
* XXX tcsetattr could have applied only some changes
|
|
|
|
* (and cfmakeraw() is a set of changes)
|
|
|
|
*/
|
2007-05-11 07:22:30 +02:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void setup_machinename(char *machine_out)
|
|
|
|
{
|
|
|
|
struct utsname host;
|
|
|
|
|
|
|
|
uname(&host);
|
2006-10-11 10:21:36 +02:00
|
|
|
#ifdef UML_CONFIG_UML_X86
|
|
|
|
# ifndef UML_CONFIG_64BIT
|
2005-09-21 18:39:14 +02:00
|
|
|
if (!strcmp(host.machine, "x86_64")) {
|
|
|
|
strcpy(machine_out, "i686");
|
|
|
|
return;
|
|
|
|
}
|
2006-10-11 10:21:36 +02:00
|
|
|
# else
|
|
|
|
if (!strcmp(host.machine, "i686")) {
|
|
|
|
strcpy(machine_out, "x86_64");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
# endif
|
2005-09-21 18:39:14 +02:00
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
strcpy(machine_out, host.machine);
|
|
|
|
}
|
|
|
|
|
2007-05-06 23:50:59 +02:00
|
|
|
void setup_hostinfo(char *buf, int len)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct utsname host;
|
|
|
|
|
|
|
|
uname(&host);
|
2007-05-06 23:50:59 +02:00
|
|
|
snprintf(buf, len, "%s %s %s %s %s", host.sysname, host.nodename,
|
|
|
|
host.release, host.version, host.machine);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2011-05-18 00:44:11 +02:00
|
|
|
/*
|
|
|
|
* We cannot use glibc's abort(). It makes use of tgkill() which
|
|
|
|
* has no effect within UML's kernel threads.
|
|
|
|
* After that glibc would execute an invalid instruction to kill
|
|
|
|
* the calling process and UML crashes with SIGSEGV.
|
|
|
|
*/
|
|
|
|
static inline void __attribute__ ((noreturn)) uml_abort(void)
|
|
|
|
{
|
|
|
|
sigset_t sig;
|
|
|
|
|
|
|
|
fflush(NULL);
|
|
|
|
|
|
|
|
if (!sigemptyset(&sig) && !sigaddset(&sig, SIGABRT))
|
|
|
|
sigprocmask(SIG_UNBLOCK, &sig, 0);
|
|
|
|
|
|
|
|
for (;;)
|
|
|
|
if (kill(getpid(), SIGABRT) < 0)
|
|
|
|
exit(127);
|
|
|
|
}
|
|
|
|
|
2007-05-06 23:51:39 +02:00
|
|
|
void os_dump_core(void)
|
|
|
|
{
|
2007-10-16 10:27:35 +02:00
|
|
|
int pid;
|
|
|
|
|
2007-05-06 23:51:39 +02:00
|
|
|
signal(SIGSEGV, SIG_DFL);
|
2007-10-16 10:27:35 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We are about to SIGTERM this entire process group to ensure that
|
|
|
|
* nothing is around to run after the kernel exits. The
|
|
|
|
* kernel wants to abort, not die through SIGTERM, so we
|
|
|
|
* ignore it here.
|
|
|
|
*/
|
|
|
|
|
|
|
|
signal(SIGTERM, SIG_IGN);
|
|
|
|
kill(0, SIGTERM);
|
|
|
|
/*
|
|
|
|
* Most of the other processes associated with this UML are
|
|
|
|
* likely sTopped, so give them a SIGCONT so they see the
|
|
|
|
* SIGTERM.
|
|
|
|
*/
|
|
|
|
kill(0, SIGCONT);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now, having sent signals to everyone but us, make sure they
|
|
|
|
* die by ptrace. Processes can survive what's been done to
|
|
|
|
* them so far - the mechanism I understand is receiving a
|
|
|
|
* SIGSEGV and segfaulting immediately upon return. There is
|
|
|
|
* always a SIGSEGV pending, and (I'm guessing) signals are
|
|
|
|
* processed in numeric order so the SIGTERM (signal 15 vs
|
|
|
|
* SIGSEGV being signal 11) is never handled.
|
|
|
|
*
|
|
|
|
* Run a waitpid loop until we get some kind of error.
|
|
|
|
* Hopefully, it's ECHILD, but there's not a lot we can do if
|
|
|
|
* it's something else. Tell os_kill_ptraced_process not to
|
|
|
|
* wait for the child to report its death because there's
|
|
|
|
* nothing reasonable to do if that fails.
|
|
|
|
*/
|
|
|
|
|
2007-12-18 01:19:46 +01:00
|
|
|
while ((pid = waitpid(-1, NULL, WNOHANG | __WALL)) > 0)
|
2007-10-16 10:27:35 +02:00
|
|
|
os_kill_ptraced_process(pid, 0);
|
|
|
|
|
2011-05-18 00:44:11 +02:00
|
|
|
uml_abort();
|
2007-05-06 23:51:39 +02:00
|
|
|
}
|
2011-05-25 02:13:01 +02:00
|
|
|
|
|
|
|
void um_early_printk(const char *s, unsigned int n)
|
|
|
|
{
|
|
|
|
printf("%.*s", n, s);
|
|
|
|
}
|