← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to tests/resolve_stack_dump.c

  • Committer: Monty
  • Date: 2008-11-07 05:51:15 UTC
  • mto: This revision was merged to the branch mainline in revision 579.
  • Revision ID: mordred@palanthas.inaugust.com-20081107055115-0275gvq62buzls77
Fixed a decimal sign thing.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/resolve_stack_dump.c
 
1
/* Copyright (C) 2000 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
 
16
/* Resolve numeric stack dump produced by drizzled 3.23.30 and later
 
17
   versions into symbolic names. By Sasha Pachev <sasha@mysql.com>
 
18
 */
 
19
 
 
20
#include <drizzled/global.h>
 
21
#include <mystrings/m_ctype.h>
 
22
#include <mysys/my_sys.h>
 
23
#include <mystrings/m_string.h>
 
24
#include <errno.h>
 
25
#include <mysys/my_getopt.h>
 
26
 
 
27
#define INIT_SYM_TABLE  4096
 
28
#define INC_SYM_TABLE  4096
 
29
#define MAX_SYM_SIZE   128
 
30
#define DUMP_VERSION "1.4"
 
31
#define HEX_INVALID  (unsigned char)255
 
32
 
 
33
 
 
34
typedef struct sym_entry
 
35
{
 
36
  char symbol[MAX_SYM_SIZE];
 
37
  unsigned char* addr;
 
38
} SYM_ENTRY;
 
39
 
 
40
 
 
41
static char* dump_fname = 0, *sym_fname = 0;
 
42
static DYNAMIC_ARRAY sym_table; /* how do you like this , static DYNAMIC ? */
 
43
static FILE* fp_dump, *fp_sym = 0, *fp_out; 
 
44
 
 
45
static struct my_option my_long_options[] =
 
