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
(17) |
2
(21) |
3
(17) |
4
(28) |
5
(21) |
6
(11) |
|
7
(13) |
8
(21) |
9
(21) |
10
(9) |
11
(11) |
12
(15) |
13
(23) |
|
14
(15) |
15
(22) |
16
(28) |
17
(12) |
18
(15) |
19
(8) |
20
(7) |
|
21
(8) |
22
(12) |
23
(13) |
24
(7) |
25
(7) |
26
(3) |
27
(9) |
|
28
(13) |
29
(7) |
30
(7) |
31
(9) |
|
|
|
|
From: Tom H. <th...@cy...> - 2004-03-13 21:19:56
|
In message <107...@sp...>
Robert Walsh <rj...@du...> wrote:
> > On that point, anybody planning to attack this should check what
> > alignment glibc uses on x86-64 as it have to return 16 byte aligned
> > pointers due to the use of SSE for floating point values. It would
> > be a bit silly to rework it for 8 buyte alignment and then find we
> > need 16 byte alignment ;-)
>
> On one of our Opteron boxes, I spotted this in the posix_memalign() man
> page:
>
> GNU libc malloc() always returns 8-byte aligned memory
> addresses, so these routines are only needed if you require
> larger alignment values.
Yep. I had a look at glibc and as far as I can see it only does 8 byte
alignment, even on x86-64.
Tom
--
Tom Hughes (th...@cy...)
Software Engineer, Cyberscience Corporation
http://www.cyberscience.com/
|
|
From: Robert W. <rj...@du...> - 2004-03-13 20:50:06
|
> On that point, anybody planning to attack this should check what
> alignment glibc uses on x86-64 as it have to return 16 byte aligned
> pointers due to the use of SSE for floating point values. It would
> be a bit silly to rework it for 8 buyte alignment and then find we
> need 16 byte alignment ;-)
On one of our Opteron boxes, I spotted this in the posix_memalign() man
page:
GNU libc malloc() always returns 8-byte aligned memory
addresses, so these routines are only needed if you require
larger alignment values.
Regards,
Robert.
--=20
Robert Walsh
Amalgamated Durables, Inc. - "We don't make the things you buy."
Email: rj...@du...
|
|
From: Jeremy F. <je...@go...> - 2004-03-13 20:46:56
|
On Sat, 2004-03-13 at 10:19, Tom Hughes wrote: > On that point, anybody planning to attack this should check what > alignment glibc uses on x86-64 as it have to return 16 byte aligned > pointers due to the use of SSE for floating point values. It would > be a bit silly to rework it for 8 buyte alignment and then find we > need 16 byte alignment ;-) Yep; that might apply to x86-32 as well. In general we should work out how to parameterise it so that it matches the default alignment of the default allocator for the current OS/CPU target. J |
|
From: Jeremy F. <je...@go...> - 2004-03-13 20:30:01
|
On Sat, 2004-03-13 at 10:24, Tom Hughes wrote:
> I've been building calltree for 2.1.0 with only a minor patch to
> accept the newer interface version, and I did a patch this morning
> to make it work with 2.1.1 which is attached.
>
> The only problem I've notice with 2.1.1 with this patch is the need
> to use pointercheck=no as Josef has mentioned on the mailing list a
> couple of times.
Yeah, I'm not quite sure what the right fix is for that. It seems to me
the two options are:
1. add new CLOAD/CSTORE (checked and/or client load and store),
which is only generated by vg_to_ucode; the tools would use
LOAD/STORE for their own instrumentation memory accesses
2. add a flag to the existing LOAD and STORE
I'm tending towards option 1, but since we're planning on changing
everything for multi-arch stuff, I'm not inclined to spend to much time
on it now.
In the meantime, the quick workaround for calltree is for it to clear
VG_(clo_pointercheck) in its post-CLO parsing init function.
J
|
|
From: Tom H. <th...@cy...> - 2004-03-13 18:20:05
|
In message <200...@ac...>
Julian Seward <js...@ac...> wrote:
> I suspect a couple of hours figuring this out might sort it,
> partly because it's fairly well abstracted, partly because there's
> a good sanity checker, and partly because there's a standalone
> test driver at the bottom of the file. And given that we are
> headed inevitably to 64bit-ville, it's necessary anyway.
On that point, anybody planning to attack this should check what
alignment glibc uses on x86-64 as it have to return 16 byte aligned
pointers due to the use of SSE for floating point values. It would
be a bit silly to rework it for 8 buyte alignment and then find we
need 16 byte alignment ;-)
Tom
--
Tom Hughes (th...@cy...)
Software Engineer, Cyberscience Corporation
http://www.cyberscience.com/
|
|
From: Julian S. <js...@ac...> - 2004-03-13 17:38:47
|
On Saturday 13 March 2004 11:30, Nicholas Nethercote wrote:
> On Sat, 13 Mar 2004, Jeremy Fitzhardinge wrote:
> > Close bug 71906. Set default malloc alignment to 8 rather than 4.
>
> Um, problem with that is that non-4-byte aligned mallocs are done with
> VG_(arena_malloc_aligned)(), rather than VG_(arena_malloc)(). So now
> VG_(arena_malloc)() won't be used at all unless one sets --alignment=4.
>
> This doesn't seem like the right thing to do. Julian, you wrote the
> allocator, do you have an opinion about this?
(historical note:) The Right Solution is to modify vg_malloc2.c so all
payload pointers come out 8-aligned. I realised I had made a mistake
to set the baseline alignment at 4 rather than 8 soon after this allocator
went into service, but it was already a complete rewrite of a previous
one and I couldn't be bothered to rewrite it yet again.
See "block layout" at vg_malloc2.c:145. If the block layout is
changed to the following, and the number of red zone words is
forced to be even, then presumably the payloads will all be 8-aligned.
this block total sizeW (1 word)
freelist previous ptr (1 word)
red zone words (depends on .rz_szW field of Arena)
(payload words)
red zone words (depends on .rz_szW field of Arena)
freelist next ptr (1 word)
this block total sizeW (1 word)
Clearly the red zone sizeW % 2 == 0 is trivial to enforce. Question
is whether or not moving the freelist next ptr after the payload is
going to break things or not. I suspect it will be ok. Mostly this
will involve possibly changing the family of small functions beginning
at "mk_free_bszW" through to "bszW_to_pszW" -- all the layout knowledge
is encoded in them, I think.
There might be some complication in VG_(arena_malloc_aligned).
That's the only really nasty bit.
I suspect a couple of hours figuring this out might sort it,
partly because it's fairly well abstracted, partly because there's
a good sanity checker, and partly because there's a standalone
test driver at the bottom of the file. And given that we are
headed inevitably to 64bit-ville, it's necessary anyway.
J
|
|
From: Jeremy F. <je...@go...> - 2004-03-13 11:52:55
|
On Sat, 2004-03-13 at 03:30, Nicholas Nethercote wrote: > Um, problem with that is that non-4-byte aligned mallocs are done with > VG_(arena_malloc_aligned)(), rather than VG_(arena_malloc)(). So now > VG_(arena_malloc)() won't be used at all unless one sets --alignment=4. Returning unaligned pointers is worse. J |
|
From: Nicholas N. <nj...@ca...> - 2004-03-13 11:30:16
|
On Sat, 13 Mar 2004, Jeremy Fitzhardinge wrote: > Close bug 71906. Set default malloc alignment to 8 rather than 4. Um, problem with that is that non-4-byte aligned mallocs are done with VG_(arena_malloc_aligned)(), rather than VG_(arena_malloc)(). So now VG_(arena_malloc)() won't be used at all unless one sets --alignment=4. This doesn't seem like the right thing to do. Julian, you wrote the allocator, do you have an opinion about this? N |
|
From: <js...@ac...> - 2004-03-13 04:06:59
|
Nightly build on phoenix ( SuSE 8.2 ) started at 2004-03-13 04:00:00 GMT Checking out source tree ... done Configuring ... done Building ... done Running regression tests ... done Last 20 lines of log.verbose follow resolv: valgrind ./resolv seg_override: valgrind ./seg_override sha1_test: valgrind ./sha1_test shortpush: valgrind ./shortpush shorts: valgrind ./shorts smc1: valgrind ./smc1 syscall-restart1: valgrind ./syscall-restart1 syscall-restart2: valgrind ./syscall-restart2 system: valgrind ./system yield: valgrind ./yield -- Finished tests in none/tests ---------------------------------------- == 143 tests, 5 stderr failures, 0 stdout failures ================= corecheck/tests/as_mmap (stderr) corecheck/tests/fdleak_fcntl (stderr) helgrind/tests/inherit (stderr) memcheck/tests/writev (stderr) memcheck/tests/zeropage (stderr) make: *** [regtest] Error 1 |
|
From: <js...@ac...> - 2004-03-13 03:48:07
|
Nightly build on nemesis ( SuSE 9.0 ) started at 2004-03-13 03:50:00 GMT Checking out source tree ... done Configuring ... done Building ... done Running regression tests ... done Last 20 lines of log.verbose follow system: valgrind ./system yield: valgrind ./yield -- Finished tests in none/tests ---------------------------------------- == 143 tests, 13 stderr failures, 0 stdout failures ================= corecheck/tests/as_mmap (stderr) corecheck/tests/fdleak_cmsg (stderr) corecheck/tests/fdleak_creat (stderr) corecheck/tests/fdleak_dup (stderr) corecheck/tests/fdleak_dup2 (stderr) corecheck/tests/fdleak_fcntl (stderr) corecheck/tests/fdleak_ipv4 (stderr) corecheck/tests/fdleak_open (stderr) corecheck/tests/fdleak_pipe (stderr) corecheck/tests/fdleak_socketpair (stderr) helgrind/tests/inherit (stderr) memcheck/tests/writev (stderr) memcheck/tests/zeropage (stderr) make: *** [regtest] Error 1 |
|
From: Tom H. <to...@co...> - 2004-03-13 03:22:46
|
Nightly build on dunsmere ( Fedora Core 1 ) started at 2004-03-13 03:20:02 GMT Checking out source tree ... done Configuring ... done Building ... done Running regression tests ... done Last 20 lines of log.verbose follow == 148 tests, 15 stderr failures, 1 stdout failure ================= corecheck/tests/fdleak_cmsg (stderr) corecheck/tests/fdleak_creat (stderr) corecheck/tests/fdleak_dup (stderr) corecheck/tests/fdleak_dup2 (stderr) corecheck/tests/fdleak_fcntl (stderr) corecheck/tests/fdleak_ipv4 (stderr) corecheck/tests/fdleak_open (stderr) corecheck/tests/fdleak_pipe (stderr) corecheck/tests/fdleak_socketpair (stderr) helgrind/tests/inherit (stderr) memcheck/tests/buflen_check (stderr) memcheck/tests/execve (stderr) memcheck/tests/fwrite (stderr) memcheck/tests/weirdioctl (stderr) memcheck/tests/writev (stderr) none/tests/exec-sigmask (stdout) make: *** [regtest] Error 1 |
|
From: Tom H. <th...@cy...> - 2004-03-13 03:17:45
|
Nightly build on audi ( Red Hat 9 ) started at 2004-03-13 03:15:03 GMT Checking out source tree ... done Configuring ... done Building ... done Running regression tests ... done Last 20 lines of log.verbose follow pushpopseg: valgrind ./pushpopseg rcl_assert: valgrind ./rcl_assert rcrl: valgrind ./rcrl readline1: valgrind ./readline1 resolv: valgrind ./resolv seg_override: valgrind ./seg_override sha1_test: valgrind ./sha1_test shortpush: valgrind ./shortpush shorts: valgrind ./shorts smc1: valgrind ./smc1 syscall-restart1: valgrind ./syscall-restart1 syscall-restart2: valgrind ./syscall-restart2 system: valgrind ./system yield: valgrind ./yield -- Finished tests in none/tests ---------------------------------------- == 148 tests, 1 stderr failure, 0 stdout failures ================= helgrind/tests/inherit (stderr) make: *** [regtest] Error 1 |
|
From: Tom H. <th...@cy...> - 2004-03-13 03:13:30
|
Nightly build on ginetta ( Red Hat 8.0 ) started at 2004-03-13 03:10:03 GMT Checking out source tree ... done Configuring ... done Building ... done Running regression tests ... done Last 20 lines of log.verbose follow resolv: valgrind ./resolv seg_override: valgrind ./seg_override sha1_test: valgrind ./sha1_test shortpush: valgrind ./shortpush shorts: valgrind ./shorts smc1: valgrind ./smc1 syscall-restart1: valgrind ./syscall-restart1 syscall-restart2: valgrind ./syscall-restart2 system: valgrind ./system yield: valgrind ./yield -- Finished tests in none/tests ---------------------------------------- == 148 tests, 5 stderr failures, 0 stdout failures ================= helgrind/tests/deadlock (stderr) helgrind/tests/inherit (stderr) helgrind/tests/race (stderr) helgrind/tests/race2 (stderr) memcheck/tests/nanoleak (stderr) make: *** [regtest] Error 1 |
|
From: Tom H. <th...@cy...> - 2004-03-13 03:07:58
|
Nightly build on alvis ( Red Hat 7.3 ) started at 2004-03-13 03:05:03 GMT Checking out source tree ... done Configuring ... done Building ... done Running regression tests ... done Last 20 lines of log.verbose follow smc1: valgrind ./smc1 syscall-restart1: valgrind ./syscall-restart1 syscall-restart2: valgrind ./syscall-restart2 system: valgrind ./system yield: valgrind ./yield -- Finished tests in none/tests ---------------------------------------- == 148 tests, 9 stderr failures, 1 stdout failure ================= helgrind/tests/deadlock (stderr) helgrind/tests/inherit (stderr) helgrind/tests/race (stderr) helgrind/tests/race2 (stderr) memcheck/tests/badfree-2trace (stderr) memcheck/tests/badjump (stderr) memcheck/tests/brk (stderr) memcheck/tests/error_counts (stdout) memcheck/tests/new_nothrow (stderr) memcheck/tests/writev (stderr) make: *** [regtest] Error 1 |
|
From: Tom H. <th...@cy...> - 2004-03-13 03:07:19
|
Nightly build on standard ( Red Hat 7.2 ) started at 2004-03-13 03:00:03 GMT Checking out source tree ... done Configuring ... done Building ... done Running regression tests ... done Last 20 lines of log.verbose follow rcl_assert: valgrind ./rcl_assert rcrl: valgrind ./rcrl readline1: valgrind ./readline1 resolv: valgrind ./resolv seg_override: valgrind ./seg_override sha1_test: valgrind ./sha1_test shortpush: valgrind ./shortpush shorts: valgrind ./shorts smc1: valgrind ./smc1 syscall-restart1: valgrind ./syscall-restart1 syscall-restart2: valgrind ./syscall-restart2 system: valgrind ./system yield: valgrind ./yield -- Finished tests in none/tests ---------------------------------------- == 148 tests, 2 stderr failures, 0 stdout failures ================= helgrind/tests/inherit (stderr) memcheck/tests/badfree-2trace (stderr) make: *** [regtest] Error 1 |
|
From: Dirk M. <mu...@kd...> - 2004-03-13 02:56:36
|
CVS commit by mueller: whoops M +7 -7 Makefile.am 1.3 --- valgrind/coregrind/arch/x86-linux/Makefile.am #1.2:1.3 @@ -4,11 +4,11 @@ libpthread_so_SOURCES = \ - vg_libpthread.c \ - vg_libpthread_unimp.c \ - vg_syscall.S + vg_libpthread.c \ + vg_libpthread_unimp.c \ + vg_syscall.S libpthread_so_DEPENDENCIES = $(srcdir)/vg_libpthread.vs libpthread_so_LDFLAGS = -Werror -fno-omit-frame-pointer -UVG_LIBDIR \ - -shared -fpic \ - -Wl,-version-script $(srcdir)/vg_libpthread.vs \ - -Wl,-z,nodelete \ - -Wl,--soname=libpthread.so.0 + -shared -fpic \ + -Wl,-version-script $(srcdir)/vg_libpthread.vs \ + -Wl,-z,nodelete \ + -Wl,--soname=libpthread.so.0 |
|
From: Dirk M. <mu...@kd...> - 2004-03-13 02:50:00
|
CVS commit by mueller:
fix up the other places as well
M +2 -2 vg_malloc2.c 1.21
M +12 -0 arch/x86-linux/Makefile.am 1.2
M +1 -1 docs/coregrind_core.html 1.27
--- valgrind/coregrind/vg_malloc2.c #1.20:1.21
@@ -47,5 +47,5 @@ Bool VG_(clo_trace_malloc) = False;
/* Minimum alignment in functions that don't specify alignment explicitly.
- default: 0, i.e. use default of the machine (== 4) */
+ default: 0, i.e. use default of the machine (== 8) */
Int VG_(clo_alignment) = 8;
@@ -87,5 +87,5 @@ void VG_(replacement_malloc_print_usage)
VG_(printf)(
" --sloppy-malloc=no|yes round malloc sizes to next word? [no]\n"
-" --alignment=<number> set minimum alignment of allocations [4]\n"
+" --alignment=<number> set minimum alignment of allocations [8]\n"
);
}
--- valgrind/coregrind/arch/x86-linux/Makefile.am #1.1:1.2
@@ -1,2 +1,14 @@
+valdir = $(libdir)/valgrind
+val_PROGRAMS = libpthread.so
+libpthread_so_SOURCES = \
+ vg_libpthread.c \
+ vg_libpthread_unimp.c \
+ vg_syscall.S
+libpthread_so_DEPENDENCIES = $(srcdir)/vg_libpthread.vs
+libpthread_so_LDFLAGS = -Werror -fno-omit-frame-pointer -UVG_LIBDIR \
+ -shared -fpic \
+ -Wl,-version-script $(srcdir)/vg_libpthread.vs \
+ -Wl,-z,nodelete \
+ -Wl,--soname=libpthread.so.0
--- valgrind/coregrind/docs/coregrind_core.html #1.26:1.27
@@ -711,5 +711,5 @@
and Addrcheck), the following options apply.
<ul>
- <li><code>--alignment=<number></code> [default: 4]<br> <p>By
+ <li><code>--alignment=<number></code> [default: 8]<br> <p>By
default Valgrind's <code>malloc</code>, <code>realloc</code>,
etc, return 4-byte aligned addresses. These are suitable for
|
|
From: Jeremy F. <je...@go...> - 2004-03-13 02:38:39
|
CVS commit by fitzhardinge:
Close bug 71906. Set default malloc alignment to 8 rather than 4.
M +1 -1 vg_malloc2.c 1.20
--- valgrind/coregrind/vg_malloc2.c #1.19:1.20
@@ -48,5 +48,5 @@ Bool VG_(clo_trace_malloc) = False;
/* Minimum alignment in functions that don't specify alignment explicitly.
default: 0, i.e. use default of the machine (== 4) */
-Int VG_(clo_alignment) = 4;
+Int VG_(clo_alignment) = 8;
|
|
From: Jeremy F. <je...@go...> - 2004-03-13 02:07:10
|
CVS commit by fitzhardinge:
Fix bug 69872. This change adds a coredumper to vg_signal.c. This means
that when the client is killed by a coredumping signal, Valgrind will
generate the coredump itself, which is full of client state, rather than
Valgrind state; this core file will therefore be useful to the developer
in debugging their program.
The corefile generated is named vgcore.pidNNNNN (and maybe with .M on
the end in case of duplicates). If you set a logfile with --logfile,
then this name will be used as the basename for the core file, so that
both the core and the logs will be next to each other.
Valgrind respects the RLIMIT_CORE limit when generating the file; if the
limit is set to 0, then it will not generate one.
M +1 -0 coregrind/vg_include.h 1.185
M +12 -13 coregrind/vg_main.c 1.147
M +5 -0 coregrind/vg_memory.c 1.52
M +402 -0 coregrind/vg_signals.c 1.60
M +3 -3 coregrind/vg_syscalls.c 1.92
M +0 -1 coregrind/vg_unsafe.h 1.25
M +118 -0 include/vg_kerneliface.h 1.16
--- valgrind/coregrind/vg_include.h #1.184:1.185
@@ -1567,4 +1567,5 @@ extern Addr VG_(find_map_space)(Addr bas
extern Segment *VG_(find_segment)(Addr a);
+extern Segment *VG_(first_segment)(void);
extern Segment *VG_(next_segment)(Segment *);
--- valgrind/coregrind/vg_main.c #1.146:1.147
@@ -48,5 +48,4 @@
#include <sys/ptrace.h>
#include <sys/signal.h>
-#include <sys/user.h>
#include <sys/wait.h>
#include <unistd.h>
@@ -312,10 +311,10 @@ void VG_(start_debugger) ( Int tid )
if (VG_(is_running_thread)( tid )) {
- regs.xcs = VG_(baseBlock)[VGOFF_(m_cs)];
- regs.xss = VG_(baseBlock)[VGOFF_(m_ss)];
- regs.xds = VG_(baseBlock)[VGOFF_(m_ds)];
- regs.xes = VG_(baseBlock)[VGOFF_(m_es)];
- regs.xfs = VG_(baseBlock)[VGOFF_(m_fs)];
- regs.xgs = VG_(baseBlock)[VGOFF_(m_gs)];
+ regs.cs = VG_(baseBlock)[VGOFF_(m_cs)];
+ regs.ss = VG_(baseBlock)[VGOFF_(m_ss)];
+ regs.ds = VG_(baseBlock)[VGOFF_(m_ds)];
+ regs.es = VG_(baseBlock)[VGOFF_(m_es)];
+ regs.fs = VG_(baseBlock)[VGOFF_(m_fs)];
+ regs.gs = VG_(baseBlock)[VGOFF_(m_gs)];
regs.eax = VG_(baseBlock)[VGOFF_(m_eax)];
regs.ebx = VG_(baseBlock)[VGOFF_(m_ebx)];
@@ -331,10 +330,10 @@ void VG_(start_debugger) ( Int tid )
ThreadState* tst = & VG_(threads)[ tid ];
- regs.xcs = tst->m_cs;
- regs.xss = tst->m_ss;
- regs.xds = tst->m_ds;
- regs.xes = tst->m_es;
- regs.xfs = tst->m_fs;
- regs.xgs = tst->m_gs;
+ regs.cs = tst->m_cs;
+ regs.ss = tst->m_ss;
+ regs.ds = tst->m_ds;
+ regs.es = tst->m_es;
+ regs.fs = tst->m_fs;
+ regs.gs = tst->m_gs;
regs.eax = tst->m_eax;
regs.ebx = tst->m_ebx;
--- valgrind/coregrind/vg_memory.c #1.51:1.52
@@ -552,4 +552,9 @@ Segment *VG_(find_segment)(Addr a)
}
+Segment *VG_(first_segment)(void)
+{
+ return VG_(SkipNode_First)(&sk_segments);
+}
+
Segment *VG_(next_segment)(Segment *s)
{
--- valgrind/coregrind/vg_signals.c #1.59:1.60
@@ -1278,4 +1278,393 @@ void VG_(kill_self)(Int sigNo)
/*
+ Dump core
+
+ Generate a standard ELF core file corresponding to the client state
+ at the time of a crash.
+ */
+#include <elf.h>
+#ifndef NT_PRXFPREG
+#define NT_PRXFPREG 0x46e62b7f /* copied from gdb5.1/include/elf/common.h */
+#endif /* NT_PRXFPREG */
+
+/* If true, then this Segment may be mentioned in the core */
+static Bool may_dump(const Segment *seg)
+{
+ return (seg->flags & SF_VALGRIND) == 0 && VG_(is_client_addr)(seg->addr);
+}
+
+/* If true, then this Segment's contents will be in the core */
+static Bool should_dump(const Segment *seg)
+{
+ return may_dump(seg); // && (seg->prot & VKI_PROT_WRITE);
+}
+
+static void fill_ehdr(Elf32_Ehdr *ehdr, Int num_phdrs)
+{
+ VG_(memset)(ehdr, 0, sizeof(ehdr));
+
+ VG_(memcpy)(ehdr->e_ident, ELFMAG, SELFMAG);
+ ehdr->e_ident[EI_CLASS] = ELFCLASS32;
+ ehdr->e_ident[EI_DATA] = ELFDATA2LSB;
+ ehdr->e_ident[EI_VERSION] = EV_CURRENT;
+ ehdr->e_ident[EI_OSABI] = ELFOSABI_LINUX;
+
+ ehdr->e_type = ET_CORE;
+ ehdr->e_machine = EM_386;
+ ehdr->e_version = EV_CURRENT;
+ ehdr->e_entry = 0;
+ ehdr->e_phoff = sizeof(Elf32_Ehdr);
+ ehdr->e_shoff = 0;
+ ehdr->e_flags = 0;
+ ehdr->e_ehsize = sizeof(Elf32_Ehdr);
+ ehdr->e_phentsize = sizeof(Elf32_Phdr);
+ ehdr->e_phnum = num_phdrs;
+ ehdr->e_shentsize = 0;
+ ehdr->e_shnum = 0;
+ ehdr->e_shstrndx = 0;
+
+}
+
+static void fill_phdr(Elf32_Phdr *phdr, const Segment *seg, UInt off, Bool write)
+{
+ write = write && should_dump(seg);
+
+ VG_(memset)(phdr, 0, sizeof(*phdr));
+
+ phdr->p_type = PT_LOAD;
+ phdr->p_offset = off;
+ phdr->p_vaddr = seg->addr;
+ phdr->p_paddr = 0;
+ phdr->p_filesz = write ? seg->len : 0;
+ phdr->p_memsz = seg->len;
+ phdr->p_flags = 0;
+
+ if (seg->prot & VKI_PROT_READ)
+ phdr->p_flags |= PF_R;
+ if (seg->prot & VKI_PROT_WRITE)
+ phdr->p_flags |= PF_W;
+ if (seg->prot & VKI_PROT_EXEC)
+ phdr->p_flags |= PF_X;
+
+ phdr->p_align = VKI_BYTES_PER_PAGE;
+}
+
+struct note {
+ struct note *next;
+ Elf32_Nhdr note;
+ Char name[0];
+};
+
+static UInt note_size(const struct note *n)
+{
+ return sizeof(Elf32_Nhdr) + ROUNDUP(VG_(strlen)(n->name)+1, 4) + ROUNDUP(n->note.n_descsz, 4);
+}
+
+static void add_note(struct note **list, const Char *name, UInt type, const void *data, UInt datasz)
+{
+ Int namelen = VG_(strlen)(name)+1;
+ Int notelen = sizeof(struct note) +
+ ROUNDUP(namelen, 4) +
+ ROUNDUP(datasz, 4);
+ struct note *n = VG_(arena_malloc)(VG_AR_CORE, notelen);
+
+ VG_(memset)(n, 0, notelen);
+
+ n->next = *list;
+ *list = n;
+
+ n->note.n_type = type;
+ n->note.n_namesz = namelen;
+ n->note.n_descsz = datasz;
+
+ VG_(memcpy)(n->name, name, namelen);
+ VG_(memcpy)(n->name+ROUNDUP(namelen,4), data, datasz);
+}
+
+static void write_note(Int fd, const struct note *n)
+{
+ VG_(write)(fd, &n->note, note_size(n));
+}
+
+static void fill_prpsinfo(const ThreadState *tst, struct elf_prpsinfo *prpsinfo)
+{
+ Char *name;
+
+ VG_(memset)(prpsinfo, 0, sizeof(*prpsinfo));
+
+ switch(tst->status) {
+ case VgTs_Runnable:
+ prpsinfo->pr_sname = 'R';
+ break;
+
+ case VgTs_WaitJoinee:
+ prpsinfo->pr_sname = 'Z';
+ prpsinfo->pr_zomb = 1;
+ break;
+
+ case VgTs_WaitJoiner:
+ case VgTs_WaitMX:
+ case VgTs_WaitCV:
+ case VgTs_WaitSys:
+ case VgTs_Sleeping:
+ prpsinfo->pr_sname = 'S';
+ break;
+
+ case VgTs_Empty:
+ /* ? */
+ break;
+ }
+
+ prpsinfo->pr_uid = 0;
+ prpsinfo->pr_gid = 0;
+
+ name = VG_(resolve_filename)(VG_(clexecfd));
+
+ if (name != NULL) {
+ Char *n = name+VG_(strlen)(name)-1;
+
+ while(n > name && *n != '/')
+ n--;
+ if (n != name)
+ n++;
+
+ VG_(strncpy)(prpsinfo->pr_fname, n, sizeof(prpsinfo->pr_fname));
+ }
+}
+
+static void fill_prstatus(const ThreadState *tst, struct elf_prstatus *prs, const vki_ksiginfo_t *si)
+{
+ struct user_regs_struct *regs;
+
+ VG_(memset)(prs, 0, sizeof(*prs));
+
+ prs->pr_info.si_signo = si->si_signo;
+ prs->pr_info.si_code = si->si_code;
+ prs->pr_info.si_errno = 0;
+
+ prs->pr_cursig = si->si_signo;
+
+ prs->pr_pid = VG_(main_pid) + tst->tid; /* just to distinguish threads from each other */
+ prs->pr_ppid = 0;
+ prs->pr_pgrp = VG_(main_pgrp);
+ prs->pr_sid = VG_(main_pgrp);
+
+ regs = (struct user_regs_struct *)prs->pr_reg;
+
+ vg_assert(sizeof(*regs) == sizeof(prs->pr_reg));
+
+ if (VG_(is_running_thread)(tst->tid)) {
+ regs->eflags = VG_(baseBlock)[VGOFF_(m_eflags)];
+ regs->esp = VG_(baseBlock)[VGOFF_(m_esp)];
+ regs->eip = VG_(baseBlock)[VGOFF_(m_eip)];
+
+ regs->ebx = VG_(baseBlock)[VGOFF_(m_ebx)];
+ regs->ecx = VG_(baseBlock)[VGOFF_(m_ecx)];
+ regs->edx = VG_(baseBlock)[VGOFF_(m_edx)];
+ regs->esi = VG_(baseBlock)[VGOFF_(m_esi)];
+ regs->edi = VG_(baseBlock)[VGOFF_(m_edi)];
+ regs->ebp = VG_(baseBlock)[VGOFF_(m_ebp)];
+ regs->eax = VG_(baseBlock)[VGOFF_(m_eax)];
+
+ regs->cs = VG_(baseBlock)[VGOFF_(m_cs)];
+ regs->ds = VG_(baseBlock)[VGOFF_(m_ds)];
+ regs->ss = VG_(baseBlock)[VGOFF_(m_ss)];
+ regs->es = VG_(baseBlock)[VGOFF_(m_es)];
+ regs->fs = VG_(baseBlock)[VGOFF_(m_fs)];
+ regs->gs = VG_(baseBlock)[VGOFF_(m_gs)];
+ } else {
+ regs->eflags = tst->m_eflags;
+ regs->esp = tst->m_esp;
+ regs->eip = tst->m_eip;
+
+ regs->ebx = tst->m_ebx;
+ regs->ecx = tst->m_ecx;
+ regs->edx = tst->m_edx;
+ regs->esi = tst->m_esi;
+ regs->edi = tst->m_edi;
+ regs->ebp = tst->m_ebp;
+ regs->eax = tst->m_eax;
+
+ regs->cs = tst->m_cs;
+ regs->ds = tst->m_ds;
+ regs->ss = tst->m_ss;
+ regs->es = tst->m_es;
+ regs->fs = tst->m_fs;
+ regs->gs = tst->m_gs;
+ }
+}
+
+static void fill_fpu(const ThreadState *tst, elf_fpregset_t *fpu)
+{
+ const Char *from;
+
+ if (VG_(is_running_thread)(tst->tid)) {
+ from = (const Char *)&VG_(baseBlock)[VGOFF_(m_ssestate)];
+ } else {
+ from = (const Char *)&tst->m_sse;
+ }
+
+ if (VG_(have_ssestate)) {
+ UShort *to;
+ Int i;
+
+ /* This is what the kernel does */
+ VG_(memcpy)(fpu, from, 7*sizeof(long));
+
+ to = (UShort *)&fpu->st_space[0];
+ from += 18 * sizeof(UShort);
+
+ for(i = 0; i < 8; i++, to += 5, from += 8)
+ VG_(memcpy)(to, from, 5*sizeof(UShort));
+ } else
+ VG_(memcpy)(fpu, from, sizeof(*fpu));
+}
+
+static void fill_xfpu(const ThreadState *tst, elf_fpxregset_t *xfpu)
+{
+ UShort *from;
+
+ if (VG_(is_running_thread)(tst->tid))
+ from = (UShort *)&VG_(baseBlock)[VGOFF_(m_ssestate)];
+ else
+ from = (UShort *)tst->m_sse;
+
+ VG_(memcpy)(xfpu, from, sizeof(*xfpu));
+}
+
+static void make_coredump(ThreadId tid, const vki_ksiginfo_t *si, UInt max_size)
+{
+ Char buf[1000];
+ Char *basename = "vgcore";
+ Char *coreext = "";
+ Int seq = 0;
+ Int core_fd;
+ Segment *seg;
+ Elf32_Ehdr ehdr;
+ Elf32_Phdr *phdrs;
+ Int num_phdrs;
+ Int i;
+ UInt off;
+ struct note *notelist, *note;
+ UInt notesz;
+ struct elf_prpsinfo prpsinfo;
+ struct elf_prstatus prstatus;
+
+ if (VG_(clo_logfile_name) != NULL) {
+ coreext = ".core";
+ basename = VG_(clo_logfile_name);
+ }
+
+ for(;;) {
+ if (seq == 0)
+ VG_(sprintf)(buf, "%s%s.pid%d",
+ basename, coreext, VG_(main_pid));
+ else
+ VG_(sprintf)(buf, "%s%s.pid%d.%d",
+ basename, coreext, VG_(main_pid), seq);
+ seq++;
+
+ core_fd = VG_(open)(buf,
+ VKI_O_CREAT|VKI_O_WRONLY|VKI_O_EXCL|VKI_O_TRUNC,
+ VKI_S_IRUSR|VKI_S_IWUSR);
+ if (core_fd >= 0)
+ break;
+
+ if (core_fd != -VKI_EEXIST)
+ return; /* can't create file */
+ }
+
+ /* First, count how many memory segments to dump */
+ num_phdrs = 1; /* start with notes */
+ for(seg = VG_(first_segment)();
+ seg != NULL;
+ seg = VG_(next_segment)(seg)) {
+ if (!may_dump(seg))
+ continue;
+
+ num_phdrs++;
+ }
+
+ fill_ehdr(&ehdr, num_phdrs);
+
+ /* Second, work out their layout */
+ phdrs = VG_(arena_malloc)(VG_AR_CORE, sizeof(*phdrs) * num_phdrs);
+
+ for(i = 1; i < VG_N_THREADS; i++) {
+ elf_fpregset_t fpu;
+
+ if (VG_(threads)[i].status == VgTs_Empty)
+ continue;
+
+ if (VG_(have_ssestate)) {
+ elf_fpxregset_t xfpu;
+
+ fill_xfpu(&VG_(threads)[i], &xfpu);
+ add_note(¬elist, "LINUX", NT_PRXFPREG, &xfpu, sizeof(xfpu));
+ }
+
+ fill_fpu(&VG_(threads)[i], &fpu);
+ add_note(¬elist, "CORE", NT_FPREGSET, &fpu, sizeof(fpu));
+
+ fill_prstatus(&VG_(threads)[i], &prstatus, si);
+ add_note(¬elist, "CORE", NT_PRSTATUS, &prstatus, sizeof(prstatus));
+ }
+
+ fill_prpsinfo(&VG_(threads)[tid], &prpsinfo);
+ add_note(¬elist, "CORE", NT_PRPSINFO, &prpsinfo, sizeof(prpsinfo));
+
+ for(note = notelist, notesz = 0; note != NULL; note = note->next)
+ notesz += note_size(note);
+
+ off = sizeof(ehdr) + sizeof(*phdrs) * num_phdrs;
+
+ phdrs[0].p_type = PT_NOTE;
+ phdrs[0].p_offset = off;
+ phdrs[0].p_vaddr = 0;
+ phdrs[0].p_paddr = 0;
+ phdrs[0].p_filesz = notesz;
+ phdrs[0].p_memsz = 0;
+ phdrs[0].p_flags = 0;
+ phdrs[0].p_align = 0;
+
+ off += notesz;
+
+ off = PGROUNDUP(off);
+
+ for(seg = VG_(first_segment)(), i = 1;
+ seg != NULL;
+ seg = VG_(next_segment)(seg), i++) {
+ if (!may_dump(seg))
+ continue;
+
+ fill_phdr(&phdrs[i], seg, off, (seg->len + off) < max_size);
+
+ off += phdrs[i].p_filesz;
+ }
+
+ /* write everything out */
+ VG_(write)(core_fd, &ehdr, sizeof(ehdr));
+ VG_(write)(core_fd, phdrs, sizeof(*phdrs) * num_phdrs);
+
+ for(note = notelist; note != NULL; note = note->next)
+ write_note(core_fd, note);
+
+ VG_(lseek)(core_fd, phdrs[1].p_offset, VKI_SEEK_SET);
+
+ for(seg = VG_(first_segment)(), i = 1;
+ seg != NULL;
+ seg = VG_(next_segment)(seg), i++) {
+ if (!should_dump(seg))
+ continue;
+
+ vg_assert(VG_(lseek)(core_fd, 0, VKI_SEEK_CUR) == phdrs[i].p_offset);
+ if (phdrs[i].p_filesz > 0)
+ VG_(write)(core_fd, (void *)seg->addr, seg->len);
+ }
+
+ VG_(close)(core_fd);
+}
+
+/*
Perform the default action of a signal. Returns if the default
action isn't fatal.
@@ -1396,4 +1785,17 @@ static void vg_default_action(const vki_
}
+ if (core) {
+ static struct vki_rlimit zero = { 0, 0 };
+ struct vki_rlimit corelim;
+
+ VG_(getrlimit)(VKI_RLIMIT_CORE, &corelim);
+
+ if (corelim.rlim_cur > 0)
+ make_coredump(tid, info, corelim.rlim_cur);
+
+ /* make sure we don't get a confusing kernel-generated coredump */
+ VG_(setrlimit)(VKI_RLIMIT_CORE, &zero);
+ }
+
if (VG_(fatal_signal_set)) {
VG_(fatal_sigNo) = sigNo;
--- valgrind/coregrind/vg_syscalls.c #1.91:1.92
@@ -1148,5 +1148,5 @@ PRE(ptrace)
case 14: /* PTRACE_GETFPREGS */
SYSCALL_TRACK( pre_mem_write, tid, "ptrace(getfpregs)", arg4,
- sizeof (struct user_fpregs_struct));
+ sizeof (struct user_i387_struct));
break;
case 18: /* PTRACE_GETFPXREGS */
@@ -1164,5 +1164,5 @@ PRE(ptrace)
case 15: /* PTRACE_SETFPREGS */
SYSCALL_TRACK( pre_mem_read, tid, "ptrace(setfpregs)", arg4,
- sizeof (struct user_fpregs_struct));
+ sizeof (struct user_i387_struct));
break;
case 19: /* PTRACE_SETFPXREGS */
@@ -1188,5 +1188,5 @@ POST(ptrace)
case 14: /* PTRACE_GETFPREGS */
VG_TRACK( post_mem_write, arg4,
- sizeof (struct user_fpregs_struct));
+ sizeof (struct user_i387_struct));
break;
case 18: /* PTRACE_GETFPXREGS */
--- valgrind/coregrind/vg_unsafe.h #1.24:1.25
@@ -62,5 +62,4 @@
#include <linux/sysctl.h> /* for struct __sysctl_args */
#include <linux/cdrom.h> /* for cd-rom ioctls */
-#include <sys/user.h> /* for struct user_regs_struct et al */
#include <signal.h> /* for siginfo_t */
#include <linux/timex.h> /* for adjtimex */
--- valgrind/include/vg_kerneliface.h #1.15:1.16
@@ -764,4 +764,122 @@ struct statfs64 {
#define VKI_FUTEX_REQUEUE 3
+/*
+ * linux/elfcore.h
+ */
+
+struct elf_siginfo
+{
+ int si_signo; /* signal number */
+ int si_code; /* extra code */
+ int si_errno; /* errno */
+};
+
+/*
+ * This is the old layout of "struct pt_regs", and
+ * is still the layout used by user mode (the new
+ * pt_regs doesn't have all registers as the kernel
+ * doesn't use the extra segment registers)
+ */
+struct user_regs_struct {
+ long ebx, ecx, edx, esi, edi, ebp, eax;
+ unsigned short ds, __ds, es, __es;
+ unsigned short fs, __fs, gs, __gs;
+ long orig_eax, eip;
+ unsigned short cs, __cs;
+ long eflags, esp;
+ unsigned short ss, __ss;
+};
+
+struct user_i387_struct {
+ long cwd;
+ long swd;
+ long twd;
+ long fip;
+ long fcs;
+ long foo;
+ long fos;
+ long st_space[20]; /* 8*10 bytes for each FP-reg = 80 bytes */
+};
+
+struct user_fxsr_struct {
+ unsigned short cwd;
+ unsigned short swd;
+ unsigned short twd;
+ unsigned short fop;
+ long fip;
+ long fcs;
+ long foo;
+ long fos;
+ long mxcsr;
+ long reserved;
+ long st_space[32]; /* 8*16 bytes for each FP-reg = 128 bytes */
+ long xmm_space[32]; /* 8*16 bytes for each XMM-reg = 128 bytes */
+ long padding[56];
+};
+
+typedef unsigned long elf_greg_t;
+
+#define ELF_NGREG (sizeof (struct user_regs_struct) / sizeof(elf_greg_t))
+typedef elf_greg_t elf_gregset_t[ELF_NGREG];
+
+typedef struct user_i387_struct elf_fpregset_t;
+typedef struct user_fxsr_struct elf_fpxregset_t;
+
+
+/*
+ * Definitions to generate Intel SVR4-like core files.
+ * These mostly have the same names as the SVR4 types with "elf_"
+ * tacked on the front to prevent clashes with linux definitions,
+ * and the typedef forms have been avoided. This is mostly like
+ * the SVR4 structure, but more Linuxy, with things that Linux does
+ * not support and which gdb doesn't really use excluded.
+ * Fields present but not used are marked with "XXX".
+ */
+struct elf_prstatus
+{
+#if 0
+ long pr_flags; /* XXX Process flags */
+ short pr_why; /* XXX Reason for process halt */
+ short pr_what; /* XXX More detailed reason */
+#endif
+ struct elf_siginfo pr_info; /* Info associated with signal */
+ short pr_cursig; /* Current signal */
+ unsigned long pr_sigpend; /* Set of pending signals */
+ unsigned long pr_sighold; /* Set of held signals */
+#if 0
+ struct sigaltstack pr_altstack; /* Alternate stack info */
+ struct sigaction pr_action; /* Signal action for current sig */
+#endif
+ Int pr_pid;
+ Int pr_ppid;
+ Int pr_pgrp;
+ Int pr_sid;
+ struct vki_timeval pr_utime; /* User time */
+ struct vki_timeval pr_stime; /* System time */
+ struct vki_timeval pr_cutime; /* Cumulative user time */
+ struct vki_timeval pr_cstime; /* Cumulative system time */
+#if 0
+ long pr_instr; /* Current instruction */
+#endif
+ elf_gregset_t pr_reg; /* GP registers */
+ int pr_fpvalid; /* True if math co-processor being used. */
+};
+
+#define ELF_PRARGSZ (80) /* Number of chars for args */
+
+struct elf_prpsinfo
+{
+ char pr_state; /* numeric process state */
+ char pr_sname; /* char for pr_state */
+ char pr_zomb; /* zombie */
+ char pr_nice; /* nice val */
+ unsigned long pr_flag; /* flags */
+ Int pr_uid;
+ Int pr_gid;
+ Int pr_pid, pr_ppid, pr_pgrp, pr_sid;
+ /* Lots missing */
+ char pr_fname[16]; /* filename of executable */
+ char pr_psargs[ELF_PRARGSZ]; /* initial part of arg list */
+};
#endif /* __VG_KERNELIFACE_H */
|
|
From: Julian S. <js...@ac...> - 2004-03-13 00:49:50
|
CVS commit by jseward: head --> 2.1.2-CVS so as to distinguish it from everything else :-) M +1 -1 configure.in 1.107 --- valgrind/configure.in #1.106:1.107 @@ -2,5 +2,5 @@ AC_INIT(coregrind/vg_main.c) # give me a source file, any source file... AM_CONFIG_HEADER(config.h) -AM_INIT_AUTOMAKE(valgrind, 2.1.1) +AM_INIT_AUTOMAKE(valgrind, 2.1.2-CVS) AM_MAINTAINER_MODE |
|
From: Julian S. <js...@ac...> - 2004-03-13 00:39:06
|
CVS commit by jseward: Implicitly mention Massif. M +10 -5 index.html 1.20 --- devel-home/valgrind/index.html #1.19:1.20 @@ -21,11 +21,16 @@ <p> <strong>Valgrind is a GPL'd system for debugging and profiling x86-Linux programs.</strong> + With the tools that come with Valgrind, you can automatically detect -many memory management and threading bugs, avoiding hours of frustrating -bug-hunting, making your programs more stable. You can also perform -detailed profiling to help speed up your programs. +many memory management and threading bugs, avoiding hours of +frustrating bug-hunting, making your programs more stable. You can +also perform detailed profiling, to speed up and reduce memory use +of your programs. + <p> -The Valgrind distribution includes four tools: two memory error -detectors, a thread error detector, and a cache profiler. Several other +The Valgrind distribution includes five tools: two memory error +detectors, a thread error detector, a cache profiler and a heap +profiler. +Several other tools have been built with Valgrind. <p> |
|
From: Julian S. <js...@ac...> - 2004-03-13 00:35:57
|
We are pleased to announce a new release, 2.1.1, from our current development (unstable) branch, available from http://valgrind.kde.org. It appears to be fairly stable and quite usable, but at the end of the day, is still a development release. Anyway, the details follow. J -------------------------------------------------------------------- 2.1.1 contains some internal structural changes needed for V's long-term future. These don't affect end-users. Most notable user-visible changes are: * Greater isolation between Valgrind and the program being run, so the program is less likely to inadvertently kill Valgrind by doing wild writes. * Massif: a new space profiling tool. Try it! It's cool, and it'll tell you in detail where and when your C/C++ code is allocating heap. Draws pretty .ps pictures of memory use against time. A potentially powerful tool for making sense of your program's space use. * Fixes for many bugs, including support for more SSE2/SSE3 instructions, various signal/syscall things, and various problems with debug info readers. * Support for glibc-2.3.3 based systems. We are now doing automatic overnight build-and-test runs on a variety of distros. As a result, we believe 2.1.1 builds and runs on: Red Hat 7.2, 7.3, 8.0, 9, Fedora Core 1, SuSE 8.2, SuSE 9. The following bugs, and probably many more, have been fixed. These are listed at http://bugs.kde.org. Reporting a bug for valgrind in the http://bugs.kde.org is much more likely to get you a fix than mailing developers directly, so please continue to keep sending bugs there. 69616 glibc 2.3.2 w/NPTL is massively different than what valgrind expects 69856 I don't know how to instrument MMXish stuff (Helgrind) 73892 valgrind segfaults starting with Objective-C debug info (fix for S-type stabs) 73145 Valgrind complains too much about close(<reserved fd>) 73902 Shadow memory allocation seems to fail on RedHat 8.0 68633 VG_N_SEMAPHORES too low (V itself was leaking semaphores) 75099 impossible to trace multiprocess programs 76839 the `impossible' happened: disInstr: INT but not 0x80 ! 76762 vg_to_ucode.c:3748 (dis_push_segreg): Assertion `sz == 4' failed. 76747 cannot include valgrind.h in c++ program 76223 parsing B(3,10) gave NULL type => impossible happens 75604 shmdt handling problem 76416 Problems with gcc 3.4 snap 20040225 75614 using -gstabs when building your programs the `impossible' happened 75787 Patch for some CDROM ioctls CDORM_GET_MCN, CDROM_SEND_PACKET, 75294 gcc 3.4 snapshot's libstdc++ have unsupported instructions. (REP RET) 73326 vg_symtab2.c:272 (addScopeRange): Assertion `range->size > 0' failed. 72596 not recognizing __libc_malloc 69489 Would like to attach ddd to running program 72781 Cachegrind crashes with kde programs 73055 Illegal operand at DXTCV11CompressBlockSSE2 (more SSE opcodes) 73026 Descriptor leak check reports port numbers wrongly 71705 README_MISSING_SYSCALL_OR_IOCTL out of date 72643 Improve support for SSE/SSE2 instructions 72484 valgrind leaves it's own signal mask in place when execing 72650 Signal Handling always seems to restart system calls 72006 The mmap system call turns all errors in ENOMEM 71781 gdb attach is pretty useless 71180 unhandled instruction bytes: 0xF 0xAE 0x85 0xE8 69886 writes to zero page cause valgrind to assert on exit 71791 crash when valgrinding gimp 1.3 (stabs reader problem) 69783 unhandled syscall: 218 69782 unhandled instruction bytes: 0x66 0xF 0x2B 0x80 70385 valgrind fails if the soft file descriptor limit is less than about 828 69529 "rep; nop" should do a yield 70827 programs with lots of shared libraries report "mmap failed" for some of them when reading symbols 71028 glibc's strnlen is optimised enough to confuse valgrind |
|
From: Julian S. <js...@ac...> - 2004-03-13 00:24:28
|
CVS commit by jseward: Announce 2.1.1. M +35 -3 downloads.html 1.11 M +3 -3 news.html 1.3 --- devel-home/valgrind/downloads.html #1.10:1.11 @@ -32,4 +32,39 @@ <h3>Current Development Release</h3> +<strong>2.1.1 (of 12 March 2004)</strong> + <a HREF="http://developer.kde.org/~sewardj/valgrind-2.1.1.tar.bz2">(bzip2'd source, 923KB)</a> + (MD5=0010c3e8f054ecc633151c62044b646d) +<p> +2.1.1 contains some internal structural changes needed for V's +long-term future. These don't affect end-users. There are +also some useful user-visible changes. +<ul> +<li> +Greater isolation between Valgrind and the program being run, so + the program is less likely to inadvertently kill Valgrind by + doing wild writes. +<p><li> +Massif: a new space profiling tool. Try it! It's cool, and it'll + tell you in detail where and when your C/C++ code is allocating heap. + Draws pretty .ps pictures of memory use against time. A potentially + powerful tool for making sense of your program's space use. +<p><li> +Fixes for many bugs, including support for more SSE2/SSE3 instructions, + various signal/syscall things, and various problems with debug + info readers. +<p><li> +Support for glibc-2.3.3 based systems. +</ul> + +We are now doing automatic overnight build-and-test runs on a variety +of distros. As a result, we believe 2.1.1 builds and runs on: +Red Hat 7.2, 7.3, 8.0, 9, Fedora Core 1, SuSE 8.2, SuSE 9. + + + + + +<h3>Older Development Release</h3> + <strong>2.1.0 (of 14 December 2003)</strong> <a HREF="http://developer.kde.org/~sewardj/valgrind-2.1.0.tar.bz2">(bzip2'd source, 762KB)</a> @@ -49,7 +84,4 @@ -<h3>Older Development Release</h3> - -None available. --- devel-home/valgrind/news.html #1.2:1.3 @@ -5,4 +5,7 @@ ?> +<p class="news">March 12, 2004: A new unstable release, +<a href="downloads.html">valgrind 2.1.1</a>, is available. + <p class="news">March 04, 2004: An experimental PowerPC port is available. See <a href="related.html">Related Projects</a>. @@ -18,7 +21,4 @@ (<a href="http://builder.com.com/5100-6375-5136747.html">interview</a>). -<p class="news">December 14, 2003: A new unstable release, -<a href="downloads.html">valgrind 2.1.0</a>, is available. - <p class="news">November 11, 2003: A new stable release, <a href="downloads.html">valgrind 2.0.0</a>, is available. |