mirror of
https://github.com/FEX-Emu/linux.git
synced 2024-12-23 01:40:30 +00:00
4dbed85a35
Sometimes when UML is debugged gdb miss breakpoints. When process traced by gdb do fork, debugger remove breakpoints from child address space. There is possibility to trace more than one fork, but this not work with UML, I guess (only guess) there is a deadlock - gdb waits for UML and UML waits for gdb. When clone() is called with SIGCHLD and CLONE_VM flags, gdb see this as PTRACE_EVENT_FORK not as PTRACE_EVENT_CLONE and remove breakpoints from child and at the same time from traced process, because either have the same address space. Maybe it is possible to do fix in gdb, but I'm not sure if there is easy way to find out if traced and child processes share memory. So I do fix for UML, it simply do not call clone() with both SIGCHLD and CLONE_VM flags together. Additionally __WALL flag is used for waitpid() to assure not miss clone and normal process events. [ jdike - checkpatch fixes ] Signed-off-by: Stanislaw Gruszka <stf_xl@wp.pl> Signed-off-by: Jeff Dike <jdike@linux.intel.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
149 lines
3.2 KiB
C
149 lines
3.2 KiB
C
/*
|
|
* Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
|
|
* Licensed under the GPL
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <limits.h>
|
|
#include <sys/mman.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/utsname.h>
|
|
#include <sys/param.h>
|
|
#include <sys/time.h>
|
|
#include "asm/types.h"
|
|
#include <ctype.h>
|
|
#include <signal.h>
|
|
#include <wait.h>
|
|
#include <errno.h>
|
|
#include <stdarg.h>
|
|
#include <sched.h>
|
|
#include <termios.h>
|
|
#include <string.h>
|
|
#include "kern_util.h"
|
|
#include "user.h"
|
|
#include "mem_user.h"
|
|
#include "init.h"
|
|
#include "ptrace_user.h"
|
|
#include "uml-config.h"
|
|
#include "os.h"
|
|
#include "longjmp.h"
|
|
#include "kern_constants.h"
|
|
|
|
void stack_protections(unsigned long address)
|
|
{
|
|
if(mprotect((void *) address, UM_THREAD_SIZE,
|
|
PROT_READ | PROT_WRITE | PROT_EXEC) < 0)
|
|
panic("protecting stack failed, errno = %d", errno);
|
|
}
|
|
|
|
int raw(int fd)
|
|
{
|
|
struct termios tt;
|
|
int err;
|
|
|
|
CATCH_EINTR(err = tcgetattr(fd, &tt));
|
|
if(err < 0)
|
|
return -errno;
|
|
|
|
cfmakeraw(&tt);
|
|
|
|
CATCH_EINTR(err = tcsetattr(fd, TCSADRAIN, &tt));
|
|
if(err < 0)
|
|
return -errno;
|
|
|
|
/* XXX tcsetattr could have applied only some changes
|
|
* (and cfmakeraw() is a set of changes) */
|
|
return 0;
|
|
}
|
|
|
|
void setup_machinename(char *machine_out)
|
|
{
|
|
struct utsname host;
|
|
|
|
uname(&host);
|
|
#ifdef UML_CONFIG_UML_X86
|
|
# ifndef UML_CONFIG_64BIT
|
|
if (!strcmp(host.machine, "x86_64")) {
|
|
strcpy(machine_out, "i686");
|
|
return;
|
|
}
|
|
# else
|
|
if (!strcmp(host.machine, "i686")) {
|
|
strcpy(machine_out, "x86_64");
|
|
return;
|
|
}
|
|
# endif
|
|
#endif
|
|
strcpy(machine_out, host.machine);
|
|
}
|
|
|
|
void setup_hostinfo(char *buf, int len)
|
|
{
|
|
struct utsname host;
|
|
|
|
uname(&host);
|
|
snprintf(buf, len, "%s %s %s %s %s", host.sysname, host.nodename,
|
|
host.release, host.version, host.machine);
|
|
}
|
|
|
|
int setjmp_wrapper(void (*proc)(void *, void *), ...)
|
|
{
|
|
va_list args;
|
|
jmp_buf buf;
|
|
int n;
|
|
|
|
n = UML_SETJMP(&buf);
|
|
if(n == 0){
|
|
va_start(args, proc);
|
|
(*proc)(&buf, &args);
|
|
}
|
|
va_end(args);
|
|
return n;
|
|
}
|
|
|
|
void os_dump_core(void)
|
|
{
|
|
int pid;
|
|
|
|
signal(SIGSEGV, SIG_DFL);
|
|
|
|
/*
|
|
* 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.
|
|
*/
|
|
|
|
while ((pid = waitpid(-1, NULL, WNOHANG | __WALL)) > 0)
|
|
os_kill_ptraced_process(pid, 0);
|
|
|
|
abort();
|
|
}
|