Mercurial > ecos
annotate packages/hal/common/current/src/thread-packets.c @ 208:e0c0827131d1 ecos
Merge from eCos master repository on 2002-05-20-20:11:54-BST
| author | jlarmour |
|---|---|
| date | Mon, 20 May 2002 22:19:26 +0000 |
| parents | 678094f34118 |
| children | d2c90368aeef |
| rev | line source |
|---|---|
|
64
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
46
diff
changeset
|
1 //======================================================================== |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
46
diff
changeset
|
2 // |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
46
diff
changeset
|
3 // thread-packets.c |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
46
diff
changeset
|
4 // |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
46
diff
changeset
|
5 // Provides multi-threaded debug support |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
46
diff
changeset
|
6 // |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
46
diff
changeset
|
7 //======================================================================== |
|
208
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
8 //####ECOSGPLCOPYRIGHTBEGIN#### |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
9 // ------------------------------------------- |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
10 // This file is part of eCos, the Embedded Configurable Operating System. |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
11 // Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
12 // |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
13 // eCos is free software; you can redistribute it and/or modify it under |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
14 // the terms of the GNU General Public License as published by the Free |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
15 // Software Foundation; either version 2 or (at your option) any later version. |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
16 // |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
17 // eCos is distributed in the hope that it will be useful, but WITHOUT ANY |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
18 // WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
19 // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
20 // for more details. |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
21 // |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
22 // You should have received a copy of the GNU General Public License along |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
23 // with eCos; if not, write to the Free Software Foundation, Inc., |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
24 // 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
25 // |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
26 // As a special exception, if other files instantiate templates or use macros |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
27 // or inline functions from this file, or you compile this file and link it |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
28 // with other works to produce a work based on this file, this file does not |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
29 // by itself cause the resulting work to be covered by the GNU General Public |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
30 // License. However the source code for this file must still be made available |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
31 // in accordance with section (3) of the GNU General Public License. |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
32 // |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
33 // This exception does not invalidate any other reasons why a work based on |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
34 // this file might be covered by the GNU General Public License. |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
35 // |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
36 // Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
37 // at http://sources.redhat.com/ecos/ecos-license |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
38 // ------------------------------------------- |
|
e0c0827131d1
Merge from eCos master repository on 2002-05-20-20:11:54-BST
jlarmour
parents:
191
diff
changeset
|
39 //####ECOSGPLCOPYRIGHTEND#### |
|
64
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
46
diff
changeset
|
40 //======================================================================== |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
46
diff
changeset
|
41 //#####DESCRIPTIONBEGIN#### |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
46
diff
changeset
|
42 // |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
46
diff
changeset
|
43 // Author(s): Red Hat, nickg |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
46
diff
changeset
|
44 // Contributors: Red Hat, nickg |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
46
diff
changeset
|
45 // Date: 1998-08-25 |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
46
diff
changeset
|
46 // Purpose: |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
46
diff
changeset
|
47 // Description: Provides multi-threaded debug support |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
46
diff
changeset
|
48 // Usage: |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
46
diff
changeset
|
49 // |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
46
diff
changeset
|
50 //####DESCRIPTIONEND#### |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
46
diff
changeset
|
51 // |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
46
diff
changeset
|
52 //======================================================================== |
|
c38311975d4f
Merge from eCos master repository on 2000-01-28-04:28:11-GMT
jlarmour
parents:
46
diff
changeset
|
53 |
| 2 | 54 // Define __ECOS__; allows all eCos specific additions to be easily identified. |
| 55 #define __ECOS__ | |
| 0 | 56 |
| 57 | |
| 2 | 58 // #ifdef __ECOS__ |
| 0 | 59 #include <pkgconf/hal.h> |
| 60 | |
| 61 #if defined(CYGDBG_HAL_DEBUG_GDB_THREAD_SUPPORT) \ | |
| 62 && defined(CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS) | |
| 2 | 63 // #endif // __ECOS__ |
| 0 | 64 |
| 65 /* FIXME: Scan this module for correct sizes of fields in packets */ | |
| 2 | 66 |
| 67 #ifdef __ECOS__ | |
| 68 #include <cyg/hal/dbg-threads-api.h> | |
| 69 #else // __ECOS__ | |
| 70 #include "dbg-threads-api.h" | |
| 71 #endif // __ECOS__ | |
| 0 | 72 |
| 73 /* This file should ALWAYS define debug thread support */ | |
| 74 /* Dont include the object in the link if you dont need the support */ | |
| 75 /* This is NOT the internal unit debug flag, it is a feature control */ | |
| 76 #if defined(DEBUG_THREADS) | |
| 77 #undef DEBUG_THREADS | |
| 78 #endif | |
| 79 | |
| 2 | 80 #define DEBUG_THREADS 1 |
| 81 #define UNIT_TEST 0 | |
| 82 #define GDB_MOCKUP 0 | |
| 0 | 83 |
| 84 | |
| 85 #define STUB_BUF_MAX 300 /* for range checking of packet lengths */ | |
| 86 | |
| 87 #include "thread-pkts.h" | |
| 88 | |
| 2 | 89 #ifdef __ECOS__ |
| 0 | 90 // Use HAL rather than board.h in eCos |
| 91 #include <cyg/hal/hal_stub.h> | |
| 2 | 92 #else // __ECOS__ |
| 93 #include "board.h" | |
| 94 #endif // __ECOS__ | |
| 95 | |
| 96 /* | |
| 97 * Export the continue and "general" (context) thread IDs from GDB. | |
| 98 */ | |
| 99 int _gdb_cont_thread ; | |
| 100 int _gdb_general_thread ; | |
| 0 | 101 |
| 102 #if !defined(PKT_DEBUG) | |
| 103 #define PKT_DEBUG 0 | |
| 104 #endif | |
| 105 extern void output_string(char * message) ; | |
| 106 | |
| 107 #if PKT_DEBUG | |
| 108 void output_threadid(char * title,threadref * ref) ; | |
| 109 #warning "PKT_DEBUG macros engaged" | |
| 110 #define PKT_TRACE(title,packet) \ | |
| 111 { output_string(title) ; output_string(packet) ; output_string("\n") ;} | |
| 112 #else | |
| 113 #define PKT_TRACE(title,packet) {} | |
| 114 #endif | |
| 115 | |
| 116 | |
| 117 /* This is going to be irregular because the various implementations | |
| 118 have adopted different names for registers. | |
| 119 It would be nice to fix them to have a common convention | |
| 120 _stub_registers | |
| 121 stub_registers | |
| 122 alt_stub_registers | |
| 123 */ | |
| 124 | |
| 125 extern target_register_t * _registers ; | |
| 126 /* A pointer to the current set of registers */ | |
|
191
678094f34118
Merge from eCos master repository on 2001-10-19-06:43:02-BST
jlarmour
parents:
76
diff
changeset
|
127 extern target_register_t registers[]; /* The current saved registers */ |
|
678094f34118
Merge from eCos master repository on 2001-10-19-06:43:02-BST
jlarmour
parents:
76
diff
changeset
|
128 extern target_register_t alt_registers[] ; |
| 0 | 129 /* Thread or saved process state */ |
| 130 | |
| 131 | |
| 2 | 132 static void stub_copy_registers( |
| 133 target_register_t * dest, | |
| 134 target_register_t *src | |
| 135 ) | |
| 0 | 136 { |
| 137 target_register_t * limit ; | |
| 138 limit = dest + NUMREGS ; | |
| 139 | |
| 140 while (dest < limit) *dest++ = *src++ ; | |
| 141 } | |
| 142 | |
| 2 | 143 #ifdef __ECOS__ |
| 144 void __stub_copy_registers(target_register_t * dest, | |
| 145 target_register_t *src) | |
| 146 { | |
| 147 stub_copy_registers(dest, src); | |
| 148 } | |
| 149 #endif // __ECOS__ | |
| 150 | |
| 0 | 151 extern int stubhex(char ch) ; |
| 152 | |
| 153 /* ----- STUB_PACK_NAK ----------------------------------- */ | |
| 154 /* Pack an error response into the response packet */ | |
| 155 | |
| 156 char * stub_pack_nak(char * outbuf) | |
| 157 { | |
| 158 *outbuf++ = 'E' ; | |
| 159 *outbuf++ = '0' ; | |
| 160 *outbuf++ = '2' ; | |
| 161 return outbuf ; | |
| 162 } /* stub_pack_nak */ | |
| 163 | |
| 164 /* ----- STUB_PACK_ACK -------------------------- */ | |
| 165 /* Pack an OK achnowledgement */ | |
| 166 char * stub_pack_ack(char * outbuf) | |
| 167 { | |
| 168 *outbuf++ = 'O' ; | |
| 169 *outbuf++ = 'K' ; | |
| 170 return outbuf ; | |
| 171 } /* stub_pack_ack */ | |
| 172 | |
| 173 /* ------- STUB_UNPACK_INT ------------------------------- */ | |
| 174 /* Unpack a few bytes and return its integer value */ | |
| 175 /* This is where I wish functions could return several values | |
| 176 I would also advance the buffer pointer */ | |
| 177 | |
| 178 int stub_unpack_int(char * buff,int fieldlength) | |
| 179 { | |
| 180 int retval = 0 ; | |
| 181 int nibble ; | |
| 182 while (fieldlength) | |
| 183 { nibble = stubhex(*buff++) ; | |
| 184 retval |= nibble ; | |
| 185 fieldlength-- ; | |
| 186 if (fieldlength) retval = retval << 4 ; | |
| 187 } | |
| 188 return retval ; | |
| 189 } /* stub_unpack_int */ | |
| 190 | |
| 191 static char * unpack_byte(char * buf, int * value) | |
| 192 { | |
| 193 *value = stub_unpack_int(buf,2) ; | |
| 194 return buf + 2 ; | |
| 195 } | |
| 196 | |
| 197 static char * unpack_int(char * buf, int * value) | |
| 198 { | |
| 199 *value = stub_unpack_int(buf,8) ; | |
| 200 return buf + 8 ; | |
| 201 } | |
| 202 | |
|
38
e7ba79f6d3a8
Merge from eCos master repository on 1999-09-23-20:10:25-BST
jlarmour
parents:
2
diff
changeset
|
203 /* We are NOT depending upon extensive libraries */ |
| 0 | 204 static int ishex(char ch,int *val) |
| 205 { | |
| 206 if ((ch >= 'a') && (ch <= 'f')) | |
| 207 { *val =ch - 'a' + 10 ; return 1 ; } | |
| 208 if ((ch >= 'A') && (ch <= 'F')) | |
| 209 { *val = ch - 'A' + 10 ; return 1 ;} | |
| 210 if ((ch >= '0') && (ch <= '9')) | |
| 211 { *val = ch - '0' ; return 1 ; } | |
| 212 return 0 ; | |
| 213 } /* ishex */ | |
| 214 | |
| 215 static char * unpack_nibble(char * buf,int * val) | |
| 216 { | |
| 217 ishex(*buf++,val) ; | |
| 218 return buf ; | |
| 219 } | |
| 220 | |
| 221 | |
| 222 static const char hexchars[] = "0123456789abcdef"; | |
| 223 | |
| 224 static char * pack_hex_byte(char * pkt, unsigned char byte) | |
| 225 { | |
| 226 *pkt++ = hexchars[(byte >> 4) & 0xf] ; | |
| 227 *pkt++ = hexchars[(byte & 0xf)] ; | |
| 228 return pkt ; | |
| 229 } /* pack_hex_byte */ | |
| 230 | |
| 2 | 231 #ifndef __ECOS__ |
| 0 | 232 /* ---- STUB_PACK_VARLEN_HEX ------------------------------------- */ |
| 233 /* Format a variable length stream of hex bytes */ | |
| 234 | |
| 235 static char * pack_varlen_hex( | |
| 2 | 236 char * pkt, |
| 237 unsigned int value) | |
| 0 | 238 { |
| 239 int i ; | |
| 240 static unsigned char n[8] ; | |
| 241 if (value == 0) | |
| 242 { | |
| 243 *pkt++ = '0' ; | |
| 244 return pkt ; | |
| 245 } | |
| 246 else | |
| 247 { | |
| 248 i = 8 ; | |
| 249 while (i-- >= 0 ) /* unpack nibbles into a char array */ | |
| 2 | 250 { |
| 251 n[i] = value & 0x0f ; | |
| 252 value = value >> 4 ; | |
| 253 } | |
|
38
e7ba79f6d3a8
Merge from eCos master repository on 1999-09-23-20:10:25-BST
jlarmour
parents:
2
diff
changeset
|
254 i = 0 ; /* we had decrmented it to -1 */ |
| 0 | 255 while (n[i] == 0 ) i++ ; /* drop leading zeroes */ |
| 256 while (i++ < 8) *pkt++ = hexchars[n[i]] ; /* pack the number */ | |
| 257 } | |
| 258 return pkt ; | |
| 259 } /* pack_varlen_hex */ | |
| 2 | 260 #endif // !__ECOS__ |
| 261 | |
| 0 | 262 |
| 263 /* ------ STUB_UNPACK_VARLEN_HEX -------------------------------- */ | |
| 264 /* Parse a stream of hex bytes which may be of variable length */ | |
| 265 /* return the pointer to the next char */ | |
| 266 /* modify a varparm containing the result */ | |
| 267 /* A failure would look like a non-increment of the buffer pointer */ | |
| 268 | |
| 269 /* This unpacks hex strings that may have been packed using sprintf(%x) */ | |
| 270 /* We assume some non-hex delimits them */ | |
| 271 | |
| 272 char * unpack_varlen_hex( | |
| 2 | 273 char * buff, /* packet to parse */ |
| 274 int * result) | |
| 0 | 275 { |
| 276 int nibble ; | |
| 277 int retval ; | |
| 278 retval = 0 ; | |
| 279 | |
| 280 while (ishex(*buff,&nibble)) | |
| 281 { | |
| 282 buff++ ; | |
| 283 retval = retval << 4 ; | |
| 284 retval |= nibble & 0x0f ; | |
| 285 } | |
| 286 *result = retval ; | |
| 287 return buff ; | |
| 288 } /* stub_unpack_varlen_int */ | |
| 289 | |
| 290 | |
| 291 /* ------ UNPACK_THREADID ------------------------------- */ | |
| 292 /* A threadid is a 64 bit quantity */ | |
| 293 | |
| 294 #define BUFTHREADIDSIZ 16 /* encode 64 bits in 16 chars of hex */ | |
| 295 | |
| 296 static char * unpack_threadid(char * inbuf, threadref * id) | |
| 297 { | |
| 298 char * altref ; | |
| 299 char * limit = inbuf + BUFTHREADIDSIZ ; | |
| 300 int x,y ; | |
| 301 altref = (char *) id ; | |
| 302 | |
| 303 while (inbuf < limit) | |
| 304 { | |
| 305 x = stubhex(*inbuf++) ; | |
| 306 y = stubhex(*inbuf++) ; | |
| 307 *altref++ = (x << 4) | y ; | |
| 308 } | |
| 309 return inbuf ; | |
| 310 } /* unpack_threadid */ | |
| 311 | |
| 312 | |
| 313 | |
| 314 /* Pack an integer use leading zeroes */ | |
| 315 static char * pack_int(char * buf,int value) | |
| 316 { | |
| 317 buf = pack_hex_byte(buf,(value>> 24)& 0xff) ; | |
| 318 buf = pack_hex_byte(buf,(value >>16)& 0xff) ; | |
| 319 buf = pack_hex_byte(buf,(value >>8) & 0x0ff) ; | |
| 320 buf = pack_hex_byte(buf,(value & 0xff)) ; | |
| 321 return buf ; | |
| 322 } /* pack_int */ | |
| 323 | |
| 324 | |
| 325 /* -------- PACK_STRING ---------------------------------------------- */ | |
| 326 /* This stupid string better not contain any funny characters */ | |
| 327 /* Also, the GDB protocol will not cope with NULLs in the | |
| 328 string or at the end of it. | |
| 329 While is is posable to encapsulate the protocol in ays that | |
| 330 preclude filtering for # I am assuming this is a constraint. | |
| 331 */ | |
| 332 | |
| 333 static char * pack_raw_string(char * pkt,char * string) | |
| 334 { | |
| 335 char ch ; | |
| 336 while (0 != (ch = *string++)) *pkt++ = ch ; | |
| 337 return pkt ; | |
| 338 } | |
| 339 | |
| 340 static char * pack_string( | |
| 2 | 341 char * pkt, |
| 342 char * string) | |
| 0 | 343 { |
| 344 char ch ; | |
| 2 | 345 #ifdef __ECOS__ |
| 0 | 346 int len = 0; |
| 347 char *s = string; | |
| 348 while( *s++ ) len++; | |
| 2 | 349 #else // __ECOS__ |
| 350 int len ; | |
| 351 len = strlen(string) ; | |
| 352 #endif // __ECOS | |
| 0 | 353 if (len > 200 ) len = 200 ; /* Bigger than most GDB packets, junk??? */ |
| 354 pkt = pack_hex_byte(pkt,len) ; | |
| 355 while (len-- > 0) | |
| 356 { | |
| 357 ch = *string++ ; | |
| 358 if ((ch == '\0') || (ch == '#')) ch = '*' ; /* Protect encapsulation */ | |
| 359 *pkt++ = ch ; | |
| 360 } | |
| 361 return pkt ; | |
| 362 } /* pack_string */ | |
| 363 | |
| 364 | |
| 365 /* ----- STUB_PACK_THREADID --------------------------------------------- */ | |
| 366 /* Convert a binary 64 bit threadid and pack it into a xmit buffer */ | |
| 367 /* Return the advanced buffer pointer */ | |
| 368 | |
| 369 static char * pack_threadid(char * pkt, threadref * id) | |
| 370 { | |
| 371 char * limit ; | |
| 372 unsigned char * altid ; | |
| 373 altid = (unsigned char *) id ; | |
| 374 limit = pkt + BUFTHREADIDSIZ ; | |
| 375 while (pkt < limit) pkt = pack_hex_byte(pkt,*altid++) ; | |
| 376 return pkt ; | |
| 377 } /* stub_pack_threadid */ | |
| 378 | |
|
38
e7ba79f6d3a8
Merge from eCos master repository on 1999-09-23-20:10:25-BST
jlarmour
parents:
2
diff
changeset
|
379 /* UNFORTUNATELY, not all of the extended debugging system has yet been |
|
e7ba79f6d3a8
Merge from eCos master repository on 1999-09-23-20:10:25-BST
jlarmour
parents:
2
diff
changeset
|
380 converted to 64 but thread references and process identifiers. |
| 0 | 381 These routines do the conversion. |
| 382 An array of bytes is the correct treatment of an opaque identifier. | |
| 383 ints have endian issues. | |
| 384 */ | |
| 385 | |
| 386 static void int_to_threadref(threadref * id, int value) | |
| 387 { | |
| 388 unsigned char * scan ; | |
| 389 scan = (unsigned char *) id ; | |
| 390 { | |
| 391 int i = 4 ; | |
| 392 while (i--) *scan++ = 0 ; | |
| 393 } | |
| 394 *scan++ = (value >> 24) & 0xff ; | |
| 395 *scan++ = (value >> 16) & 0xff ; | |
| 396 *scan++ = (value >> 8) & 0xff ; | |
| 397 *scan++ = (value & 0xff) ; | |
| 398 } | |
| 399 | |
| 400 static int threadref_to_int(threadref * ref) | |
| 401 { | |
| 402 int value = 0 ; | |
| 403 unsigned char * scan ; | |
| 404 int i ; | |
| 405 | |
| 406 scan = (char *) ref ; | |
| 407 scan += 4 ; | |
| 408 i = 4 ; | |
| 409 while (i-- > 0) value = (value << 8) | ((*scan++) & 0xff) ; | |
| 410 return value ; | |
| 411 } /* threadref_to_int */ | |
| 412 | |
| 413 void copy_threadref(threadref * dest, threadref * src) | |
| 414 { | |
| 415 int i ; | |
| 416 unsigned char * csrc, * cdest ; | |
| 417 csrc = (unsigned char *) src ; | |
| 418 cdest = (unsigned char *) dest ; | |
| 419 i = 8 ; | |
| 420 while (i--) *cdest++ = *csrc++ ; | |
| 421 } | |
| 422 | |
| 423 | |
| 424 int threadmatch( | |
| 2 | 425 threadref * dest , |
| 426 threadref * src | |
| 427 ) | |
| 0 | 428 { |
| 429 unsigned char * srcp, * destp ; | |
| 430 int i , result ; | |
| 431 srcp = (char *) src ; | |
| 432 destp = (char *) dest ; | |
| 433 i = 8 ; | |
| 434 result = 1 ; | |
| 435 while (i-- > 0 ) result &= (*srcp++ == *destp++) ? 1 : 0 ; | |
| 436 return result ; | |
| 2 | 437 } /* threadmatch */ |
| 0 | 438 |
| 439 | |
| 440 | |
| 441 static char * Tpkt_threadtag = "thread:" ; | |
| 442 | |
| 443 /* ----- STUB_PACK_TPKT_THREADID ------------------------------------ */ | |
| 444 /* retreive, tag and insert a thread identifier into a T packet. */ | |
| 445 /* Insert nothing if the thread identifier is not available */ | |
| 446 | |
| 447 char * stub_pack_Tpkt_threadid(char * pkt) | |
| 448 { | |
| 449 static threadref thread ; | |
| 450 int fmt = 0 ; /* old format */ | |
| 451 PKT_TRACE("Tpkt-id","---") ; | |
| 452 if (dbg_currthread(&thread)) | |
| 453 { | |
| 454 pkt = pack_raw_string(pkt,Tpkt_threadtag) ; | |
| 455 if (fmt) | |
| 2 | 456 pkt = pack_threadid(pkt,&thread) ; |
| 0 | 457 else |
| 2 | 458 /* Until GDB lengthens its thread ids, we have to MASH |
| 459 the threadid into somthing shorter. PLEASE FIX GDB */ | |
| 460 pkt = pack_int(pkt,threadref_to_int(&thread)) ; | |
| 0 | 461 *pkt++ = ';' ; /* terminate variable length int */ |
| 462 *pkt = '\0' ; /* Null terminate to allow string to be printed, no++ */ | |
| 463 } | |
| 464 PKT_TRACE("packedTpkt","--") ; | |
| 465 return pkt ; | |
| 466 } /* stub_pack_Tpkt_threadid */ | |
| 467 | |
| 2 | 468 long stub_get_currthread (void) |
| 469 { | |
| 470 threadref thread ; | |
| 471 | |
| 472 if (dbg_currthread(&thread)) | |
| 473 return threadref_to_int(&thread) ; | |
| 474 else | |
| 475 return 0 ; | |
| 476 } | |
| 0 | 477 |
| 478 void stub_pkt_currthread( | |
| 2 | 479 char * inbuf, |
| 480 char * outbuf, | |
| 481 int bufmax) | |
| 0 | 482 { |
| 483 threadref thread ; | |
| 484 char * base_out ; | |
| 485 base_out = outbuf ; | |
| 486 | |
| 487 if (dbg_currthread(&thread)) | |
| 488 { | |
| 2 | 489 *outbuf++ = 'Q' ; |
|
46
797268ecc331
Merge from eCos master repository on 1999-10-19-18:55:31-BST
jlarmour
parents:
38
diff
changeset
|
490 *outbuf++ = 'C' ; /* FIXME: Is this a reasonable code */ |
| 2 | 491 outbuf = pack_int(outbuf, threadref_to_int(&thread)) ; /* Short form */ |
| 0 | 492 } |
| 493 else outbuf = stub_pack_nak(outbuf) ; | |
| 494 *outbuf = '\0' ; /* terminate response packet */ | |
| 495 PKT_TRACE("stub_pkt_currthread(resp) ",base_out) ; | |
| 496 } /* stub_pkt_currthread */ | |
| 497 | |
| 498 /* ----- STUB_PKT_THREAD_ALIVE --------------------------------- */ | |
| 499 /* Answer the thread alive query */ | |
| 500 | |
| 2 | 501 static int thread_alive (int id) |
| 502 { | |
| 503 threadref thread ; | |
| 504 struct cygmon_thread_debug_info info ; | |
| 505 | |
| 506 int_to_threadref(&thread, id) ; | |
| 507 if (dbg_threadinfo(&thread, &info) && | |
| 508 info.context_exists) | |
| 509 return 1 ; | |
| 510 else | |
| 511 return 0 ; | |
| 512 } | |
| 513 | |
| 0 | 514 void stub_pkt_thread_alive(char * inbuf, |
| 2 | 515 char * outbuf, |
| 516 int bufmax) | |
| 0 | 517 { |
| 518 char * prebuf = inbuf ; | |
| 519 int result ; | |
| 520 | |
| 521 if (prebuf != (inbuf = unpack_varlen_hex(inbuf,&result))) | |
| 522 { | |
| 2 | 523 if (thread_alive(result)) |
| 524 { | |
| 525 outbuf = stub_pack_ack(outbuf) ; | |
| 526 *outbuf = '\0' ; | |
| 527 return ; | |
| 528 } | |
| 0 | 529 } |
| 530 outbuf = stub_pack_nak(outbuf) ; | |
| 531 *outbuf = '\0' ; /* terminate the response message */ | |
| 532 } /* stub_pkt_thread_alive */ | |
| 533 | |
| 534 | |
| 535 | |
| 536 /* ----- STUB_PKT_CHANGETHREAD ------------------------------- */ | |
| 537 /* Switch the display of registers to that of a saved context */ | |
| 538 | |
| 539 /* Changing the context makes NO sense, although the packets define the | |
| 540 capability. Therefore, the option to change the context back does | |
| 541 call the function to change registers. Also, there is no | |
| 542 forced context switch. | |
| 543 'p' - New format, long long threadid, no special cases | |
| 2 | 544 'c' - Old format, id for continue, 32 bit threadid max, possably less |
| 545 -1 means continue all threads | |
| 0 | 546 'g' - Old Format, id for general use (other than continue) |
| 547 | |
| 548 replies: | |
| 549 OK for success | |
| 2 | 550 ENN for error |
| 0 | 551 */ |
| 552 | |
| 553 void stub_pkt_changethread( | |
| 2 | 554 char * inbuf, |
| 555 char * outbuf, | |
| 556 int bufmax) | |
| 0 | 557 { |
| 558 threadref id ; | |
| 559 int idefined = -1 ; | |
| 560 char ch ; | |
| 561 PKT_TRACE("setthread-pkt ",inbuf) ; | |
| 562 | |
| 563 /* Parse the incoming packet for a thread identifier */ | |
| 564 switch (ch = *inbuf++ ) /* handle various packet formats */ | |
| 565 { | |
| 566 case 'p' : /* New format: mode:8,threadid:64 */ | |
| 567 inbuf = unpack_nibble(inbuf,&idefined) ; | |
| 568 inbuf = unpack_threadid(inbuf,&id) ; /* even if startflag */ | |
| 569 break ; | |
| 570 case 'c' : /* old format , specify thread for continue */ | |
| 2 | 571 if (inbuf[0] == '-' && inbuf[1] == '1') /* Hc-1 */ |
| 572 _gdb_cont_thread = 0 ; | |
| 573 else | |
| 574 inbuf = unpack_varlen_hex(inbuf, &_gdb_cont_thread) ; | |
| 575 | |
| 576 if (_gdb_cont_thread == 0 || /* revert to any old thread */ | |
| 577 thread_alive(_gdb_cont_thread)) /* specified thread is alive */ | |
| 578 outbuf = stub_pack_ack(outbuf) ; | |
| 579 else | |
| 580 outbuf = stub_pack_nak(outbuf) ; | |
| 581 break ; | |
| 0 | 582 case 'g' : /* old format, specify thread for general operations */ |
| 583 /* OLD format: parse a variable length hex string */ | |
| 584 /* OLD format consider special thread ids */ | |
| 585 { | |
| 2 | 586 inbuf = unpack_varlen_hex(inbuf, &_gdb_general_thread) ; |
| 587 int_to_threadref(&id, _gdb_general_thread) ; | |
| 588 switch (_gdb_general_thread) | |
| 589 { | |
| 590 case 0 : /* pick a thread, any thread */ | |
| 591 idefined = 2 ; /* select original interrupted context */ | |
| 592 break ; | |
| 593 case -1 : /* all threads */ | |
| 594 idefined = 2 ; | |
| 595 break ; | |
| 596 default : | |
| 597 idefined = 1 ; /* select the specified thread */ | |
| 598 break ; | |
| 599 } | |
| 0 | 600 } |
| 601 break ; | |
| 602 default: | |
| 603 outbuf = stub_pack_nak(outbuf) ; | |
| 604 break ; | |
| 605 } /* handle various packet formats */ | |
| 606 | |
| 607 switch (idefined) | |
| 608 { | |
| 609 case -1 : | |
| 610 /* Packet not supported, already NAKed, no further action */ | |
| 611 break ; | |
| 612 case 0 : | |
| 613 /* Switch back to interrupted context */ | |
| 614 _registers = ®isters[0] ; | |
| 615 break ; | |
| 616 case 1 : | |
| 617 /* copy the saved registers into the backup registers */ | |
| 2 | 618 stub_copy_registers(alt_registers,registers) ; |
| 0 | 619 /* The OS will now update the values it has in a saved process context*/ |
| 620 if (dbg_getthreadreg(&id,NUMREGS,&alt_registers[0])) | |
| 2 | 621 { |
| 622 /* switch the registers pointer */ | |
| 623 _registers = &alt_registers[0] ; | |
| 624 outbuf = stub_pack_ack(outbuf) ; | |
| 625 } | |
| 0 | 626 else |
| 2 | 627 outbuf = stub_pack_nak(outbuf) ; |
| 0 | 628 break ; |
| 2 | 629 case 2 : |
| 630 /* switch to interrupted context */ | |
| 631 outbuf = stub_pack_ack(outbuf) ; | |
| 632 break ; | |
| 0 | 633 default: |
| 634 outbuf = stub_pack_nak(outbuf) ; | |
| 635 break ; | |
| 636 } | |
| 637 *outbuf = '\0' ; /* Terminate response pkt */ | |
| 2 | 638 } /* stub_pkt_changethread */ |
| 0 | 639 |
| 640 | |
| 641 /* ---- STUB_PKT_GETTHREADLIST ------------------------------- */ | |
| 642 /* Get a portion of the threadlist or process list */ | |
| 643 /* This may be part of a multipacket transaction */ | |
| 644 /* It would be hard to tell in the response packet the difference | |
| 645 between the end of list and an error in threadid encoding. | |
| 646 */ | |
| 647 | |
| 648 void stub_pkt_getthreadlist(char * inbuf, | |
| 2 | 649 char * outbuf, |
| 650 int bufmax) | |
| 0 | 651 { |
| 652 char * count_ptr ; | |
| 653 char * done_ptr ; | |
| 654 char * limit ; | |
| 655 int start_flag , batchsize , result , count ; | |
| 656 static threadref lastthread, nextthread ; | |
| 657 | |
| 658 #if PKT_DEBUG | |
| 659 char * r_base = outbuf ; | |
| 660 #endif | |
| 661 PKT_TRACE("pkt_getthreadlist: ",inbuf) ; | |
| 662 | |
| 663 count = 0 ; | |
| 664 inbuf = unpack_nibble(inbuf,&start_flag) ; | |
| 665 inbuf = unpack_byte(inbuf,&batchsize) ; | |
| 666 inbuf = unpack_threadid(inbuf,&lastthread) ; /* even if startflag */ | |
| 667 | |
| 668 /* Start building response packet */ | |
| 669 limit = outbuf + (bufmax - BUFTHREADIDSIZ - 10) ; /* id output packing limit */ | |
| 670 *outbuf++ = 'Q' ; | |
| 671 *outbuf++ = 'M' ; | |
| 672 | |
| 673 /* Default values for count and done fields, save ptr to repatch */ | |
| 674 count_ptr = outbuf ; /* save to repatch count */ | |
| 675 outbuf = pack_hex_byte(outbuf,0) ; | |
| 676 done_ptr = outbuf ; /* Backpatched later */ | |
| 677 *outbuf++ = '0' ; /* Done = 0 by default */ | |
| 678 outbuf = pack_threadid(outbuf,&lastthread) ; | |
| 679 | |
| 680 /* Loop through the threadid packing */ | |
| 681 while ((outbuf < limit) && (count < batchsize)) | |
| 682 { | |
| 683 result = dbg_threadlist(start_flag,&lastthread,&nextthread) ; | |
|
76
435cced73e2f
eCos v1.3.1 merged from eCos master repository on 2000-03-27-23:22:51-BST
jlarmour
parents:
66
diff
changeset
|
684 start_flag = 0 ; /* redundant but effective */ |
| 0 | 685 if (!result) |
| 2 | 686 { *done_ptr = '1' ; /* pack the done flag */ |
| 687 break ; | |
| 688 } | |
| 0 | 689 #if 0 /* DEBUG */ |
| 690 if (threadmatch(&lastthread,&nextthread)) | |
| 2 | 691 { |
| 692 output_string("FAIL: Threadlist, not incrementing\n") ; | |
| 693 *done_ptr = '1' ; | |
| 694 break ; | |
| 695 } | |
| 0 | 696 #endif |
| 697 count++ ; | |
| 698 outbuf = pack_threadid(outbuf,&nextthread) ; | |
| 699 copy_threadref(&lastthread,&nextthread) ; | |
| 700 } | |
| 701 pack_hex_byte(count_ptr,count) ;/* backpatch, Pack the count field */ | |
| 702 *outbuf = '\0' ; | |
| 703 PKT_TRACE("pkt_getthreadlist(resp) ",r_base) ; | |
| 704 } /* pkt_getthreadlist */ | |
| 705 | |
| 706 | |
| 707 | |
| 708 | |
| 709 /* ----- STUB_PKT_GETTHREADINFO ---------------------------------------- */ | |
| 710 /* Get the detailed information about a specific thread or process */ | |
| 711 | |
| 712 /* | |
| 713 Encoding: | |
| 714 'Q':8,'P':8,mask:16 | |
| 715 | |
| 716 Mask Fields | |
| 2 | 717 threadid:1, # always request threadid |
| 718 context_exists:2, | |
| 719 display:4, | |
| 720 unique_name:8, | |
| 721 more_display:16 | |
| 0 | 722 */ |
| 723 | |
| 724 void stub_pkt_getthreadinfo( | |
| 2 | 725 char * inbuf, |
| 726 char * outbuf, | |
| 727 int bufmax) | |
| 0 | 728 { |
| 729 int mask ; | |
| 730 int result ; | |
| 731 threadref thread ; | |
| 732 struct cygmon_thread_debug_info info ; | |
| 733 | |
| 734 info.context_exists = 0 ; | |
| 735 info.thread_display = 0 ; | |
| 736 info.unique_thread_name = 0 ; | |
| 737 info.more_display = 0 ; | |
| 738 | |
| 739 /* Assume the packet identification chars have already been | |
| 740 discarded by the packet demultiples routines */ | |
| 741 PKT_TRACE("PKT getthreadinfo",inbuf) ; | |
| 742 | |
| 743 inbuf = unpack_int(inbuf,&mask) ; | |
| 744 inbuf = unpack_threadid(inbuf,&thread) ; | |
| 745 | |
| 746 result = dbg_threadinfo(&thread,&info) ; /* Make system call */ | |
| 747 | |
| 748 if (result) | |
| 749 { | |
| 750 *outbuf++ = 'q' ; | |
| 751 *outbuf++ = 'p' ; | |
| 752 outbuf = pack_int(outbuf,mask) ; | |
| 753 outbuf = pack_threadid(outbuf,&info.thread_id) ; /* echo threadid */ | |
| 754 if (mask & 2) /* context-exists */ | |
| 2 | 755 { |
| 756 outbuf = pack_int(outbuf,2) ; /* tag */ | |
| 757 outbuf = pack_hex_byte(outbuf,2) ; /* length */ | |
| 758 outbuf = pack_hex_byte(outbuf,info.context_exists) ; | |
| 759 } | |
| 0 | 760 if ((mask & 4) && info.thread_display)/* display */ |
| 2 | 761 { |
| 762 outbuf = pack_int(outbuf,4) ; /* tag */ | |
| 763 outbuf = pack_string(outbuf,info.thread_display) ; | |
| 764 } | |
| 0 | 765 if ((mask & 8) && info.unique_thread_name) /* unique_name */ |
| 2 | 766 { |
| 767 outbuf = pack_int(outbuf,8) ; | |
| 768 outbuf = pack_string(outbuf,info.unique_thread_name) ; | |
| 769 } | |
| 0 | 770 if ((mask & 16) && info.more_display) /* more display */ |
| 2 | 771 { |
| 772 outbuf = pack_int(outbuf,16) ; /* tag 16 */ | |
| 773 outbuf = pack_string(outbuf,info.more_display) ; | |
| 774 } | |
| 0 | 775 } |
| 776 else | |
| 777 { | |
| 778 PKT_TRACE("FAIL: dbg_threadinfo\n", "") ; | |
| 779 outbuf = stub_pack_nak(outbuf) ; | |
| 780 } | |
| 781 *outbuf = '\0' ; | |
| 782 } /* stub_pkt_getthreadinfo */ | |
| 783 | |
| 2 | 784 int stub_lock_scheduler(int lock, /* 0 to unlock, 1 to lock */ |
| 785 int mode, /* 0 for step, 1 for continue */ | |
| 786 long id) /* current thread */ | |
| 787 { | |
| 788 threadref thread; | |
| 0 | 789 |
| 2 | 790 int_to_threadref(&thread, id) ; |
| 791 return dbg_scheduler(&thread, lock, mode) ; | |
| 792 } | |
| 0 | 793 |
| 794 | |
| 795 #if GDB_MOCKUP | |
| 796 /* ------ MATCHED GDB SIDE PACKET ENCODING AND PARSING ----------------- */ | |
| 797 | |
| 798 char * pack_nibble(char * buf, int nibble) | |
| 799 { | |
| 800 *buf++ = hexchars[(nibble & 0x0f)] ; | |
| 801 return buf ; | |
| 802 } /* pack_nibble */ | |
| 803 | |
| 804 #if 0 | |
| 805 static char * unpack_short(char * buf,int * value) | |
| 806 { | |
| 807 *value = stub_unpack_int(buf,4) ; | |
| 808 return buf + 4 ; | |
| 809 } | |
| 810 | |
| 811 static char * pack_short( | |
| 2 | 812 char * buf, |
| 813 unsigned int value) | |
| 0 | 814 { |
| 815 buf = pack_hex_byte(buf,(value >> 8) & 0xff) ; | |
| 816 buf = pack_hex_byte(buf,(value & 0xff)) ; | |
| 817 return buf ; | |
| 818 } /* pack_short */ | |
| 819 #endif | |
| 820 | |
| 821 | |
| 822 /* Generally, I dont bury xmit and receive calls inside packet formatters | |
| 823 and parsers | |
| 824 */ | |
| 825 | |
| 826 | |
| 827 | |
| 828 | |
| 829 /* ----- PACK_SETTHREAD_REQUEST ------------------------------------- */ | |
| 2 | 830 /* Encoding: ??? decode gdb/remote.c |
| 831 'Q':8,'p':8,idefined:8,threadid:32 ; | |
| 832 */ | |
| 0 | 833 |
| 834 char * pack_setthread_request( | |
| 2 | 835 char * buf, |
| 836 char fmt, /* c,g or, p */ | |
| 837 int idformat , | |
| 838 threadref * threadid ) | |
| 0 | 839 { |
| 840 *buf++ = fmt ; | |
| 841 | |
| 842 if (fmt == 'p') | |
| 843 { /* pack the long form */ | |
| 844 buf = pack_nibble(buf,idformat) ; | |
| 845 buf = pack_threadid(buf,threadid) ; | |
| 846 } | |
| 847 else | |
| 848 { /* pack the shorter form - Serious truncation */ | |
| 849 /* There are reserved identifieds 0 , -1 */ | |
| 850 int quickref = threadref_to_int(threadid) ; | |
| 851 buf = pack_varlen_hex(buf,quickref) ; | |
| 852 } | |
| 853 *buf++ = '\0' ; /* end_of_packet */ | |
| 854 return buf ; | |
| 855 } /* pack_setthread_request */ | |
| 856 | |
| 857 | |
| 858 | |
| 859 /* -------- PACK_THREADLIST-REQUEST --------------------------------- */ | |
| 860 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */ | |
| 861 | |
| 862 | |
| 863 char * pack_threadlist_request( | |
| 2 | 864 char * pkt, |
| 865 int startflag, | |
| 866 int threadcount, | |
| 867 threadref * nextthread | |
| 868 ) | |
| 0 | 869 { |
| 870 *pkt++ = 'q' ; | |
| 871 *pkt++ = 'L' ; | |
| 872 pkt = pack_nibble(pkt,startflag) ; /* initflag 1 bytes */ | |
| 873 pkt = pack_hex_byte(pkt,threadcount) ; /* threadcount 2 bytes */ | |
| 874 pkt = pack_threadid(pkt,nextthread) ; /* 64 bit thread identifier */ | |
| 875 *pkt = '\0' ; | |
| 876 return pkt ; | |
| 877 } /* remote_threadlist_request */ | |
| 878 | |
| 879 | |
| 880 | |
| 881 | |
| 882 /* ---------- PARSE_THREADLIST_RESPONSE ------------------------------------ */ | |
| 883 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */ | |
| 884 | |
| 885 int parse_threadlist_response( | |
| 2 | 886 char * pkt, |
| 887 threadref * original_echo, | |
| 888 threadref * resultlist, | |
| 889 int * doneflag) | |
| 0 | 890 { |
| 891 char * limit ; | |
| 892 int count, resultcount , done ; | |
| 893 resultcount = 0 ; | |
| 894 | |
| 895 /* assume the 'q' and 'M chars have been stripped */ | |
| 896 PKT_TRACE("parse-threadlist-response ",pkt) ; | |
| 897 limit = pkt + (STUB_BUF_MAX - BUFTHREADIDSIZ) ; /* done parse past here */ | |
| 2 | 898 pkt = unpack_byte(pkt,&count) ; /* count field */ |
| 0 | 899 pkt = unpack_nibble(pkt,&done) ; |
| 900 /* The first threadid is the argument threadid */ | |
| 901 pkt = unpack_threadid(pkt,original_echo) ; /* should match query packet */ | |
| 902 while ((count-- > 0) && (pkt < limit)) | |
| 903 { | |
| 904 pkt = unpack_threadid(pkt,resultlist++) ; | |
| 905 resultcount++ ; | |
| 906 } | |
| 907 if (doneflag) *doneflag = done ; | |
| 908 return resultcount ; /* successvalue */ | |
| 909 } /* parse_threadlist_response */ | |
| 910 | |
| 911 struct gdb_ext_thread_info | |
| 912 { | |
| 913 threadref threadid ; | |
| 914 int active ; | |
| 915 char display[256] ; | |
| 916 char shortname[32] ; | |
| 917 char more_display[256] ; | |
| 918 } ; | |
| 919 | |
| 920 | |
| 921 /* ----- PACK_THREAD_INFO_REQUEST -------------------------------- */ | |
| 922 | |
| 923 /* | |
| 924 threadid:1, # always request threadid | |
| 925 context_exists:2, | |
| 926 display:4, | |
| 927 unique_name:8, | |
| 928 more_display:16 | |
| 929 */ | |
| 930 | |
| 931 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */ | |
| 932 | |
| 933 char * pack_threadinfo_request(char * pkt, | |
| 2 | 934 int mode, |
| 935 threadref * id | |
| 936 ) | |
| 0 | 937 { |
| 938 *pkt++ = 'Q' ; | |
| 939 *pkt++ = 'P' ; | |
| 940 pkt = pack_int(pkt,mode) ; /* mode */ | |
| 941 pkt = pack_threadid(pkt,id) ; /* threadid */ | |
| 942 *pkt = '\0' ; /* terminate */ | |
| 943 return pkt ; | |
| 944 } /* pack_thread_info_request */ | |
| 945 | |
| 946 | |
| 947 | |
| 948 static char * unpack_string( | |
| 2 | 949 char * src, |
| 950 char * dest, | |
| 951 int length) | |
| 0 | 952 { |
| 953 while (length--) *dest++ = *src++ ; | |
| 954 *dest = '\0' ; | |
| 955 return src ; | |
| 956 } /* unpack_string */ | |
| 957 | |
| 958 | |
| 959 void output_threadid(char * title,threadref * ref) | |
| 960 { | |
| 961 char hexid[20] ; | |
| 962 pack_threadid(&hexid[0],ref) ; /* Convert threead id into hex */ | |
| 963 hexid[16] = 0 ; | |
| 2 | 964 output_string(title) ; |
| 965 output_string(&hexid[0]) ; | |
| 966 output_string("\n") ; | |
| 0 | 967 } |
| 968 | |
| 969 /* ------ REMOTE_UPK_THREAD_INFO_RESPONSE ------------------------------- */ | |
| 970 /* Unpack the response of a detailed thread info packet */ | |
| 971 /* Encoding: i'Q':8,i'R':8,argmask:16,threadid:64,(tag:8,length:16,data:x)* */ | |
| 972 | |
| 973 #define TAG_THREADID 1 | |
| 974 #define TAG_EXISTS 2 | |
| 975 #define TAG_DISPLAY 4 | |
| 976 #define TAG_THREADNAME 8 | |
| 977 #define TAG_MOREDISPLAY 16 | |
| 978 | |
| 979 | |
| 980 int remote_upk_thread_info_response( | |
| 2 | 981 char * pkt, |
| 982 threadref * expectedref , | |
| 983 struct gdb_ext_thread_info * info) | |
| 0 | 984 { |
| 985 int mask, length ; | |
| 986 unsigned int tag ; | |
| 987 threadref ref ; | |
| 988 char * limit = pkt + 500 ; /* plausable parsing limit */ | |
| 989 int retval = 1 ; | |
| 990 | |
| 991 PKT_TRACE("upk-threadinfo ",pkt) ; | |
| 992 | |
| 993 /* info->threadid = 0 ; FIXME: implement zero_threadref */ | |
| 994 info->active = 0 ; | |
| 995 info->display[0] = '\0' ; | |
| 996 info->shortname[0] = '\0' ; | |
| 997 info->more_display[0] = '\0' ; | |
| 998 | |
| 999 /* Assume the characters indicating the packet type have been stripped */ | |
| 1000 pkt = unpack_int(pkt,&mask) ; /* arg mask */ | |
| 1001 pkt = unpack_threadid(pkt , &ref) ; | |
| 1002 | |
| 1003 if (! threadmatch(&ref,expectedref)) | |
| 1004 { /* This is an answer to a different request */ | |
| 1005 output_string("FAIL Thread mismatch\n") ; | |
| 1006 output_threadid("ref ",&ref) ; | |
| 1007 output_threadid("expected ",expectedref) ; | |
| 1008 return 0 ; | |
| 1009 } | |
| 1010 copy_threadref(&info->threadid,&ref) ; | |
| 1011 | |
| 1012 /* Loop on tagged fields , try to bail if somthing goes wrong */ | |
| 1013 if (mask==0) output_string("OOPS NO MASK \n") ; | |
| 1014 | |
| 1015 while ((pkt < limit) && mask && *pkt) /* packets are terminated with nulls */ | |
| 1016 { | |
| 1017 pkt = unpack_int(pkt,&tag) ; /* tag */ | |
| 1018 pkt = unpack_byte(pkt,&length) ; /* length */ | |
| 1019 if (! (tag & mask)) /* tags out of synch with mask */ | |
| 2 | 1020 { |
| 1021 output_string("FAIL: threadinfo tag mismatch\n") ; | |
| 1022 retval = 0 ; | |
| 1023 break ; | |
| 1024 } | |
| 0 | 1025 if (tag == TAG_THREADID) |
| 2 | 1026 { |
| 1027 output_string("unpack THREADID\n") ; | |
| 1028 if (length != 16) | |
| 1029 { | |
| 1030 output_string("FAIL: length of threadid is not 16\n") ; | |
| 1031 retval = 0 ; | |
| 1032 break ; | |
| 1033 } | |
| 1034 pkt = unpack_threadid(pkt,&ref) ; | |
| 1035 mask = mask & ~ TAG_THREADID ; | |
| 1036 continue ; | |
| 1037 } | |
| 0 | 1038 if (tag == TAG_EXISTS) |
| 2 | 1039 { |
| 1040 info->active = stub_unpack_int(pkt,length) ; | |
| 1041 pkt += length ; | |
| 1042 mask = mask & ~(TAG_EXISTS) ; | |
| 1043 if (length > 8) | |
| 1044 { | |
| 1045 output_string("FAIL: 'exists' length too long\n") ; | |
| 1046 retval = 0 ; | |
| 1047 break ; | |
| 1048 } | |
| 1049 continue ; | |
| 1050 } | |
| 0 | 1051 if (tag == TAG_THREADNAME) |
| 2 | 1052 { |
| 1053 pkt = unpack_string(pkt,&info->shortname[0],length) ; | |
| 1054 mask = mask & ~TAG_THREADNAME ; | |
| 1055 continue ; | |
| 1056 } | |
| 0 | 1057 if (tag == TAG_DISPLAY) |
| 2 | 1058 { |
| 1059 pkt = unpack_string(pkt,&info->display[0],length) ; | |
| 1060 mask = mask & ~TAG_DISPLAY ; | |
| 1061 continue ; | |
| 1062 } | |
| 0 | 1063 if (tag == TAG_MOREDISPLAY) |
| 2 | 1064 { |
| 1065 pkt = unpack_string(pkt,&info->more_display[0],length) ; | |
| 1066 mask = mask & ~TAG_MOREDISPLAY ; | |
| 1067 continue ; | |
| 1068 } | |
| 0 | 1069 output_string("FAIL: unknown info tag\n") ; |
| 1070 break ; /* Not a tag we know about */ | |
| 1071 } | |
| 1072 return retval ; | |
| 1073 } /* parse-thread_info_response */ | |
| 1074 | |
| 1075 | |
| 2 | 1076 /* ---- REMOTE_PACK_CURRTHREAD_REQUEST ---------------------------- */ |
| 0 | 1077 /* This is a request to emit the T packet */ |
| 1078 | |
| 1079 /* FORMAT: 'q':8,'C' */ | |
| 1080 | |
| 1081 char * remote_pack_currthread_request(char * pkt ) | |
| 1082 { | |
| 1083 *pkt++ = 'q' ; | |
| 1084 *pkt++ = 'C' ; | |
| 1085 *pkt = '\0' ; | |
| 1086 return pkt ; | |
| 2 | 1087 } /* remote_pack_currthread_request */ |
| 0 | 1088 |
| 1089 | |
| 1090 /* ------- REMOTE_UPK_CURTHREAD_RESPONSE ----------------------- */ | |
| 1091 /* Unpack the interesting part of a T packet */ | |
| 1092 | |
| 1093 | |
| 1094 int remote_upk_currthread_response( | |
| 2 | 1095 char * pkt, |
| 1096 int *thr ) /* Parse a T packet */ | |
| 0 | 1097 { |
| 1098 int retval = 0 ; | |
| 1099 PKT_TRACE("upk-currthreadresp ",pkt) ; | |
| 1100 | |
| 1101 #if 0 | |
| 1102 { | |
| 1103 static char threadtag[8] = "thread" ; | |
| 1104 int retval = 0 ; | |
| 1105 int i , found ; | |
| 1106 char ch ; | |
| 1107 int quickid ; | |
| 1108 | |
| 1109 /* Unpack as a t packet */ | |
| 1110 while (((ch = *pkt++) != ':') /* scan for : thread */ | |
| 2 | 1111 && (ch != '\0')) /* stop at end of packet */ |
| 0 | 1112 |
| 1113 { | |
| 1114 found = 0 ; | |
| 1115 i = 0 ; | |
| 1116 while ((ch = *pkt++) == threadtag[i++]) ; | |
| 1117 if (i == 8) /* string match "thread" */ | |
| 2 | 1118 { |
| 1119 pkt = unpack_varlen_hex(pkt,&quickid) ; | |
| 1120 retval = 1; | |
| 1121 break ; | |
| 1122 } | |
| 0 | 1123 retval = 0 ; |
| 1124 } | |
| 1125 } | |
| 1126 #else | |
| 2 | 1127 pkt = unpack_threadid(pkt, thr) ; |
| 0 | 1128 retval = 1 ; |
| 1129 #endif | |
| 1130 return retval ; | |
| 1131 } /* remote_upk_currthread_response */ | |
| 1132 | |
| 1133 | |
| 1134 /* -------- REMOTE_UPK-SIMPLE_ACK --------------------------------- */ | |
| 1135 /* Decode a response which is eother "OK" or "Enn" | |
| 1136 fillin error code, fillin pkfag-1== undef, 0==nak, 1 == ack ; | |
| 1137 return advanced packet pointer */ | |
| 1138 | |
| 1139 | |
| 1140 char * remote_upk_simple_ack( | |
| 2 | 1141 char * buf, |
| 1142 int * pkflag, | |
| 1143 int * errcode) | |
| 0 | 1144 { |
| 1145 int lclerr = 0 ; | |
| 1146 char ch = *buf++ ; | |
| 1147 int retval = -1 ; /* Undefined ACK , a protocol error */ | |
| 1148 if (ch == 'E') /* NAK */ | |
| 1149 { | |
| 1150 buf = unpack_byte(buf,&lclerr) ; | |
| 1151 retval = 0 ; /* transaction failed, explicitly */ | |
| 1152 } | |
| 1153 else | |
| 1154 if ((ch == 'O') && (*buf++ == 'K')) /* ACK */ | |
| 1155 retval = 1 ; /* transaction succeeded */ | |
| 1156 *pkflag = retval ; | |
| 1157 *errcode = lclerr ; | |
| 1158 return buf ; | |
| 1159 } /* remote-upk_simple_ack */ | |
| 1160 | |
| 1161 | |
| 1162 /* -------- PACK_THREADALIVE_REQUEST ------------------------------- */ | |
| 1163 | |
| 1164 char * pack_threadalive_request( | |
| 2 | 1165 char * buf, |
| 1166 threadref * threadid) | |
| 0 | 1167 { |
| 1168 *buf++ = 'T' ; | |
| 1169 buf = pack_threadid(buf,threadid) ; | |
| 1170 *buf = '\0' ; | |
| 1171 return buf ; | |
| 1172 } /* pack_threadalive_request */ | |
| 1173 | |
| 1174 #endif /* GDB_MOCKUP */ | |
| 1175 | |
| 1176 /* ---------------------------------------------------------------------- */ | |
| 1177 /* UNIT_TESTS SUBSECTION */ | |
| 1178 /* ---------------------------------------------------------------------- */ | |
| 1179 | |
| 1180 | |
| 1181 #if UNIT_TEST | |
| 1182 extern void output_string(char * message) ; | |
| 1183 static char test_req[400] ; | |
| 1184 static char t_response[400] ; | |
| 1185 | |
| 1186 | |
| 1187 | |
| 1188 /* ----- DISPLAY_THREAD_INFO ---------------------------------------------- */ | |
| 1189 /* Use local cygmon string output utiities */ | |
| 1190 | |
| 1191 void display_thread_info(struct gdb_ext_thread_info * info) | |
| 1192 { | |
| 1193 | |
| 1194 output_threadid("Threadid: ",&info->threadid) ; | |
| 1195 /* short name */ | |
| 1196 output_string("Name: ") ; output_string(info->shortname) ; output_string("\n"); | |
| 1197 /* format display state */ | |
| 1198 output_string("State: ") ; output_string(info->display) ; output_string("\n") ; | |
| 1199 /* additional data */ | |
| 1200 output_string("other: ");output_string(info->more_display); | |
| 1201 output_string("\n\n"); | |
| 1202 } /* display_thread_info */ | |
| 1203 | |
| 1204 | |
| 1205 /* --- CURRTHREAD-TEST -------------------------------------------- */ | |
| 1206 static int currthread_test(threadref * thread) | |
| 1207 { | |
| 1208 int result ; | |
| 2 | 1209 int threadid ; |
| 0 | 1210 output_string("TEST: currthread\n") ; |
| 1211 remote_pack_currthread_request(test_req) ; | |
| 1212 stub_pkt_currthread(test_req+2,t_response,STUB_BUF_MAX) ; | |
| 2 | 1213 result = remote_upk_currthread_response(t_response+2, &threadid) ; |
| 0 | 1214 if (result) |
| 1215 { | |
| 1216 output_string("PASS getcurthread\n") ; | |
| 1217 /* FIXME: print the thread */ | |
| 1218 } | |
| 1219 else | |
| 1220 output_string("FAIL getcurrthread\n") ; | |
| 1221 return result ; | |
| 1222 } /* currthread_test */ | |
| 1223 | |
| 1224 /* ------ SETTHREAD_TEST ------------------------------------------- */ | |
| 1225 /* use a known thread from previous test */ | |
| 1226 | |
| 1227 static int setthread_test(threadref * thread) | |
| 1228 { | |
| 1229 int result, errcode ; | |
| 1230 output_string("TEST: setthread\n") ; | |
| 1231 | |
| 1232 pack_setthread_request(test_req,'p',1,thread) ; | |
| 1233 stub_pkt_changethread(test_req,t_response,STUB_BUF_MAX) ; | |
| 1234 remote_upk_simple_ack(t_response,&result,&errcode) ; | |
| 1235 switch (result) | |
| 1236 { | |
| 1237 case 0 : | |
| 1238 output_string("FAIL setthread\n") ; | |
| 1239 break ; | |
| 1240 case 1 : | |
| 1241 output_string("PASS setthread\n") ; | |
| 1242 break ; | |
| 1243 default : | |
| 1244 output_string("FAIL setthread -unrecognized response\n") ; | |
| 1245 break ; | |
| 1246 } | |
| 1247 return result ; | |
| 1248 } /* setthread_test */ | |
| 1249 | |
| 1250 | |
| 1251 /* ------ THREADACTIVE_TEST ---------------------- */ | |
| 1252 /* use known thread */ | |
| 1253 /* pack threadactive packet */ | |
| 1254 /* process threadactive packet */ | |
| 1255 /* parse threadactive response */ | |
| 1256 /* check results */ | |
| 1257 | |
| 1258 | |
| 1259 int threadactive_test(threadref * thread) | |
| 1260 { | |
| 1261 int result ; | |
| 1262 int errcode ; | |
| 1263 output_string("TEST: threadactive\n") ; | |
| 1264 pack_threadalive_request(test_req,thread) ; | |
| 1265 stub_pkt_thread_alive(test_req+1,t_response,STUB_BUF_MAX); | |
| 1266 remote_upk_simple_ack(t_response,&result,&errcode) ; | |
| 1267 switch (result) | |
| 1268 { | |
| 1269 case 0 : | |
| 1270 output_string("FAIL threadalive\n") ; | |
| 1271 break ; | |
| 1272 case 1 : | |
| 1273 output_string("PASS threadalive\n") ; | |
| 1274 break ; | |
| 1275 default : | |
| 1276 output_string("FAIL threadalive -unrecognized response\n") ; | |
| 1277 break ; | |
| 1278 } | |
| 1279 return result ; | |
| 1280 } /* threadactive_test */ | |
| 1281 | |
| 1282 /* ------ REMOTE_GET_THREADINFO -------------------------------------- */ | |
| 1283 int remote_get_threadinfo( | |
| 1284 threadref * threadid, | |
| 1285 int fieldset , /* TAG mask */ | |
| 1286 struct gdb_ext_thread_info * info | |
| 1287 ) | |
| 1288 { | |
| 1289 int result ; | |
| 1290 pack_threadinfo_request(test_req,fieldset,threadid) ; | |
| 1291 stub_pkt_getthreadinfo(test_req+2,t_response,STUB_BUF_MAX) ; | |
| 1292 result = remote_upk_thread_info_response(t_response+2,threadid,info) ; | |
| 1293 return result ; | |
| 1294 } /* remote_get-thrreadinfo */ | |
| 1295 | |
| 1296 | |
| 1297 static struct gdb_ext_thread_info test_info ; | |
| 1298 | |
| 1299 static int get_and_display_threadinfo(threadref * thread) | |
| 1300 { | |
| 1301 int mode ; | |
| 1302 int result ; | |
| 1303 /* output_string("TEST: get and display threadinfo\n") ; */ | |
| 1304 | |
| 1305 mode = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME | |
| 1306 | TAG_MOREDISPLAY | TAG_DISPLAY ; | |
| 1307 result = remote_get_threadinfo(thread,mode,&test_info) ; | |
| 1308 if (result) display_thread_info(&test_info) ; | |
| 1309 #if 0 /* silent subtest */ | |
| 1310 if (result) | |
| 1311 output_string("PASS: get_and_display threadinfo\n") ; | |
| 1312 else | |
| 1313 output_string("FAIL: get_and_display threadinfo\n") ; | |
| 1314 #endif | |
| 1315 return result ; | |
| 1316 } /* get-and-display-threadinfo */ | |
| 1317 | |
| 1318 | |
| 1319 | |
| 1320 /* ----- THREADLIST_TEST ------------------------------------------ */ | |
| 1321 #define TESTLISTSIZE 16 | |
| 1322 #define TLRSIZ 2 | |
| 1323 static threadref test_threadlist[TESTLISTSIZE] ; | |
| 1324 | |
| 1325 static int threadlist_test(void) | |
| 1326 { | |
| 1327 int done, i , result_count ; | |
| 1328 int startflag = 1 ; | |
| 1329 int result = 1 ; | |
| 1330 int loopcount = 0 ; | |
| 1331 static threadref nextthread ; | |
| 1332 static threadref echo_nextthread ; | |
| 1333 | |
| 1334 output_string("TEST: threadlist\n") ; | |
| 1335 | |
| 1336 done = 0 ; | |
| 1337 while (! done) | |
| 1338 { | |
| 1339 if (loopcount++ > 10) | |
| 2 | 1340 { |
| 1341 result = 0 ; | |
| 1342 output_string("FAIL: Threadlist test -infinite loop-\n") ; | |
| 1343 break ; | |
| 1344 } | |
| 0 | 1345 pack_threadlist_request(test_req,startflag,TLRSIZ,&nextthread) ; |
| 1346 startflag = 0 ; /* clear for later iterations */ | |
| 1347 stub_pkt_getthreadlist(test_req+2,t_response,STUB_BUF_MAX); | |
| 1348 result_count = parse_threadlist_response(t_response+2, | |
| 2 | 1349 &echo_nextthread, |
| 1350 &test_threadlist[0],&done) ; | |
| 0 | 1351 if (! threadmatch(&echo_nextthread,&nextthread)) |
| 2 | 1352 { |
| 1353 output_string("FAIL: threadlist did not echo arg thread\n"); | |
| 1354 result = 0 ; | |
| 1355 break ; | |
| 1356 } | |
| 0 | 1357 if (result_count <= 0) |
| 2 | 1358 { |
| 1359 if (done != 0) | |
| 1360 { output_string("FAIL threadlist_test, failed to get list"); | |
| 1361 result = 0 ; | |
| 1362 } | |
| 1363 break ; | |
| 1364 } | |
| 0 | 1365 if (result_count > TLRSIZ) |
| 2 | 1366 { |
| 1367 output_string("FAIL: threadlist response longer than requested\n") ; | |
| 1368 result = 0 ; | |
| 1369 break ; | |
| 1370 } | |
| 0 | 1371 /* Setup to resume next batch of thread references , set nestthread */ |
| 1372 copy_threadref(&nextthread,&test_threadlist[result_count-1]) ; | |
| 1373 /* output_threadid("last-of-batch",&nextthread) ; */ | |
| 1374 i = 0 ; | |
| 1375 while (result_count--) | |
| 2 | 1376 { |
| 1377 if (0) /* two display alternatives */ | |
| 1378 output_threadid("truncatedisplay",&test_threadlist[i++]) ; | |
| 1379 else | |
| 1380 get_and_display_threadinfo(&test_threadlist[i++]) ; | |
| 1381 } | |
| 0 | 1382 |
| 1383 } | |
| 1384 if (!result) | |
| 1385 output_string("FAIL: threadlist test\n") ; | |
| 1386 else output_string("PASS: Threadlist test\n") ; | |
| 1387 return result ; | |
| 1388 } /* threadlist_test */ | |
| 1389 | |
| 1390 | |
| 1391 static threadref testthread ; | |
| 1392 | |
| 1393 | |
| 1394 int test_thread_support(void) | |
| 1395 { | |
| 1396 int result = 1 ; | |
| 1397 output_string("TESTING Thread support infrastructure\n") ; | |
| 1398 stub_pack_Tpkt_threadid(test_req) ; | |
| 1399 PKT_TRACE("packing the threadid -> ",test_req) ; | |
| 1400 result &= currthread_test(&testthread) ; | |
| 1401 result &= get_and_display_threadinfo(&testthread) ; | |
| 1402 result &= threadlist_test() ; | |
| 1403 result &= setthread_test(&testthread) ; | |
| 1404 if (result) | |
| 1405 output_string("PASS: UNITTEST Thread support\n") ; | |
| 1406 else | |
| 1407 output_string("FAIL: UNITTEST Thread support\n") ; | |
| 1408 return result ; | |
| 1409 } /* test-thread_support */ | |
| 1410 #endif /* UNIT_TEST */ | |
| 1411 | |
| 2 | 1412 // #ifdef __ECOS__ |
| 0 | 1413 #endif // ifdef CYGDBG_HAL_DEBUG_GDB_THREAD_SUPPORT... |
| 2 | 1414 // #endif // __ECOS__ |