This is the mail archive of the
gdb-prs@sources.redhat.com
mailing list for the GDB project.
gdb/738: [rfa] lin-lwp.c change to avoid obscure hanging
- From: ac131313 at redhat dot com
- To: gdb-gnats at sources dot redhat dot com
- Cc: Hilfinger at otisco dot mckusick dot com
- Date: 27 Sep 2002 17:51:48 -0000
- Subject: gdb/738: [rfa] lin-lwp.c change to avoid obscure hanging
- Reply-to: ac131313 at redhat dot com
>Number: 738
>Category: gdb
>Synopsis: [rfa] lin-lwp.c change to avoid obscure hanging
>Confidential: no
>Severity: serious
>Priority: medium
>Responsible: unassigned
>State: open
>Class: sw-bug
>Submitter-Id: net
>Arrival-Date: Fri Sep 27 10:58:01 PDT 2002
>Closed-Date:
>Last-Modified:
>Originator: ac131313@redhat.com
>Release: unknown-1.0
>Organization:
>Environment:
>Description:
Under certain obscure conditions, GDB will hang when continuing a program
that uses GNU/Linux LWPs. For example, one set of circumstances that
were uncovered in an Ada program were:
1. A breakpoint is tripped over in thread A.
2. When all threads are stopped, it turns out that thread B != A has received
a signal (specifically SIG32, which is apparently used by the thread
package). This signal, furthermore, is "not of interest" to GDB
(as if according to 'set handle SIG32 pass noprint nostop').
A and B here stand for integer literals, of course.
3. The user executes the commands
delete
thread B
continue
I am uncertain as to the proper fix is for this, but I have provided
one possibility below (that works for us). The long ugly comment
will, I hope, prompt the more experienced among you to resolve the
outstanding questions.
Paul Hilfinger
ACT, Inc.
2002-04-10 Paul N. Hilfinger <hilfingr@otisco.mckusick.com>
* lin-lwp.c (lin_lwp_resume): Pass unprocessed signals to the
selected lwp, if GDB is not interested in them, and no specific
signal is requested. Fixes regression (hanging) displayed by
9820-005__task_switch.
Index: gdb/lin-lwp.c
===================================================================
RCS file: /cvs/src/src/gdb/lin-lwp.c,v
retrieving revision 1.34
diff -u -p -r1.34 lin-lwp.c
--- gdb/lin-lwp.c 31 Mar 2002 15:10:38 -0000 1.34
+++ gdb/lin-lwp.c 13 Apr 2002 08:41:20 -0000
@@ -605,6 +605,32 @@ lin_lwp_resume (ptid_t ptid, int step, e
/* Mark this LWP as resumed. */
lp->resumed = 1;
+ if (WIFSTOPPED (lp->status))
+ {
+ enum target_signal stopsig
+ = target_signal_from_host (WSTOPSIG (lp->status));
+
+ /* If we have a signal GDB is not interested in, then
+ arrange to pass it to the process without comment. This
+ should be able to happen only when one changes threads
+ before continuing. To be conservative, we do this only
+ if signo is TARGET_SIGNAL_0.
+ FIXME: hilfinger/2002-04-10: But this means we can't
+ switch to this thread and clear its signal. We could try
+ simply not resuming when lp->status is non-zero, and
+ leave it to lin_lwp_wait to catch the unhandled signal,
+ but it will resume ONLY this thread (see Kettenis's FIXME
+ in lin_lwp_wait), and this is not always right. */
+
+ if (signo == TARGET_SIGNAL_0
+ && signal_stop_state (stopsig) == 0
+ && signal_print_state (stopsig) == 0
+ && signal_pass_state (stopsig) == 1)
+ {
+ signo = stopsig;
+ lp->status = 0;
+ }
+ }
/* If we have a pending wait status for this thread, there is no
point in resuming the process. */
if (lp->status)
>How-To-Repeat:
>Fix:
>Release-Note:
>Audit-Trail:
>Unformatted:
----gnatsweb-attachment----
Content-Type: message/rfc822; name="message.eml"
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="message.eml"
RnJvbSBnZGItcGF0Y2hlcy1vd25lckBzb3VyY2VzLnJlZGhhdC5jb20gIFNhdCBBcHIgMTMgMTc6
NDI6MzIgMjAwMgpYLU1vemlsbGEtU3RhdHVzOiAwMDAzClgtTW96aWxsYS1TdGF0dXMyOiAwMDAw
MDAwMApSZXR1cm4tUGF0aDogPGdkYi1wYXRjaGVzLW93bmVyQHNvdXJjZXMucmVkaGF0LmNvbT4K
RGVsaXZlcmVkLVRvOiBhYzEzMTMxM0Bsb2NhbGhvc3QucmVkaGF0LmNvbQpSZWNlaXZlZDogZnJv
bSBsb2NhbGhvc3QgKGxvY2FsaG9zdCBbMTI3LjAuMC4xXSkKCWJ5IGxvY2FsaG9zdC5yZWRoYXQu
Y29tIChQb3N0Zml4KSB3aXRoIEVTTVRQIGlkIEJGOEI0M0NERAoJZm9yIDxhYzEzMTMxM0Bsb2Nh
bGhvc3Q+OyBTYXQsIDEzIEFwciAyMDAyIDE3OjQyOjMxIC0wNDAwIChFRFQpClJlY2VpdmVkOiBm
cm9tIHBvcC5jeWdudXMuY29tCglieSBsb2NhbGhvc3Qgd2l0aCBJTUFQIChmZXRjaG1haWwtNS45
LjYpCglmb3IgYWMxMzEzMTNAbG9jYWxob3N0IChzaW5nbGUtZHJvcCk7IFNhdCwgMTMgQXByIDIw
MDIgMTc6NDI6MzEgLTA0MDAgKEVEVCkKUmVjZWl2ZWQ6IGZyb20gY3lnbnVzLW14LnNmYmF5LnJl
ZGhhdC5jb20gKGN5Z251cy1teC5zZmJheS5yZWRoYXQuY29tIFsxNzIuMTYuMjcuMTZdKQoJYnkg
cnVueW9uLmN5Z251cy5jb20gKDguOC43LWN5Z251cy84LjguNykgd2l0aCBFU01UUCBpZCBDQUEy
OTY5NwoJZm9yIDxhYzEzMTMxM0BydW55b24uc2ZiYXkucmVkaGF0LmNvbT47IFNhdCwgMTMgQXBy
IDIwMDIgMDI6MDU6NDAgLTA3MDAgKFBEVCkKUmVjZWl2ZWQ6IGZyb20gc291cmNlcy5yZWRoYXQu
Y29tIChzb3VyY2VzLnJlZGhhdC5jb20gWzIwOS4yNDkuMjkuNjddKQoJYnkgY3lnbnVzLW14LnNm
YmF5LnJlZGhhdC5jb20gKDguMTEuNi84LjExLjYpIHdpdGggU01UUCBpZCBnM0QxRFV3MTY4NjQK
CWZvciA8YWMxMzEzMTNAY3lnbnVzLmNvbT47IEZyaSwgMTIgQXByIDIwMDIgMTg6MTM6MzAgLTA3
MDAKUmVjZWl2ZWQ6IChxbWFpbCAyMTg2NyBpbnZva2VkIGJ5IGFsaWFzKTsgMTMgQXByIDIwMDIg
MDk6MDU6MzMgLTAwMDAKUmVjZWl2ZWQ6IChxbWFpbCAyMTg2MCBpbnZva2VkIGZyb20gbmV0d29y
ayk7IDEzIEFwciAyMDAyIDA5OjA1OjI4IC0wMDAwClJlY2VpdmVkOiBmcm9tIHVua25vd24gKEhF
TE8gb3Rpc2NvLk1jS3VzaWNrLkNPTSkgKDIwOS4zMS4yMzMuMTkwKQogIGJ5IHNvdXJjZXMucmVk
aGF0LmNvbSB3aXRoIFNNVFA7IDEzIEFwciAyMDAyIDA5OjA1OjI4IC0wMDAwClJlY2VpdmVkOiAo
ZnJvbSBoaWxmaW5nckBsb2NhbGhvc3QpCglieSBvdGlzY28uTWNLdXNpY2suQ09NICg4LjkuMy84
LjkuMykgaWQgQ0FBMTEyMDI7CglTYXQsIDEzIEFwciAyMDAyIDAyOjA1OjI4IC0wNzAwCk1haWxp
bmctTGlzdDogY29udGFjdCBnZGItcGF0Y2hlcy1oZWxwQHNvdXJjZXMucmVkaGF0LmNvbTsgcnVu
IGJ5IGV6bWxtClByZWNlZGVuY2U6IGJ1bGsKTGlzdC1VbnN1YnNjcmliZTogPG1haWx0bzpnZGIt
cGF0Y2hlcy11bnN1YnNjcmliZS1hYzEzMTMxMz1jeWdudXMuY29tQHNvdXJjZXMucmVkaGF0LmNv
bT4KTGlzdC1TdWJzY3JpYmU6IDxtYWlsdG86Z2RiLXBhdGNoZXMtc3Vic2NyaWJlQHNvdXJjZXMu
cmVkaGF0LmNvbT4KTGlzdC1BcmNoaXZlOiA8aHR0cDovL3NvdXJjZXMucmVkaGF0LmNvbS9tbC9n
ZGItcGF0Y2hlcy8+Ckxpc3QtUG9zdDogPG1haWx0bzpnZGItcGF0Y2hlc0Bzb3VyY2VzLnJlZGhh
dC5jb20+Ckxpc3QtSGVscDogPG1haWx0bzpnZGItcGF0Y2hlcy1oZWxwQHNvdXJjZXMucmVkaGF0
LmNvbT4sIDxodHRwOi8vc291cmNlcy5yZWRoYXQuY29tL21sLyNmYXFzPgpTZW5kZXI6IGdkYi1w
YXRjaGVzLW93bmVyQHNvdXJjZXMucmVkaGF0LmNvbQpEZWxpdmVyZWQtVG86IG1haWxpbmcgbGlz
dCBnZGItcGF0Y2hlc0Bzb3VyY2VzLnJlZGhhdC5jb20KRGF0ZTogU2F0LCAxMyBBcHIgMjAwMiAw
MjowNToyOCAtMDcwMApNZXNzYWdlLUlkOiA8MjAwMjA0MTMwOTA1LkNBQTExMjAyQG90aXNjby5N
Y0t1c2ljay5DT00+ClgtQXV0aGVudGljYXRpb24tV2FybmluZzogbG9jYWxob3N0LmxvY2FsZG9t
YWluOiBoaWxmaW5nciBzZXQgc2VuZGVyIHRvIGhpbGZpbmdyQG90aXNjby5tY2t1c2ljay5jb20g
dXNpbmcgLWYKRnJvbTogIlBhdWwgTi4gSGlsZmluZ2VyIiA8aGlsZmluZ3JAb3Rpc2NvLm1ja3Vz
aWNrLmNvbT4KVG86IGdkYi1wYXRjaGVzQHNvdXJjZXMucmVkaGF0LmNvbQpTdWJqZWN0OiBbUkZB
XSBsaW4tbHdwLmMgY2hhbmdlIHRvIGF2b2lkIG9ic2N1cmUgaGFuZ2luZwpSZXBseS1UbzogSGls
ZmluZ2VyQG90aXNjby5tY2t1c2ljay5jb20KUmVmZXJlbmNlczogIDwyMDAyMDQxMjE5MzEuZzND
SlZhZTEyMDY4QHJlZGR3YXJmLnNmYmF5LnJlZGhhdC5jb20+CkNvbnRlbnQtVHlwZTogdGV4dApD
b250ZW50LUxlbmd0aDogMjc1NgoKClVuZGVyIGNlcnRhaW4gb2JzY3VyZSBjb25kaXRpb25zLCBH
REIgd2lsbCBoYW5nIHdoZW4gY29udGludWluZyBhIHByb2dyYW0KdGhhdCB1c2VzIEdOVS9MaW51
eCBMV1BzLiAgRm9yIGV4YW1wbGUsIG9uZSBzZXQgb2YgY2lyY3Vtc3RhbmNlcyB0aGF0CndlcmUg
dW5jb3ZlcmVkIGluIGFuIEFkYSBwcm9ncmFtIHdlcmU6CgoxLiBBIGJyZWFrcG9pbnQgaXMgdHJp
cHBlZCBvdmVyIGluIHRocmVhZCBBLgoKMi4gV2hlbiBhbGwgdGhyZWFkcyBhcmUgc3RvcHBlZCwg
aXQgdHVybnMgb3V0IHRoYXQgdGhyZWFkIEIgIT0gQSBoYXMgcmVjZWl2ZWQKICAgYSBzaWduYWwg
KHNwZWNpZmljYWxseSBTSUczMiwgd2hpY2ggaXMgYXBwYXJlbnRseSB1c2VkIGJ5IHRoZSB0aHJl
YWQKICAgcGFja2FnZSkuICBUaGlzIHNpZ25hbCwgZnVydGhlcm1vcmUsIGlzICJub3Qgb2YgaW50
ZXJlc3QiIHRvIEdEQgogICAoYXMgaWYgYWNjb3JkaW5nIHRvICdzZXQgaGFuZGxlIFNJRzMyIHBh
c3Mgbm9wcmludCBub3N0b3AnKS4KICAgQSBhbmQgQiBoZXJlIHN0YW5kIGZvciBpbnRlZ2VyIGxp
dGVyYWxzLCBvZiBjb3Vyc2UuCgozLiBUaGUgdXNlciBleGVjdXRlcyB0aGUgY29tbWFuZHMKICAg
ICBkZWxldGUKICAgICB0aHJlYWQgQgogICAgIGNvbnRpbnVlICAgICAKCkkgYW0gdW5jZXJ0YWlu
IGFzIHRvIHRoZSBwcm9wZXIgZml4IGlzIGZvciB0aGlzLCBidXQgSSBoYXZlIHByb3ZpZGVkCm9u
ZSBwb3NzaWJpbGl0eSBiZWxvdyAodGhhdCB3b3JrcyBmb3IgdXMpLiAgVGhlIGxvbmcgdWdseSBj
b21tZW50CndpbGwsIEkgaG9wZSwgcHJvbXB0IHRoZSBtb3JlIGV4cGVyaWVuY2VkIGFtb25nIHlv
dSB0byByZXNvbHZlIHRoZQpvdXRzdGFuZGluZyBxdWVzdGlvbnMuCgpQYXVsIEhpbGZpbmdlcgpB
Q1QsIEluYy4KCgoKMjAwMi0wNC0xMCAgUGF1bCBOLiBIaWxmaW5nZXIgIDxoaWxmaW5nckBvdGlz
Y28ubWNrdXNpY2suY29tPgoKCSogbGluLWx3cC5jIChsaW5fbHdwX3Jlc3VtZSk6IFBhc3MgdW5w
cm9jZXNzZWQgc2lnbmFscyB0byB0aGUgCglzZWxlY3RlZCBsd3AsIGlmIEdEQiBpcyBub3QgaW50
ZXJlc3RlZCBpbiB0aGVtLCBhbmQgbm8gc3BlY2lmaWMKCXNpZ25hbCBpcyByZXF1ZXN0ZWQuICBG
aXhlcyByZWdyZXNzaW9uIChoYW5naW5nKSBkaXNwbGF5ZWQgYnkgCgk5ODIwLTAwNV9fdGFza19z
d2l0Y2guCgoKSW5kZXg6IGdkYi9saW4tbHdwLmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09
PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQpSQ1MgZmlsZTogL2N2cy9z
cmMvc3JjL2dkYi9saW4tbHdwLmMsdgpyZXRyaWV2aW5nIHJldmlzaW9uIDEuMzQKZGlmZiAtdSAt
cCAtcjEuMzQgbGluLWx3cC5jCi0tLSBnZGIvbGluLWx3cC5jCTMxIE1hciAyMDAyIDE1OjEwOjM4
IC0wMDAwCTEuMzQKKysrIGdkYi9saW4tbHdwLmMJMTMgQXByIDIwMDIgMDg6NDE6MjAgLTAwMDAK
QEAgLTYwNSw2ICs2MDUsMzIgQEAgbGluX2x3cF9yZXN1bWUgKHB0aWRfdCBwdGlkLCBpbnQgc3Rl
cCwgZQogICAgICAgLyogTWFyayB0aGlzIExXUCBhcyByZXN1bWVkLiAgKi8KICAgICAgIGxwLT5y
ZXN1bWVkID0gMTsKIAorICAgICAgaWYgKFdJRlNUT1BQRUQgKGxwLT5zdGF0dXMpKQorCXsKKwkg
IGVudW0gdGFyZ2V0X3NpZ25hbCBzdG9wc2lnIAorCSAgICA9IHRhcmdldF9zaWduYWxfZnJvbV9o
b3N0IChXU1RPUFNJRyAobHAtPnN0YXR1cykpOworCisJICAvKiBJZiB3ZSBoYXZlIGEgc2lnbmFs
IEdEQiBpcyBub3QgaW50ZXJlc3RlZCBpbiwgdGhlbgorCSAgICAgYXJyYW5nZSB0byBwYXNzIGl0
IHRvIHRoZSBwcm9jZXNzIHdpdGhvdXQgY29tbWVudC4gIFRoaXMKKwkgICAgIHNob3VsZCBiZSBh
YmxlIHRvIGhhcHBlbiBvbmx5IHdoZW4gb25lIGNoYW5nZXMgdGhyZWFkcyAKKwkgICAgIGJlZm9y
ZSBjb250aW51aW5nLiAgVG8gYmUgY29uc2VydmF0aXZlLCB3ZSBkbyB0aGlzIG9ubHkKKwkgICAg
IGlmIHNpZ25vIGlzIFRBUkdFVF9TSUdOQUxfMC4gIAorCSAgICAgRklYTUU6IGhpbGZpbmdlci8y
MDAyLTA0LTEwOiBCdXQgdGhpcyBtZWFucyB3ZSBjYW4ndAorCSAgICAgc3dpdGNoIHRvIHRoaXMg
dGhyZWFkIGFuZCBjbGVhciBpdHMgc2lnbmFsLiAgV2UgY291bGQgdHJ5CisJICAgICBzaW1wbHkg
bm90IHJlc3VtaW5nIHdoZW4gbHAtPnN0YXR1cyBpcyBub24temVybywgYW5kCisJICAgICBsZWF2
ZSBpdCB0byBsaW5fbHdwX3dhaXQgdG8gY2F0Y2ggdGhlIHVuaGFuZGxlZCBzaWduYWwsCisJICAg
ICBidXQgaXQgd2lsbCByZXN1bWUgT05MWSB0aGlzIHRocmVhZCAoc2VlIEtldHRlbmlzJ3MgRklY
TUUKKwkgICAgIGluIGxpbl9sd3Bfd2FpdCksIGFuZCB0aGlzIGlzIG5vdCBhbHdheXMgcmlnaHQu
ICovCisKKwkgIGlmIChzaWdubyA9PSBUQVJHRVRfU0lHTkFMXzAgCisJICAgICAgJiYgc2lnbmFs
X3N0b3Bfc3RhdGUgKHN0b3BzaWcpID09IDAKKwkgICAgICAmJiBzaWduYWxfcHJpbnRfc3RhdGUg
KHN0b3BzaWcpID09IDAKKwkgICAgICAmJiBzaWduYWxfcGFzc19zdGF0ZSAoc3RvcHNpZykgPT0g
MSkKKwkgICAgeworCSAgICAgIHNpZ25vID0gc3RvcHNpZzsKKwkgICAgICBscC0+c3RhdHVzID0g
MDsKKwkgICAgfQorCX0KICAgICAgIC8qIElmIHdlIGhhdmUgYSBwZW5kaW5nIHdhaXQgc3RhdHVz
IGZvciB0aGlzIHRocmVhZCwgdGhlcmUgaXMgbm8KICAgICAgICAgIHBvaW50IGluIHJlc3VtaW5n
IHRoZSBwcm9jZXNzLiAgKi8KICAgICAgIGlmIChscC0+c3RhdHVzKQoK