You can subscribe to this list here.
| 2002 |
Jan
|
Feb
|
Mar
|
Apr
|
May
|
Jun
|
Jul
|
Aug
|
Sep
(1) |
Oct
(122) |
Nov
(152) |
Dec
(69) |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 2003 |
Jan
(6) |
Feb
(25) |
Mar
(73) |
Apr
(82) |
May
(24) |
Jun
(25) |
Jul
(10) |
Aug
(11) |
Sep
(10) |
Oct
(54) |
Nov
(203) |
Dec
(182) |
| 2004 |
Jan
(307) |
Feb
(305) |
Mar
(430) |
Apr
(312) |
May
(187) |
Jun
(342) |
Jul
(487) |
Aug
(637) |
Sep
(336) |
Oct
(373) |
Nov
(441) |
Dec
(210) |
| 2005 |
Jan
(385) |
Feb
(480) |
Mar
(636) |
Apr
(544) |
May
(679) |
Jun
(625) |
Jul
(810) |
Aug
(838) |
Sep
(634) |
Oct
(521) |
Nov
(965) |
Dec
(543) |
| 2006 |
Jan
(494) |
Feb
(431) |
Mar
(546) |
Apr
(411) |
May
(406) |
Jun
(322) |
Jul
(256) |
Aug
(401) |
Sep
(345) |
Oct
(542) |
Nov
(308) |
Dec
(481) |
| 2007 |
Jan
(427) |
Feb
(326) |
Mar
(367) |
Apr
(255) |
May
(244) |
Jun
(204) |
Jul
(223) |
Aug
(231) |
Sep
(354) |
Oct
(374) |
Nov
(497) |
Dec
(362) |
| 2008 |
Jan
(322) |
Feb
(482) |
Mar
(658) |
Apr
(422) |
May
(476) |
Jun
(396) |
Jul
(455) |
Aug
(267) |
Sep
(280) |
Oct
(253) |
Nov
(232) |
Dec
(304) |
| 2009 |
Jan
(486) |
Feb
(470) |
Mar
(458) |
Apr
(423) |
May
(696) |
Jun
(461) |
Jul
(551) |
Aug
(575) |
Sep
(134) |
Oct
(110) |
Nov
(157) |
Dec
(102) |
| 2010 |
Jan
(226) |
Feb
(86) |
Mar
(147) |
Apr
(117) |
May
(107) |
Jun
(203) |
Jul
(193) |
Aug
(238) |
Sep
(300) |
Oct
(246) |
Nov
(23) |
Dec
(75) |
| 2011 |
Jan
(133) |
Feb
(195) |
Mar
(315) |
Apr
(200) |
May
(267) |
Jun
(293) |
Jul
(353) |
Aug
(237) |
Sep
(278) |
Oct
(611) |
Nov
(274) |
Dec
(260) |
| 2012 |
Jan
(303) |
Feb
(391) |
Mar
(417) |
Apr
(441) |
May
(488) |
Jun
(655) |
Jul
(590) |
Aug
(610) |
Sep
(526) |
Oct
(478) |
Nov
(359) |
Dec
(372) |
| 2013 |
Jan
(467) |
Feb
(226) |
Mar
(391) |
Apr
(281) |
May
(299) |
Jun
(252) |
Jul
(311) |
Aug
(352) |
Sep
(481) |
Oct
(571) |
Nov
(222) |
Dec
(231) |
| 2014 |
Jan
(185) |
Feb
(329) |
Mar
(245) |
Apr
(238) |
May
(281) |
Jun
(399) |
Jul
(382) |
Aug
(500) |
Sep
(579) |
Oct
(435) |
Nov
(487) |
Dec
(256) |
| 2015 |
Jan
(338) |
Feb
(357) |
Mar
(330) |
Apr
(294) |
May
(191) |
Jun
(108) |
Jul
(142) |
Aug
(261) |
Sep
(190) |
Oct
(54) |
Nov
(83) |
Dec
(22) |
| 2016 |
Jan
(49) |
Feb
(89) |
Mar
(33) |
Apr
(50) |
May
(27) |
Jun
(34) |
Jul
(53) |
Aug
(53) |
Sep
(98) |
Oct
(206) |
Nov
(93) |
Dec
(53) |
| 2017 |
Jan
(65) |
Feb
(82) |
Mar
(102) |
Apr
(86) |
May
(187) |
Jun
(67) |
Jul
(23) |
Aug
(93) |
Sep
(65) |
Oct
(45) |
Nov
(35) |
Dec
(17) |
| 2018 |
Jan
(26) |
Feb
(35) |
Mar
(38) |
Apr
(32) |
May
(8) |
Jun
(43) |
Jul
(27) |
Aug
(30) |
Sep
(43) |
Oct
(42) |
Nov
(38) |
Dec
(67) |
| 2019 |
Jan
(32) |
Feb
(37) |
Mar
(53) |
Apr
(64) |
May
(49) |
Jun
(18) |
Jul
(14) |
Aug
(53) |
Sep
(25) |
Oct
(30) |
Nov
(49) |
Dec
(31) |
| 2020 |
Jan
(87) |
Feb
(45) |
Mar
(37) |
Apr
(51) |
May
(99) |
Jun
(36) |
Jul
(11) |
Aug
(14) |
Sep
(20) |
Oct
(24) |
Nov
(40) |
Dec
(23) |
| 2021 |
Jan
(14) |
Feb
(53) |
Mar
(85) |
Apr
(15) |
May
(19) |
Jun
(3) |
Jul
(14) |
Aug
(1) |
Sep
(57) |
Oct
(73) |
Nov
(56) |
Dec
(22) |
| 2022 |
Jan
(3) |
Feb
(22) |
Mar
(6) |
Apr
(55) |
May
(46) |
Jun
(39) |
Jul
(15) |
Aug
(9) |
Sep
(11) |
Oct
(34) |
Nov
(20) |
Dec
(36) |
| 2023 |
Jan
(79) |
Feb
(41) |
Mar
(99) |
Apr
(169) |
May
(48) |
Jun
(16) |
Jul
(16) |
Aug
(57) |
Sep
(19) |
Oct
|
Nov
|
Dec
|
| S | M | T | W | T | F | S |
|---|---|---|---|---|---|---|
|
|
|
|
|
|
|
1
(4) |
|
2
(5) |
3
(3) |
4
(3) |
5
(7) |
6
(7) |
7
(9) |
8
(10) |
|
9
(12) |
10
(26) |
11
(9) |
12
(6) |
13
(7) |
14
(15) |
15
(25) |
|
16
(20) |
17
(32) |
18
(11) |
19
(19) |
20
(22) |
21
(6) |
22
(8) |
|
23
(16) |
24
(25) |
25
(11) |
26
(16) |
27
(12) |
28
(15) |
29
(11) |
|
30
(5) |
31
(8) |
|
|
|
|
|
|
From: Nicholas N. <nj...@ca...> - 2005-01-28 20:25:41
|
On Fri, 28 Jan 2005, Robert Walsh wrote:
>>> I'm of the opinion that we should be trying to make our autoconf stuff
>>> as simple as possible to avoid situations like this. Maybe by choosing
>>> a baseline version (perhaps the version that ships with the earliest
>>> distribution release that we support) and not using any macros that
>>> don't exist in that version? Or shipping any extra macros above this
>>> that we need.
>>
>> This sounds good to me.
>
> This was the bit where I was hoping someone would just in and say "I'll
> do it! I know everything about autoconf!" ;-) I guess I'll take a look
> over the weekend and see what I can see...
Is there much to do? I guess:
- decide on an acceptable maximal version
- remove the REQUIRE_VERSION(2.59) macro (or whatever it's called)
- remove any macros that don't work in the chosen maximal version
(was it AS_HELP_STRING? I think it just concatenates the program name
to a string, so replace eg:
AS_HELP_STRING("foo")
with
"valgrind: foo"
or similar)
From then on it's a matter of policy (ie. don't use new macros), rather
than coding, no?
N
|
|
From: Robert W. <rj...@du...> - 2005-01-28 20:09:23
|
> > I'm of the opinion that we should be trying to make our autoconf stuff > > as simple as possible to avoid situations like this. Maybe by choosing > > a baseline version (perhaps the version that ships with the earliest > > distribution release that we support) and not using any macros that > > don't exist in that version? Or shipping any extra macros above this > > that we need. > > This sounds good to me. This was the bit where I was hoping someone would just in and say "I'll do it! I know everything about autoconf!" ;-) I guess I'll take a look over the weekend and see what I can see... Regards, Robert. |
|
From: Nicholas N. <nj...@ca...> - 2005-01-28 19:21:56
|
On Wed, 26 Jan 2005, Robert Walsh wrote: > I just tried building Valgrind for the folks here at work on our FC1 > machine. The build fell over because FC1 doesn't ship with autoconf > 2.59, which Valgrind apparently needs. I can't install that version of > autoconf very easily on this machine because it's also used as one of > our product build machines and we don't want to change the system > software. > > BTW: this appears to be a relatively new requirement - I built a version > of FC1 back in December without any problems. > > I'm of the opinion that we should be trying to make our autoconf stuff > as simple as possible to avoid situations like this. Maybe by choosing > a baseline version (perhaps the version that ships with the earliest > distribution release that we support) and not using any macros that > don't exist in that version? Or shipping any extra macros above this > that we need. This sounds good to me. N |
|
From: Nicholas N. <nj...@ca...> - 2005-01-28 19:16:41
|
On Fri, 28 Jan 2005, Julian Seward wrote: > And vex doesn't do translation chaining ... instead it chases across > bb boundaries (possibly even conditional branches, am still experimenting) Will that make function wrapping more difficult? N |
|
From: Julian S. <js...@ac...> - 2005-01-28 10:52:31
|
I also arrived at the same conclusions a while back.
> But it seems to me that the baseBlock is fairly redundant.
In the new jit ("Vex"), the baseblock is gone, and guest state
is just a field in each thread state, which ebp is made to point
at when running that thread.
> This would not only make getting at
> the VCPU state much simpler and more consistent, it removes all the code
> responsible for shuffling the state around, and all the code which sets
> up the baseBlock in the first place.
Yup. I nuked lots of code.
Not only that, it makes V much faster in some cases where there was
previously a lot of copying stuff to/from the baseblock -- bear in mind
the SSEified cpu state == 512 bytes, so this had got expensive.
> But the baseBlock is configured differently for different Tools
> True, but but apart from pointers to helper functions (see
> below), this is just a has shadow regs/doesn't have shadow regs
> switch. The ThreadState always contains shadow state either
> way.
Vex imposes this requirement; doesn't seem a big deal to me.
> But the baseBlock has all the pointers to helpers.
> Yes; as I understand it, they're there for two reasons:
> 1. they let us generate more compact code, because we can
> generate short-form call instructions, and
> 2. the calls don't need relocating when the code is copied
> into the translation cache
>
> But it seems to me that these indirect calls are not good for
> performance; the CPU would prefer to see a simple predictable
> direct call. And if the offset is >128 it ends up generating a
> longer sequence anyway.
Vex disallows pointers to helpers; the vex-generated code has to
be self-contained. That makes it slightly more difficult on x86 to
generate a position-independent call to an absolute address, but overall
since vex is generating faster code anyway, I don't care.
And vex doesn't do translation chaining ... instead it chases across
bb boundaries (possibly even conditional branches, am still experimenting)
which (1) reduces the number of transitions significantly, and (2)
gives a benefit beyond merely removing the branch cost, namely allowing
IR level optimisation to propagate constants and then fold redundant
computations/specialise calls to helper functions between the two basic
blocks.
Additionally vex unrolls single-BB loops during IR optimisation up to 8 times,
which also helps.
J
|
|
From: Jeremy F. <je...@go...> - 2005-01-28 09:09:34
|
CVS commit by fitzhardinge:
Expand thread-exits to test for the case where master_tid is blocked in a syscall.
M +68 -5 thread-exits.c 1.3
M +1 -0 thread-exits.stderr.exp 1.2
M +16 -1 thread-exits.stdout.exp 1.2
--- valgrind/none/tests/thread-exits.c #1.2:1.3
@@ -14,4 +14,11 @@
like the program crashed.
+ The extra complication in this test is making sure that the
+ unwanted signals are discarded while the main thread is blocked in
+ a syscall. So, to check this, main creates a new process, which
+ attempts to grow the stack once all the threads have been created
+ and exited. main() itself is blocked waiting for the child
+ process.
+
Oh, and this test also makes sure that thread resources are cleaned
up properly.
@@ -21,4 +28,13 @@
#include <string.h>
#include <stdlib.h>
+#include <unistd.h>
+#include <signal.h>
+#include <sys/wait.h>
+
+static int grower;
+
+static void handler(int sig)
+{
+}
static void *thr(void *v)
@@ -39,13 +55,19 @@ static void grow(int depth)
}
-int main()
+static void *maker(void *v)
{
int i;
+ sleep(1);
+
/* Create lots of threads */
+ printf("creating threads...\n");
for(i = 0; i < 1300; i++) {
pthread_t t;
int ret;
+ if (i % 100 == 0)
+ printf("%d...\n", i);
+
ret = pthread_create(&t, NULL, thr, NULL);
if (ret) {
@@ -61,9 +83,50 @@ int main()
}
- /* Grow the stack */
+ kill(grower, SIGUSR1);
+
+ return NULL;
+}
+
+int main()
+{
+ pthread_t pth;
+ sigset_t mask;
+ int status;
+
+ sigemptyset(&mask);
+ sigaddset(&mask, SIGCHLD);
+ sigprocmask(SIG_BLOCK, &mask, NULL);
+
+ struct sigaction sa;
+ sa.sa_handler = handler;
+ sa.sa_flags = 0;
+ sigfillset(&sa.sa_mask);
+ sigaction(SIGUSR1, &sa, NULL);
+
+ grower = fork();
+
+ if (grower == -1) {
+ perror("fork");
+ exit(1);
+ }
+
+ if (grower == 0) {
+ pause(); /* child - wait for SIGUSR1 */
grow(10);
+ printf("stack grew OK\n");
+ exit(0);
+ }
- /* If we didn't die with SIGSEGV in grow(), it is a pass */
- printf("PASS\n");
+ pthread_create(&pth, NULL, maker, NULL);
+
+ /* wait for child */
+ if (waitpid(grower, &status, 0) != grower)
+ printf("FAILED\n");
+ else if (WIFEXITED(status) && WEXITSTATUS(status) == 0)
+ printf("PASS: child OK\n");
+ else
+ printf("FAILED: exit status=%d\n", status);
+
+ pthread_join(pth, NULL);
return 0;
--- valgrind/none/tests/thread-exits.stderr.exp #1.1:1.2
@@ -1,2 +1,3 @@
+
--- valgrind/none/tests/thread-exits.stdout.exp #1.1:1.2
@@ -1 +1,16 @@
-PASS
+stack grew OK
+creating threads...
+0...
+100...
+200...
+300...
+400...
+500...
+600...
+700...
+800...
+900...
+1000...
+1100...
+1200...
+PASS: child OK
|
|
From: Jeremy F. <je...@go...> - 2005-01-28 09:08:57
|
CVS commit by fitzhardinge:
Set SIGVGCHLD to SIG_IGN, except for when we actually care about it.
This prevents unwanted signals from building up and clogging our
pores.
M +8 -10 core.h 1.72
M +4 -4 vg_scheduler.c 1.216
M +93 -42 vg_signals.c 1.116
M +2 -4 vg_syscalls.c 1.238
M +10 -29 linux/core_os.c 1.7
M +8 -8 x86-linux/syscall.S 1.4
M +16 -0 x86-linux/syscalls.c 1.19
--- valgrind/coregrind/vg_signals.c #1.115:1.116
@@ -93,10 +93,7 @@ static void vg_sync_signalhandler ( Int
static void vg_async_signalhandler ( Int sigNo, vki_siginfo_t *info, struct vki_ucontext * );
static void sigvgkill_handler ( Int sigNo, vki_siginfo_t *info, struct vki_ucontext * );
-static void sigvgchld_handler ( Int sigNo, vki_siginfo_t *info, struct vki_ucontext * );
static const Char *signame(Int sigNo);
-vki_sigset_t VG_(blocked_mask);
-
/* Maximum usable signal. */
Int VG_(max_signal) = _VKI_NSIG;
@@ -257,5 +254,5 @@ void calculate_SKSS_from_SCSS ( SKSS* ds
skss_handler = sigvgkill_handler;
else if (sig == VKI_SIGVGCHLD)
- skss_handler = sigvgchld_handler;
+ skss_handler = VKI_SIG_IGN; /* we only poll for it */
else {
if (scss_handler == VKI_SIG_IGN)
@@ -477,5 +474,5 @@ Int VG_(do_sys_sigaction) ( Int signo,
/* don't let them use our signals */
- if ( (signo == VKI_SIGVGCHLD || signo == VKI_SIGVGKILL)
+ if ( (signo > VKI_SIGVGRTUSERMAX)
&& new_act
&& !(new_act->ksa_handler == VKI_SIG_DFL || new_act->ksa_handler == VKI_SIG_IGN) )
@@ -565,8 +562,61 @@ void do_sigprocmask_bitops ( Int vki_how
}
+static void sigvgchld_handler(Int sig)
+{
+ VG_(printf)("got a sigvgchld?\n");
+}
+
+/*
+ Wait until some predicate about threadstates is satisfied.
+
+ This uses SIGVGCHLD as a notification that it is now worth
+ re-evaluating the predicate.
+ */
+void VG_(wait_for_threadstate)(Bool (*pred)(void *), void *arg)
+{
+ vki_sigset_t set, saved;
+ struct vki_sigaction sa, old_sa;
+
+ /*
+ SIGVGCHLD is set to be ignored, and is unblocked by default.
+ This means all such signals are simply discarded.
+
+ In this loop, we actually block it, and then poll for it with
+ sigtimedwait.
+ */
+ VG_(sigemptyset)(&set);
+ VG_(sigaddset)(&set, VKI_SIGVGCHLD);
+
+ VG_(set_sleeping)(VG_(master_tid), VgTs_Yielding);
+ VG_(sigprocmask)(VKI_SIG_BLOCK, &set, &saved);
+
+ /* It shouldn't be necessary to set a handler, since the signal is
+ always blocked, but it seems to be necessary to convice the
+ kernel not to just toss the signal... */
+ sa.ksa_handler = sigvgchld_handler;
+ sa.sa_flags = 0;
+ VG_(sigfillset)(&sa.sa_mask);
+ VG_(sigaction)(VKI_SIGVGCHLD, &sa, &old_sa);
+
+ vg_assert(old_sa.ksa_handler == VKI_SIG_IGN);
+
+ while(!(*pred)(arg)) {
+ struct vki_siginfo si;
+ Int ret = VG_(sigtimedwait)(&set, &si, NULL);
+
+ if (ret > 0 && VG_(clo_trace_signals))
+ VG_(message)(Vg_DebugMsg, "Got %d (code=%d) from tid lwp %d",
+ ret, si.si_code, si._sifields._kill._pid);
+ }
+
+ VG_(sigaction)(VKI_SIGVGCHLD, &old_sa, NULL);
+ VG_(sigprocmask)(VKI_SIG_SETMASK, &saved, NULL);
+ VG_(set_running)(VG_(master_tid));
+}
+
/* Add and remove signals from mask so that we end up telling the
kernel the state we actually want rather than what the client
wants. */
-void VG_(sanitize_client_sigmask)(vki_sigset_t *mask)
+void VG_(sanitize_client_sigmask)(ThreadId tid, vki_sigset_t *mask)
{
VG_(sigdelset)(mask, VKI_SIGKILL);
@@ -574,5 +624,13 @@ void VG_(sanitize_client_sigmask)(vki_si
VG_(sigdelset)(mask, VKI_SIGVGKILL); /* never block */
- VG_(sigaddset)(mask, VKI_SIGVGCHLD); /* always block */
+
+ /* SIGVGCHLD is used by threads to indicate their state changes to
+ the master thread. Mostly it doesn't care, so it leaves the
+ signal ignored and unblocked. Everyone else should have it
+ blocked, so there's at most 1 thread with it unblocked. */
+ if (tid == VG_(master_tid))
+ VG_(sigdelset)(mask, VKI_SIGVGCHLD);
+ else
+ VG_(sigaddset)(mask, VKI_SIGVGCHLD);
}
@@ -816,7 +874,7 @@ void VG_(kill_self)(Int sigNo)
VG_(sigaction)(sigNo, &sa, &origsa);
- VG_(sigfillset)(&mask);
- VG_(sigdelset)(&mask, sigNo);
- VG_(sigprocmask)(VKI_SIG_SETMASK, &mask, &origmask);
+ VG_(sigemptyset)(&mask);
+ VG_(sigaddset)(&mask, sigNo);
+ VG_(sigprocmask)(VKI_SIG_UNBLOCK, &mask, &origmask);
VG_(tkill)(VG_(getpid)(), sigNo);
@@ -1808,21 +1866,4 @@ static void sigvgkill_handler(int signo,
}
-/* This handler should never be called */
-static void sigvgchld_handler(int signo, vki_siginfo_t *si, struct vki_ucontext *uc)
-{
- /* Just ignore it - it seems that LinuxThread signals can get
- delivered even if they're blocked... */
- vg_assert(signo == VKI_SIGVGCHLD);
-
- if (VG_(clo_trace_signals)) {
- vki_sigset_t mask;
- VG_(sigprocmask)(0, NULL, &mask);
- VG_(message)(Vg_DebugMsg, "SIGVGCHLD called in tid %d: mask=%08x%08x (blocked=%d)\n",
- VG_(gettid)(), mask.sig[1], mask.sig[0], VG_(sigismember)(&mask, signo));
- }
-
- return;
-}
-
static __attribute((unused))
void pp_vg_ksigaction ( struct vki_sigaction* sa )
@@ -1865,11 +1906,4 @@ void VG_(poll_signals)(ThreadId tid)
vki_sigset_t saved_mask;
- /* First, mop up any pending SIGVGCHLDs; we don't care about
- them here. */
- VG_(sigemptyset)(&pollset);
- VG_(sigaddset)(&pollset, VKI_SIGVGCHLD);
- while(VG_(sigtimedwait)(&pollset, NULL, &zero) == VKI_SIGVGCHLD)
- ;
-
/* look for all the signals this thread isn't blocking */
for(i = 0; i < _VKI_NSIG_WORDS; i++)
@@ -1909,4 +1943,29 @@ void VG_(poll_signals)(ThreadId tid)
}
+/* Set the standard set of blocked signals, used wheneever we're not
+ running a client syscall. */
+void VG_(block_signals)(ThreadId tid)
+{
+ vki_sigset_t mask;
+
+ VG_(sigfillset)(&mask);
+
+ /* Don't block these because they're synchronous */
+ VG_(sigdelset)(&mask, VKI_SIGSEGV);
+ VG_(sigdelset)(&mask, VKI_SIGBUS);
+ VG_(sigdelset)(&mask, VKI_SIGFPE);
+ VG_(sigdelset)(&mask, VKI_SIGILL);
+
+ /* Can't block these anyway */
+ VG_(sigdelset)(&mask, VKI_SIGSTOP);
+ VG_(sigdelset)(&mask, VKI_SIGKILL);
+
+ /* Master doesn't block this */
+ if (tid == VG_(master_tid))
+ VG_(sigdelset)(&mask, VKI_SIGVGCHLD);
+
+ VG_(sigprocmask)(VKI_SIG_SETMASK, &mask, NULL);
+}
+
/* At startup, copy the process' real signal state to the SCSS.
Whilst doing this, block all real signals. Then calculate SKSS and
@@ -1925,12 +1984,4 @@ void VG_(sigstartup_actions) ( void )
VG_(block_all_host_signals)( &saved_procmask );
- VG_(sigfillset)(&VG_(blocked_mask));
- VG_(sigdelset)(&VG_(blocked_mask), VKI_SIGSEGV);
- VG_(sigdelset)(&VG_(blocked_mask), VKI_SIGBUS);
- VG_(sigdelset)(&VG_(blocked_mask), VKI_SIGFPE);
- VG_(sigdelset)(&VG_(blocked_mask), VKI_SIGILL);
- VG_(sigdelset)(&VG_(blocked_mask), VKI_SIGSTOP);
- VG_(sigdelset)(&VG_(blocked_mask), VKI_SIGKILL);
-
/* Copy per-signal settings to SCSS. */
for (i = 1; i <= _VKI_NSIG; i++) {
--- valgrind/coregrind/core.h #1.71:1.72
@@ -839,10 +839,7 @@ extern Bool VG_(my_fault);
------------------------------------------------------------------ */
-/* This is a signal mask with almost everything blocked. The
- exceptions are signals which could be synchronous (SIGILL, SIGBUS,
- SIGSEGV - if we get one of those when they're blocked, then the
- whole process could just die without warning), and the unblockable
- ones (SIGKILL and SIGSTOP). */
-extern vki_sigset_t VG_(blocked_mask);
+/* Set the standard set of blocked signals, used wheneever we're not
+ running a client syscall. */
+extern void VG_(block_signals)(ThreadId tid);
/* Highest signal the kernel will let us use */
@@ -901,5 +898,8 @@ extern void VG_(set_default_handler)(Int
/* Adjust a client's signal mask to match our internal requirements */
-extern void VG_(sanitize_client_sigmask)(vki_sigset_t *mask);
+extern void VG_(sanitize_client_sigmask)(ThreadId tid, vki_sigset_t *mask);
+
+/* Wait until a thread-related predicate is true */
+extern void VG_(wait_for_threadstate)(Bool (*pred)(void *), void *arg);
/* ---------------------------------------------------------------------
@@ -1847,7 +1847,5 @@ extern const Addr vga_sys_before, vga_sy
*/
extern void VGA_(client_syscall)(Int syscallno, arch_thread_t *regs,
- const vki_sigset_t *syscall_mask,
- const vki_sigset_t *restore_mask,
- Int nsigwords);
+ const vki_sigset_t *syscall_mask);
/*
--- valgrind/coregrind/vg_syscalls.c #1.237:1.238
@@ -6034,10 +6034,8 @@ void VG_(client_syscall) ( ThreadId tid
mask = tst->sig_mask;
- VG_(sanitize_client_sigmask)(&mask);
+ VG_(sanitize_client_sigmask)(tid, &mask);
VG_(set_sleeping)(tid, VgTs_WaitSys);
- VGA_(client_syscall)(syscallno, &tst->arch, &mask,
- &VG_(blocked_mask),
- _VKI_NSIG_WORDS * sizeof(UWord));
+ VGA_(client_syscall)(syscallno, &tst->arch, &mask);
/* VGA_(client_syscall) may not return if the syscall was
interrupted by a signal. In that case, flow of control
--- valgrind/coregrind/vg_scheduler.c #1.215:1.216
@@ -538,5 +538,5 @@ UInt run_thread_for_a_while ( ThreadId t
vg_assert(trc == 0);
trc = VG_TRC_FAULT_SIGNAL;
- VG_(sigprocmask)(VKI_SIG_SETMASK, &VG_(blocked_mask), NULL);
+ VG_(block_signals)(tid);
}
@@ -705,5 +705,5 @@ static void handle_syscall(ThreadId tid)
if (jumped) {
- VG_(sigprocmask)(VKI_SIG_SETMASK, &VG_(blocked_mask), NULL);
+ VG_(block_signals)(tid);
VG_(poll_signals)(tid);
}
@@ -726,5 +726,5 @@ VgSchedReturnCode VG_(scheduler) ( Threa
/* set the proper running signal mask */
- VG_(sigprocmask)(VKI_SIG_SETMASK, &VG_(blocked_mask), NULL);
+ VG_(block_signals)(tid);
vg_assert(VG_(is_running_thread)(tid));
@@ -809,5 +809,5 @@ VgSchedReturnCode VG_(scheduler) ( Threa
before (ie, there's no window that unsafe signals could
sneak in). */
- VG_(sigprocmask)(VKI_SIG_SETMASK, &VG_(blocked_mask), NULL);
+ VG_(block_signals)(tid);
break;
--- valgrind/coregrind/linux/core_os.c #1.6:1.7
@@ -79,34 +79,15 @@ void VGA_(terminate)(ThreadId tid, VgSch
/* wait until all other threads are dead */
+static Bool alldead(void *v)
+{
+ /* master_tid must be alive... */
+ Int c = VG_(count_living_threads)();
+ //VG_(printf)("alldead: count=%d\n", c);
+ return c <= 1;
+}
void VGA_(reap_threads)(ThreadId self)
{
- vki_sigset_t mask;
- vki_sigset_t sigchld;
- vki_siginfo_t si;
-
- /* block everything */
- VG_(sigfillset)(&mask);
- VG_(sigprocmask)(VKI_SIG_SETMASK, &mask, NULL);
-
- /* wait for SIGVGCHLD to show up */
- VG_(sigemptyset)(&sigchld);
- VG_(sigaddset)(&sigchld, VKI_SIGVGCHLD);
-
- vg_assert(VG_(threads)[self].status == VgTs_Runnable);
-
- while(VG_(count_living_threads)() > 1) {
- Int sig;
-
- VG_(set_sleeping)(self, VgTs_WaitSys); /* let other threads run a bit */
- sig = VG_(sigtimedwait)(&sigchld, &si, 0);
- VG_(set_running)(self);
-
- if (sig == -VKI_EINTR)
- continue;
-
- vg_assert(sig == VKI_SIGVGCHLD);
- vg_assert(si.si_signo == VKI_SIGVGCHLD);
- }
- vg_assert(VG_(count_living_threads)() == 1);
+ vg_assert(self == VG_(master_tid));
+ VG_(wait_for_threadstate)(alldead, NULL);
}
@@ -142,5 +123,5 @@ void VGA_(final_tidyup)(ThreadId tid)
/* block all blockable signals... */
- VG_(threads)[tid].sig_mask = VG_(blocked_mask);
+ VG_(sigprocmask)(VKI_SIG_BLOCK, NULL, &VG_(threads)[tid].sig_mask);
/* and restore handlers to default */
--- valgrind/coregrind/x86-linux/syscall.S #1.3:1.4
@@ -149,9 +149,9 @@
Prototype:
- Int VGA_(client_syscall)(Int syscallno, // 0
- arch_thread_t *regs, // 4
- const vki_sigset_t *sysmask, // 8
- const vki_sigset_t *postmask, // 12
- Int nsigwords) // 16
+ Int VGA_(_client_syscall)(Int syscallno, // 0
+ arch_thread_t *regs, // 4
+ const vki_sigset_t *sysmask, // 8
+ vki_sigset_t *postmask, // 12
+ Int nsigwords) // 16
*/
@@ -160,6 +160,6 @@
#define VKI_SIG_SETMASK 2
-.globl VGA_(client_syscall)
-VGA_(client_syscall):
+.globl VGA_(_client_syscall)
+VGA_(_client_syscall):
/* save callee-saved regs */
push %esi
@@ -177,5 +177,5 @@
movl $VKI_SIG_SETMASK, %ebx
movl 8+FSZ(%esp), %ecx
- xorl %edx, %edx
+ movl 12+FSZ(%esp), %edx
movl 16+FSZ(%esp), %esi
int $0x80
--- valgrind/coregrind/x86-linux/syscalls.c #1.18:1.19
@@ -148,4 +148,16 @@ void VGA_(interrupted_syscall)(ThreadId
}
+extern void VGA_(_client_syscall)(Int syscallno, arch_thread_t *regs,
+ const vki_sigset_t *syscall_mask,
+ const vki_sigset_t *restore_mask,
+ Int nsigwords);
+
+void VGA_(client_syscall)(Int syscallno, arch_thread_t *regs,
+ const vki_sigset_t *syscall_mask)
+{
+ vki_sigset_t saved;
+ VGA_(_client_syscall)(syscallno, regs, syscall_mask, &saved, _VKI_NSIG_WORDS * sizeof(UWord));
+}
+
/*
@@ -234,4 +246,8 @@ static Int start_thread(void *arg)
/* Poke the reaper */
+ if (VG_(clo_trace_signals))
+ VG_(message)(Vg_DebugMsg, "Sending SIGVGCHLD to master tid=%d lwp=%d",
+ VG_(master_tid), VG_(threads)[VG_(master_tid)].os_state.lwpid);
+
VG_(tkill)(VG_(threads)[VG_(master_tid)].os_state.lwpid, VKI_SIGVGCHLD);
|
|
From: Jeremy F. <je...@go...> - 2005-01-28 09:08:20
|
CVS commit by fitzhardinge:
Honour SIG_IGN. Previously Valgrind was delivering ignored signals as
SIG_DFL. Surprising this doesn't break more stuff...
M +33 -27 vg_signals.c 1.115
--- valgrind/coregrind/vg_signals.c #1.114:1.115
@@ -352,5 +352,5 @@ static void handle_SCSS_change ( Bool fo
VG_(sigdelset)( &ksa.sa_mask, VKI_SIGSTOP );
- if (VG_(clo_trace_signals))
+ if (VG_(clo_trace_signals) && VG_(clo_verbosity) > 2)
VG_(message)(Vg_DebugMsg,
"setting ksig %d to: hdlr 0x%x, flags 0x%x, "
@@ -1217,6 +1217,6 @@ static void vg_default_action(const vki_
if (VG_(clo_trace_signals))
- VG_(message)(Vg_DebugMsg, "delivering %d (code %d) to default handler %s%s",
- sigNo, info->si_code, terminate ? "terminate" : "", core ? "+core" : "");
+ VG_(message)(Vg_DebugMsg, "delivering %d (code %d) to default handler; action: %s%s",
+ sigNo, info->si_code, terminate ? "terminate" : "ignore", core ? "+core" : "");
if (!terminate)
@@ -1379,8 +1379,4 @@ void VG_(synth_fault)(ThreadId tid)
cause the thread to enter the signal handler.
- Note that this doesn't check the signal mask either. The
- assumption is that whoever calls this has already determined that
- the thread must get the signal.
-
This updates the thread state, but it does not set it to be
Runnable.
@@ -1490,5 +1486,9 @@ void queue_signal(ThreadId tid, const vk
/* Add signal to the queue. If the queue gets overrun, then old
- queued signals may get lost. */
+ queued signals may get lost.
+
+ XXX We should also keep a sigset of pending signals, so that at
+ least a non-siginfo signal gets deliviered.
+ */
if (sq->sigs[sq->next].si_signo != 0)
VG_(message)(Vg_UserMsg, "Signal %d being dropped from thread %d's queue\n",
@@ -1566,9 +1566,9 @@ void vg_async_signalhandler ( Int sigNo,
/* Set up the thread's state to deliver a signal */
+ if (!VG_(is_sig_ign)(info->si_signo))
VG_(deliver_signal)(tid, info);
/* longjmp back to the thread's main loop to start executing the
- handler.
- */
+ handler. */
VG_(resume_scheduler)(tid);
@@ -1876,29 +1876,35 @@ void VG_(poll_signals)(ThreadId tid)
pollset.sig[i] = ~tst->sig_mask.sig[i];
- VG_(sigdelset)(&pollset, VKI_SIGVGCHLD); /* never look for this */
+ VG_(sigdelset)(&pollset, VKI_SIGVGCHLD); /* already dealt with */
//VG_(printf)("tid %d pollset=%08x%08x\n", tid, pollset.sig[1], pollset.sig[0]);
- VG_(block_all_host_signals)(&saved_mask);
+ VG_(block_all_host_signals)(&saved_mask); // protect signal queue
/* First look for any queued pending signals */
- sip = next_queued(0, &pollset); /* process-wide */
- if (sip == NULL)
sip = next_queued(tid, &pollset); /* this thread */
- if (sip != NULL) {
- VG_(deliver_signal)(tid, sip);
- sip->si_signo = 0;
- VG_(restore_all_host_signals)(&saved_mask);
- return;
- }
- VG_(restore_all_host_signals)(&saved_mask);
- /* Grab a single pending signal for this thread, and deliver it to
- the thread */
- if (VG_(sigtimedwait)(&pollset, &si, &zero) > 0) {
+ if (sip == NULL)
+ sip = next_queued(0, &pollset); /* process-wide */
+
+ /* If there was nothing queued, ask the kernel for a pending signal */
+ if (sip == NULL && VG_(sigtimedwait)(&pollset, &si, &zero) > 0) {
if (VG_(clo_trace_signals))
VG_(message)(Vg_DebugMsg, "poll_signals: got signal %d for thread %d", si.si_signo, tid);
- VG_(deliver_signal)(tid, &si);
+ sip = &si;
}
+
+ if (sip != NULL) {
+ /* OK, something to do; deliver it */
+ if (!VG_(is_sig_ign)(sip->si_signo))
+ VG_(deliver_signal)(tid, sip);
+ else if (VG_(clo_trace_signals))
+ VG_(message)(Vg_DebugMsg, " signal %d ignored", sip->si_signo);
+
+ sip->si_signo = 0; /* remove from signal queue, if that's
+ where it came from */
+ }
+
+ VG_(restore_all_host_signals)(&saved_mask);
}
@@ -1956,5 +1962,5 @@ void VG_(sigstartup_actions) ( void )
VG_(max_signal) = i;
- if (VG_(clo_trace_signals))
+ if (VG_(clo_trace_signals) && VG_(clo_verbosity) > 2)
VG_(printf)("snaffling handler 0x%x for signal %d\n",
(Addr)(sa.ksa_handler), i );
|
|
From: <js...@ac...> - 2005-01-28 06:04:14
|
Nightly build on phoenix ( SuSE 9.1 ) started at 2005-01-28 03:50:00 GMT Checking out source tree ... done Configuring ... done Building ... done Running regression tests ... done Last 20 lines of log.verbose follow -- Finished tests in none/tests ---------------------------------------- == 194 tests, 15 stderr failures, 0 stdout failures ================= corecheck/tests/as_mmap (stderr) corecheck/tests/fdleak_fcntl (stderr) helgrind/tests/allok (stderr) helgrind/tests/deadlock (stderr) helgrind/tests/inherit (stderr) helgrind/tests/race (stderr) helgrind/tests/race2 (stderr) helgrind/tests/readshared (stderr) massif/tests/toobig-allocs (stderr) massif/tests/true_html (stderr) massif/tests/true_text (stderr) memcheck/tests/pth_once (stderr) memcheck/tests/scalar (stderr) memcheck/tests/threadederrno (stderr) memcheck/tests/writev (stderr) make: *** [regtest] Error 1 |
|
From: Tom H. <to...@co...> - 2005-01-28 03:24:03
|
Nightly build on dunsmere ( Fedora Core 3 ) started at 2005-01-28 03:20:03 GMT Checking out source tree ... done Configuring ... done Building ... done Running regression tests ... done Last 20 lines of log.verbose follow seg_override: valgrind --num-callers=4 ./seg_override -- Finished tests in none/tests/x86 ------------------------------------ yield: valgrind --num-callers=4 ./yield -- Finished tests in none/tests ---------------------------------------- == 201 tests, 12 stderr failures, 0 stdout failures ================= helgrind/tests/allok (stderr) helgrind/tests/deadlock (stderr) helgrind/tests/inherit (stderr) helgrind/tests/race (stderr) helgrind/tests/race2 (stderr) helgrind/tests/readshared (stderr) massif/tests/toobig-allocs (stderr) massif/tests/true_html (stderr) massif/tests/true_text (stderr) memcheck/tests/scalar (stderr) memcheck/tests/scalar_supp (stderr) memcheck/tests/vgtest_ume (stderr) make: *** [regtest] Error 1 |
|
From: Tom H. <th...@cy...> - 2005-01-28 03:21:00
|
Nightly build on audi ( Red Hat 9 ) started at 2005-01-28 03:15:01 GMT Checking out source tree ... done Configuring ... done Building ... done Running regression tests ... done Last 20 lines of log.verbose follow helgrind/tests/allok (stderr) helgrind/tests/deadlock (stderr) helgrind/tests/inherit (stderr) helgrind/tests/race (stderr) helgrind/tests/race2 (stderr) helgrind/tests/readshared (stderr) massif/tests/toobig-allocs (stderr) massif/tests/true_html (stderr) massif/tests/true_text (stderr) memcheck/tests/badpoll (stderr) memcheck/tests/buflen_check (stderr) memcheck/tests/execve (stderr) memcheck/tests/execve2 (stderr) memcheck/tests/scalar (stderr) memcheck/tests/scalar_exit_group (stderr) memcheck/tests/scalar_supp (stderr) memcheck/tests/writev (stderr) none/tests/tls (stdout) make: *** [regtest] Error 1 |
|
From: Tom H. <th...@cy...> - 2005-01-28 03:15:16
|
Nightly build on ginetta ( Red Hat 8.0 ) started at 2005-01-28 03:10:05 GMT Checking out source tree ... done Configuring ... done Building ... done Running regression tests ... done Last 20 lines of log.verbose follow seg_override: valgrind --num-callers=4 ./seg_override -- Finished tests in none/tests/x86 ------------------------------------ yield: valgrind --num-callers=4 ./yield -- Finished tests in none/tests ---------------------------------------- == 199 tests, 12 stderr failures, 0 stdout failures ================= helgrind/tests/allok (stderr) helgrind/tests/deadlock (stderr) helgrind/tests/inherit (stderr) helgrind/tests/race (stderr) helgrind/tests/race2 (stderr) helgrind/tests/readshared (stderr) massif/tests/toobig-allocs (stderr) massif/tests/true_html (stderr) massif/tests/true_text (stderr) memcheck/tests/pth_once (stderr) memcheck/tests/scalar (stderr) memcheck/tests/threadederrno (stderr) make: *** [regtest] Error 1 |
|
From: Tom H. <th...@cy...> - 2005-01-28 03:08:49
|
Nightly build on alvis ( Red Hat 7.3 ) started at 2005-01-28 03:05:01 GMT Checking out source tree ... done Configuring ... done Building ... done Running regression tests ... done Last 20 lines of log.verbose follow yield: valgrind --num-callers=4 ./yield -- Finished tests in none/tests ---------------------------------------- == 199 tests, 14 stderr failures, 0 stdout failures ================= helgrind/tests/allok (stderr) helgrind/tests/deadlock (stderr) helgrind/tests/inherit (stderr) helgrind/tests/race (stderr) helgrind/tests/race2 (stderr) helgrind/tests/readshared (stderr) massif/tests/toobig-allocs (stderr) massif/tests/true_html (stderr) massif/tests/true_text (stderr) memcheck/tests/post-syscall (stderr) memcheck/tests/pth_once (stderr) memcheck/tests/scalar (stderr) memcheck/tests/threadederrno (stderr) memcheck/tests/vgtest_ume (stderr) make: *** [regtest] Error 1 |
|
From: Tom H. <th...@cy...> - 2005-01-28 03:04:51
|
Nightly build on standard ( Red Hat 7.2 ) started at 2005-01-28 03:00:02 GMT Checking out source tree ... done Configuring ... done Building ... done Running regression tests ... done Last 20 lines of log.verbose follow -- Finished tests in none/tests/x86 ------------------------------------ yield: valgrind --num-callers=4 ./yield -- Finished tests in none/tests ---------------------------------------- == 199 tests, 13 stderr failures, 0 stdout failures ================= helgrind/tests/allok (stderr) helgrind/tests/deadlock (stderr) helgrind/tests/inherit (stderr) helgrind/tests/race (stderr) helgrind/tests/race2 (stderr) helgrind/tests/readshared (stderr) massif/tests/toobig-allocs (stderr) massif/tests/true_html (stderr) massif/tests/true_text (stderr) memcheck/tests/pth_once (stderr) memcheck/tests/scalar (stderr) memcheck/tests/threadederrno (stderr) memcheck/tests/vgtest_ume (stderr) make: *** [regtest] Error 1 |