From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 18578 invoked by alias); 7 Dec 2005 18:32:44 -0000 Received: (qmail 18567 invoked by uid 22791); 7 Dec 2005 18:32:43 -0000 X-Spam-Status: No, hits=-2.5 required=5.0 tests=AWL,BAYES_00,FORGED_RCVD_HELO,UPPERCASE_25_50 X-Spam-Check-By: sourceware.org Received: from mx1.redhat.com (HELO mx1.redhat.com) (66.187.233.31) by sourceware.org (qpsmtpd/0.31) with ESMTP; Wed, 07 Dec 2005 18:32:41 +0000 Received: from int-mx1.corp.redhat.com (int-mx1.corp.redhat.com [172.16.52.254]) by mx1.redhat.com (8.12.11/8.12.11) with ESMTP id jB7IWeoE027002 for ; Wed, 7 Dec 2005 13:32:40 -0500 Received: from pobox.corp.redhat.com (pobox.corp.redhat.com [172.16.52.156]) by int-mx1.corp.redhat.com (8.11.6/8.11.6) with ESMTP id jB7IWdV25995 for ; Wed, 7 Dec 2005 13:32:39 -0500 Received: from localhost.localdomain (vpn50-83.rdu.redhat.com [172.16.50.83]) by pobox.corp.redhat.com (8.12.8/8.12.8) with ESMTP id jB7IWdUQ021390 for ; Wed, 7 Dec 2005 13:32:39 -0500 Received: from ironwood.lan (ironwood.lan [192.168.64.8]) by localhost.localdomain (8.12.11/8.12.10) with ESMTP id jB7IWYUv005182 for ; Wed, 7 Dec 2005 11:32:34 -0700 Date: Wed, 07 Dec 2005 18:32:00 -0000 From: Kevin Buettner To: rda@sources.redhat.com Subject: [commit] Use __SIGRTMIN and __SIGRTMAX when mapping signals Message-ID: <20051207113232.5e541b93@ironwood.lan> Organization: Red Hat X-Mailer: Sylpheed-Claws 0.9.12cvs173.1 (GTK+ 2.4.14; i386-redhat-linux-gnu) Mime-Version: 1.0 Content-Type: text/plain; charset=US-ASCII Content-Transfer-Encoding: 7bit X-IsSubscribed: yes Mailing-List: contact rda-help@sourceware.org; run by ezmlm Precedence: bulk List-Subscribe: List-Post: List-Help: , Sender: rda-owner@sourceware.org X-SW-Source: 2005-q4/txt/msg00011.txt.bz2 I've just committed the patch below. RDA maps target specific signal numbers to signal numbers which GDB uses. Until now, RDA was using SIGRTMIN and SIGRTMAX for computing part of this mapping. On a GNU(ish) system, these macros are defined to call functions which compute the actual minimum and maximum realtime signal numbers. In particular, this computation will exclude any signals used by the C library for its own purposes. These signals could include signals related to thread debugging or, more importantly, for thread cancellation. If these signals are ignored by the mapping computation, then they will be sent to GDB as signal 0. This is not only uninformative, but it also makes it impossible to continue the program with the desired signal. The patch below makes RDA use __SIGRTMIN and __SIGRTMAX for the signal mapping computations instead. These constants represent a hard minumum and maximum. * ptrace-target.c (ptrace_compute_signal, ptrace_process_signal): Use __SIGRTMIN in place of SIGRTMIN. Use __SIGRTMAX in place of SIGRTMAX. (ptrace_compute_signal): Consolidate logic which computes return value. Index: ptrace-target.c =================================================================== RCS file: /cvs/src/src/rda/unix/ptrace-target.c,v retrieving revision 1.12 diff -u -p -r1.12 ptrace-target.c --- ptrace-target.c 7 Dec 2005 17:51:48 -0000 1.12 +++ ptrace-target.c 7 Dec 2005 18:11:20 -0000 @@ -665,13 +665,9 @@ ptrace_compute_signal (struct gdbserv *s if (tgtsig == SIGPWR) return GDBSERV_SIGPWR; #endif -#if defined (SIGRTMIN) && defined (SIGRTMAX) - if (tgtsig == SIGRTMIN) - return GDBSERV_SIGRT32; - if (tgtsig == SIGRTMIN + 32) - return GDBSERV_SIGRT64; - if (tgtsig > SIGRTMIN && tgtsig < SIGRTMAX) - return GDBSERV_SIGRT33 + tgtsig - 1; +#if defined (__SIGRTMIN) && defined (__SIGRTMAX) + if (tgtsig >= __SIGRTMIN && tgtsig < __SIGRTMAX) + return GDBSERV_SIGRT32 + tgtsig - __SIGRTMIN; return GDBSERV_SIGNONE; /* ? */ #endif } @@ -915,73 +911,73 @@ ptrace_process_signal (struct gdbserv *s case GDBSERV_SIGPRIO: process->signal_to_send = SIGPRIO; break; #endif -#if defined (SIGRTMIN) && defined (SIGRTMAX) +#if defined (__SIGRTMIN) && defined (__SIGRTMAX) case GDBSERV_SIGRT32: - process->signal_to_send = SIGRTMIN; break; + process->signal_to_send = __SIGRTMIN; break; case GDBSERV_SIGRT33: - process->signal_to_send = SIGRTMIN+1; break; + process->signal_to_send = __SIGRTMIN+1; break; case GDBSERV_SIGRT34: - process->signal_to_send = SIGRTMIN+2; break; + process->signal_to_send = __SIGRTMIN+2; break; case GDBSERV_SIGRT35: - process->signal_to_send = SIGRTMIN+3; break; + process->signal_to_send = __SIGRTMIN+3; break; case GDBSERV_SIGRT36: - process->signal_to_send = SIGRTMIN+4; break; + process->signal_to_send = __SIGRTMIN+4; break; case GDBSERV_SIGRT37: - process->signal_to_send = SIGRTMIN+5; break; + process->signal_to_send = __SIGRTMIN+5; break; case GDBSERV_SIGRT38: - process->signal_to_send = SIGRTMIN+6; break; + process->signal_to_send = __SIGRTMIN+6; break; case GDBSERV_SIGRT39: - process->signal_to_send = SIGRTMIN+7; break; + process->signal_to_send = __SIGRTMIN+7; break; case GDBSERV_SIGRT40: - process->signal_to_send = SIGRTMIN+8; break; + process->signal_to_send = __SIGRTMIN+8; break; case GDBSERV_SIGRT41: - process->signal_to_send = SIGRTMIN+9; break; + process->signal_to_send = __SIGRTMIN+9; break; case GDBSERV_SIGRT42: - process->signal_to_send = SIGRTMIN+10; break; + process->signal_to_send = __SIGRTMIN+10; break; case GDBSERV_SIGRT43: - process->signal_to_send = SIGRTMIN+11; break; + process->signal_to_send = __SIGRTMIN+11; break; case GDBSERV_SIGRT44: - process->signal_to_send = SIGRTMIN+12; break; + process->signal_to_send = __SIGRTMIN+12; break; case GDBSERV_SIGRT45: - process->signal_to_send = SIGRTMIN+13; break; + process->signal_to_send = __SIGRTMIN+13; break; case GDBSERV_SIGRT46: - process->signal_to_send = SIGRTMIN+14; break; + process->signal_to_send = __SIGRTMIN+14; break; case GDBSERV_SIGRT47: - process->signal_to_send = SIGRTMIN+15; break; + process->signal_to_send = __SIGRTMIN+15; break; case GDBSERV_SIGRT48: - process->signal_to_send = SIGRTMIN+16; break; + process->signal_to_send = __SIGRTMIN+16; break; case GDBSERV_SIGRT49: - process->signal_to_send = SIGRTMIN+17; break; + process->signal_to_send = __SIGRTMIN+17; break; case GDBSERV_SIGRT50: - process->signal_to_send = SIGRTMIN+18; break; + process->signal_to_send = __SIGRTMIN+18; break; case GDBSERV_SIGRT51: - process->signal_to_send = SIGRTMIN+19; break; + process->signal_to_send = __SIGRTMIN+19; break; case GDBSERV_SIGRT52: - process->signal_to_send = SIGRTMIN+20; break; + process->signal_to_send = __SIGRTMIN+20; break; case GDBSERV_SIGRT53: - process->signal_to_send = SIGRTMIN+21; break; + process->signal_to_send = __SIGRTMIN+21; break; case GDBSERV_SIGRT54: - process->signal_to_send = SIGRTMIN+22; break; + process->signal_to_send = __SIGRTMIN+22; break; case GDBSERV_SIGRT55: - process->signal_to_send = SIGRTMIN+23; break; + process->signal_to_send = __SIGRTMIN+23; break; case GDBSERV_SIGRT56: - process->signal_to_send = SIGRTMIN+24; break; + process->signal_to_send = __SIGRTMIN+24; break; case GDBSERV_SIGRT57: - process->signal_to_send = SIGRTMIN+25; break; + process->signal_to_send = __SIGRTMIN+25; break; case GDBSERV_SIGRT58: - process->signal_to_send = SIGRTMIN+26; break; + process->signal_to_send = __SIGRTMIN+26; break; case GDBSERV_SIGRT59: - process->signal_to_send = SIGRTMIN+27; break; + process->signal_to_send = __SIGRTMIN+27; break; case GDBSERV_SIGRT60: - process->signal_to_send = SIGRTMIN+28; break; + process->signal_to_send = __SIGRTMIN+28; break; case GDBSERV_SIGRT61: - process->signal_to_send = SIGRTMIN+29; break; + process->signal_to_send = __SIGRTMIN+29; break; case GDBSERV_SIGRT62: - process->signal_to_send = SIGRTMIN+30; break; + process->signal_to_send = __SIGRTMIN+30; break; case GDBSERV_SIGRT63: - process->signal_to_send = SIGRTMIN+31; break; + process->signal_to_send = __SIGRTMIN+31; break; case GDBSERV_SIGRT64: - process->signal_to_send = SIGRTMIN+32; break; + process->signal_to_send = __SIGRTMIN+32; break; #endif } /* Since we will handle the signal, we don't want gdbserv