46
{
 
47
  {"help", 'h', "Display this help and exit.",
 
48
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
 
49
  {"version", 'V', "Output version information and exit.",
 
50
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
 
51
  {"symbols-file", 's', "Use specified symbols file.", (char**) &sym_fname,
 
52
   (char**) &sym_fname, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 
53
  {"numeric-dump-file", 'n', "Read the dump from specified file.",
 
54
   (char**) &dump_fname, (char**) &dump_fname, 0, GET_STR, REQUIRED_ARG,
 
55
   0, 0, 0, 0, 0, 0},
 
56
  { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
 
57
};
 
58
 
 
59
 
 
60
static void verify_sort(void);
 
61
 
 
62
static void print_version(void)
 
63
{
 
64
  printf("%s  Ver %s Distrib %s, for %s (%s)\n",my_progname,DUMP_VERSION,
 
65
         VERSION,SYSTEM_TYPE,MACHINE_TYPE);
 
66
}
 
67
 
 
68
 
 
69
static void usage(void)
 
70
{
 
71
  print_version();
 
72
  printf("MySQL AB, by Sasha Pachev\n");
 
73
  printf("This software comes with ABSOLUTELY NO WARRANTY\n\n");
 
74
  printf("Resolve numeric stack strace dump into symbols.\n\n");
 
75
  printf("Usage: %s [OPTIONS] symbols-file [numeric-dump-file]\n",
 
76
         my_progname);
 
77
  my_print_help(my_long_options);
 
78
  my_print_variables(my_long_options);
 
79
  printf("\n\
 
80
The symbols-file should include the output from:  'nm --numeric-sort drizzled'.\n\
 
81
The numeric-dump-file should contain a numeric stack trace from drizzled.\n\
 
82
If the numeric-dump-file is not given, the stack trace is read from stdin.\n");
 
83
}
 
84
 
 
85
static void die(const char* fmt, ...)
 
86
{
 
87
  va_list args;
 
88
  va_start(args, fmt);
 
89
  fprintf(stderr, "%s: ", my_progname);
 
90
  vfprintf(stderr, fmt, args);
 
91
  fprintf(stderr, "\n");
 
92
  va_end(args);
 
93
  exit(1);
 
94
}
 
95
 
 
96
 
 
97
static bool
 
98
get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
 
99
               char *argument __attribute__((unused)))
 
100
{
 
101
  switch(optid) {
 
102
  case 'V':
 
103
    print_version();
 
104
    exit(0);
 
105
  case '?':
 
106
    usage();
 
107
    exit(0);
 
108
  }
 
109
  return 0;
 
110
}
 
111
 
 
112
 
 
113
static int parse_args(int argc, char **argv)
 
114
{
 
115
  int ho_error;
 
116
 
 
117
  if ((ho_error= handle_options(&argc, &argv, my_long_options, get_one_option)))
 
118
    exit(ho_error);
 
119
 
 
120
  /*
 
121
    The following code is to make the command compatible with the old
 
122
    version that required one to use the -n and -s options
 
123
  */
 
124
 
 
125
  if (argc == 2)
 
126
  {
 
127
    sym_fname= argv[0];
 
128
    dump_fname= argv[1];
 
129
  }
 
130
  else if (argc == 1)
 
131
  {
 
132
    if (!sym_fname)
 
133
      sym_fname = argv[0];
 
134
    else if (!dump_fname)
 
135
      dump_fname = argv[0];
 
136
    else
 
137
    {
 
138
      usage();
 
139
      exit(1);
 
140
    }
 
141
  }
 
142
  else if (argc != 0 || !sym_fname)
 
143
  {
 
144
    usage();
 
145
    exit(1);
 
146
  }
 
147
  return 0;
 
148
}
 
149
 
 
150
 
 
151
static void open_files(void)
 
152
{
 
153
  fp_out = stdout;
 
154
  fp_dump = stdin;
 
155
 
 
156
  if (dump_fname && !(fp_dump = my_fopen(dump_fname, O_RDONLY, MYF(MY_WME))))
 
157
      die("Could not open %s", dump_fname);
 
158
  /* if name not given, assume stdin*/
 
159
 
 
160
  if (!sym_fname)
 
161
    die("Please run nm --numeric-sort on drizzled binary that produced stack \
 
162
trace dump and specify the path to it with -s or --symbols-file");
 
163
  if (!(fp_sym = my_fopen(sym_fname, O_RDONLY, MYF(MY_WME))))
 
164
    die("Could not open %s", sym_fname);
 
165
 
 
166
}
 
167
 
 
168
static unsigned char hex_val(char c)
 
169
{
 
170
  unsigned char l;
 
171
  if (my_isdigit(&my_charset_utf8_general_ci,c))
 
172
    return c - '0';
 
173
  l = my_tolower(&my_charset_utf8_general_ci,c);
 
174
  if (l < 'a' || l > 'f')
 
175
    return HEX_INVALID; 
 
176
  return (unsigned char)10 + ((unsigned char)c - (unsigned char)'a');
 
177
}
 
178
 
 
179
static unsigned long read_addr(char** buf)
 
180
{
 
181
  unsigned char c;
 
182
  char* p = *buf;
 
183
  unsigned long addr = 0;
 
184
 
 
185
  while((c = hex_val(*p++)) != HEX_INVALID)
 
186
      addr = (addr << 4) + c;
 
187
 
 
188
  *buf = p; 
 
189
  return addr;
 
190
}
 
191
 
 
192
static int init_sym_entry(SYM_ENTRY* se, char* buf)
 
193
{
 
194
  char* p, *p_end;
 
195
  se->addr = (unsigned char*)read_addr(&buf);
 
196
 
 
197
  if (!se->addr)
 
198
    return -1;
 
199
  while (my_isspace(&my_charset_utf8_general_ci,*buf++))
 
200
    /* empty */;
 
201
 
 
202
  while (my_isspace(&my_charset_utf8_general_ci,*buf++))
 
203
    /* empty - skip more space */;
 
204
  --buf;
 
205
  /* now we are on the symbol */
 
206
  for (p = se->symbol, p_end = se->symbol + sizeof(se->symbol) - 1;
 
207
       *buf != '\n' && *buf && p < p_end; ++buf,++p)
 
208
    *p = *buf;
 
209
  *p = 0;
 
210
  if (!strcmp(se->symbol, "gcc2_compiled."))
 
211
    return -1;
 
212
  return 0;
 
213
}
 
214
 
 
215
static void init_sym_table(void)
 
216
{
 
217
  char buf[512];
 
218
  if (my_init_dynamic_array(&sym_table, sizeof(SYM_ENTRY), INIT_SYM_TABLE,
 
219
                            INC_SYM_TABLE))
 
220
    die("Failed in my_init_dynamic_array() -- looks like out of memory problem");
 
221
 
 
222
  while (fgets(buf, sizeof(buf), fp_sym))
 
223
  {
 
224
    SYM_ENTRY se;
 
225
    if (init_sym_entry(&se, buf))
 
226
      continue;
 
227
    if (insert_dynamic(&sym_table, (unsigned char*)&se))
 
228
      die("insert_dynamic() failed - looks like we are out of memory");
 
229
  }
 
230
 
 
231
  verify_sort();
 
232
}
 
233
 
 
234
static void clean_up(void)
 
235
{
 
236
  delete_dynamic(&sym_table);
 
237
}
 
238
 
 
239
static void verify_sort()
 
240
{
 
241
  uint32_t i;
 
242
  unsigned char* last = 0;
 
243
 
 
244
  for (i = 0; i < sym_table.elements; i++)
 
245
  {
 
246
    SYM_ENTRY se;
 
247
    get_dynamic(&sym_table, (unsigned char*)&se, i);
 
248
    if (se.addr < last)
 
249
      die("sym table does not appear to be sorted, did you forget \
 
250
--numeric-sort arg to nm? trouble addr = %p, last = %p", se.addr, last);
 
251
    last = se.addr;
 
252
  }
 
253
}
 
254
 
 
255
 
 
256
static SYM_ENTRY* resolve_addr(unsigned char* addr, SYM_ENTRY* se)
 
257
{
 
258
  uint32_t i;
 
259
  get_dynamic(&sym_table, (unsigned char*)se, 0);
 
260
  if (addr < se->addr)
 
261
    return 0;
 
262
 
 
263
  for (i = 1; i < sym_table.elements; i++)
 
264
  {
 
265
    get_dynamic(&sym_table, (unsigned char*)se, i);
 
266
    if (addr < se->addr)
 
267
    {
 
268
      get_dynamic(&sym_table, (unsigned char*)se, i - 1);
 
269
      return se;
 
270
    }
 
271
  }
 
272
 
 
273
  return se;
 
274
}
 
275
 
 
276
 
 
277
static void do_resolve(void)
 
278
{
 
279
  char buf[1024], *p;
 
280
  while (fgets(buf, sizeof(buf), fp_dump))
 
281
  {
 
282
    p = buf;
 
283
    /* skip space */
 
284
    while (my_isspace(&my_charset_utf8_general_ci,*p))
 
285
      ++p;
 
286
 
 
287
    if (*p++ == '0' && *p++ == 'x')
 
288
    {
 
289
      SYM_ENTRY se ;
 
290
      unsigned char* addr = (unsigned char*)read_addr(&p);
 
291
      if (resolve_addr(addr, &se))
 
292
        fprintf(fp_out, "%p %s + %d\n", addr, se.symbol,
 
293
                (int) (addr - se.addr));
 
294
      else
 
295
        fprintf(fp_out, "%p (?)\n", addr);
 
296
 
 
297
    }
 
298
    else
 
299
    {
 
300
      fputs(buf, fp_out);
 
301
      continue;
 
302
    }
 
303
  }
 
304
}
 
305
 
 
306
 
 
307
int main(int argc, char** argv)
 
308
{
 
309
  MY_INIT(argv[0]);
 
310
  parse_args(argc, argv);
 
311
  open_files();
 
312
  init_sym_table();
 
313
  do_resolve();
 
314
  clean_up();
 
315
  return 0;
 
316
}