1 /* system/debuggerd/debuggerd.c
2 **
3 ** Copyright 2006, The Android Open Source Project
4 **
5 ** Licensed under the Apache License, Version 2.0 (the "License");
6 ** you may not use this file except in compliance with the License.
7 ** You may obtain a copy of the License at
8 **
9 ** http://www.apache.org/licenses/LICENSE-2.0
10 **
11 ** Unless required by applicable law or agreed to in writing, software
12 ** distributed under the License is distributed on an "AS IS" BASIS,
13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 ** See the License for the specific language governing permissions and
15 ** limitations under the License.
16 */
17
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <unistd.h>
21 #include <errno.h>
22 #include <signal.h>
23 #include <pthread.h>
24 #include <stdarg.h>
25 #include <fcntl.h>
26 #include <sys/types.h>
27 #include <dirent.h>
28
29 #include <sys/ptrace.h>
30 #include <sys/wait.h>
31 #include <sys/exec_elf.h>
32 #include <sys/stat.h>
33
34 #include <cutils/sockets.h>
35 #include <cutils/logd.h>
36 #include <cutils/sockets.h>
37 #include <cutils/properties.h>
38
39 #include <linux/input.h>
40
41 #include <private/android_filesystem_config.h>
42
43 #include "utility.h"
44
45 #ifdef WITH_VFP
46 #ifdef WITH_VFP_D32
47 #define NUM_VFP_REGS 32
48 #else
49 #define NUM_VFP_REGS 16
50 #endif
51 #endif
52
53 /* Main entry point to get the backtrace from the crashing process */
54 extern int unwind_backtrace_with_ptrace(int tfd, pid_t pid, mapinfo *map,
55 unsigned int sp_list[],
56 int *frame0_pc_sane,
57 bool at_fault);
58
59 static int logsocket = -1;
60
61 #define ANDROID_LOG_INFO 4
62
63 /* Log information onto the tombstone */
_LOG(int tfd,bool in_tombstone_only,const char * fmt,...)64 void _LOG(int tfd, bool in_tombstone_only, const char *fmt, ...)
65 {
66 char buf[128];
67
68 va_list ap;
69 va_start(ap, fmt);
70
71 if (tfd >= 0) {
72 int len;
73 vsnprintf(buf, sizeof(buf), fmt, ap);
74 len = strlen(buf);
75 if(tfd >= 0) write(tfd, buf, len);
76 }
77
78 if (!in_tombstone_only)
79 __android_log_vprint(ANDROID_LOG_INFO, "DEBUG", fmt, ap);
80 }
81
82 #define LOG(fmt...) _LOG(-1, 0, fmt)
83 #if 0
84 #define XLOG(fmt...) _LOG(-1, 0, fmt)
85 #else
86 #define XLOG(fmt...) do {} while(0)
87 #endif
88
89 // 6f000000-6f01e000 rwxp 00000000 00:0c 16389419 /system/lib/libcomposer.so
90 // 012345678901234567890123456789012345678901234567890123456789
91 // 0 1 2 3 4 5
92
parse_maps_line(char * line)93 mapinfo *parse_maps_line(char *line)
94 {
95 mapinfo *mi;
96 int len = strlen(line);
97
98 if(len < 1) return 0;
99 line[--len] = 0;
100
101 if(len < 50) return 0;
102 if(line[20] != 'x') return 0;
103
104 mi = malloc(sizeof(mapinfo) + (len - 47));
105 if(mi == 0) return 0;
106
107 mi->start = strtoul(line, 0, 16);
108 mi->end = strtoul(line + 9, 0, 16);
109 /* To be filled in parse_exidx_info if the mapped section starts with
110 * elf_header
111 */
112 mi->exidx_start = mi->exidx_end = 0;
113 mi->next = 0;
114 strcpy(mi->name, line + 49);
115
116 return mi;
117 }
118
dump_build_info(int tfd)119 void dump_build_info(int tfd)
120 {
121 char fingerprint[PROPERTY_VALUE_MAX];
122
123 property_get("ro.build.fingerprint", fingerprint, "unknown");
124
125 _LOG(tfd, false, "Build fingerprint: '%s'\n", fingerprint);
126 }
127
128
dump_stack_and_code(int tfd,int pid,mapinfo * map,int unwind_depth,unsigned int sp_list[],bool at_fault)129 void dump_stack_and_code(int tfd, int pid, mapinfo *map,
130 int unwind_depth, unsigned int sp_list[],
131 bool at_fault)
132 {
133 unsigned int sp, pc, p, end, data;
134 struct pt_regs r;
135 int sp_depth;
136 bool only_in_tombstone = !at_fault;
137 char code_buffer[80];
138
139 if(ptrace(PTRACE_GETREGS, pid, 0, &r)) return;
140 sp = r.ARM_sp;
141 pc = r.ARM_pc;
142
143 _LOG(tfd, only_in_tombstone, "\ncode around pc:\n");
144
145 end = p = pc & ~3;
146 p -= 32;
147 end += 32;
148
149 /* Dump the code around PC as:
150 * addr contents
151 * 00008d34 fffffcd0 4c0eb530 b0934a0e 1c05447c
152 * 00008d44 f7ff18a0 490ced94 68035860 d0012b00
153 */
154 while (p <= end) {
155 int i;
156
157 sprintf(code_buffer, "%08x ", p);
158 for (i = 0; i < 4; i++) {
159 data = ptrace(PTRACE_PEEKTEXT, pid, (void*)p, NULL);
160 sprintf(code_buffer + strlen(code_buffer), "%08x ", data);
161 p += 4;
162 }
163 _LOG(tfd, only_in_tombstone, "%s\n", code_buffer);
164 }
165
166 if ((unsigned) r.ARM_lr != pc) {
167 _LOG(tfd, only_in_tombstone, "\ncode around lr:\n");
168
169 end = p = r.ARM_lr & ~3;
170 p -= 32;
171 end += 32;
172
173 /* Dump the code around LR as:
174 * addr contents
175 * 00008d34 fffffcd0 4c0eb530 b0934a0e 1c05447c
176 * 00008d44 f7ff18a0 490ced94 68035860 d0012b00
177 */
178 while (p <= end) {
179 int i;
180
181 sprintf(code_buffer, "%08x ", p);
182 for (i = 0; i < 4; i++) {
183 data = ptrace(PTRACE_PEEKTEXT, pid, (void*)p, NULL);
184 sprintf(code_buffer + strlen(code_buffer), "%08x ", data);
185 p += 4;
186 }
187 _LOG(tfd, only_in_tombstone, "%s\n", code_buffer);
188 }
189 }
190
191 p = sp - 64;
192 p &= ~3;
193 if (unwind_depth != 0) {
194 if (unwind_depth < STACK_CONTENT_DEPTH) {
195 end = sp_list[unwind_depth-1];
196 }
197 else {
198 end = sp_list[STACK_CONTENT_DEPTH-1];
199 }
200 }
201 else {
202 end = sp | 0x000000ff;
203 end += 0xff;
204 }
205
206 _LOG(tfd, only_in_tombstone, "\nstack:\n");
207
208 /* If the crash is due to PC == 0, there will be two frames that
209 * have identical SP value.
210 */
211 if (sp_list[0] == sp_list[1]) {
212 sp_depth = 1;
213 }
214 else {
215 sp_depth = 0;
216 }
217
218 while (p <= end) {
219 char *prompt;
220 char level[16];
221 data = ptrace(PTRACE_PEEKTEXT, pid, (void*)p, NULL);
222 if (p == sp_list[sp_depth]) {
223 sprintf(level, "#%02d", sp_depth++);
224 prompt = level;
225 }
226 else {
227 prompt = " ";
228 }
229
230 /* Print the stack content in the log for the first 3 frames. For the
231 * rest only print them in the tombstone file.
232 */
233 _LOG(tfd, (sp_depth > 2) || only_in_tombstone,
234 "%s %08x %08x %s\n", prompt, p, data,
235 map_to_name(map, data, ""));
236 p += 4;
237 }
238 /* print another 64-byte of stack data after the last frame */
239
240 end = p+64;
241 while (p <= end) {
242 data = ptrace(PTRACE_PEEKTEXT, pid, (void*)p, NULL);
243 _LOG(tfd, (sp_depth > 2) || only_in_tombstone,
244 " %08x %08x %s\n", p, data,
245 map_to_name(map, data, ""));
246 p += 4;
247 }
248 }
249
dump_pc_and_lr(int tfd,int pid,mapinfo * map,int unwound_level,bool at_fault)250 void dump_pc_and_lr(int tfd, int pid, mapinfo *map, int unwound_level,
251 bool at_fault)
252 {
253 struct pt_regs r;
254
255 if(ptrace(PTRACE_GETREGS, pid, 0, &r)) {
256 _LOG(tfd, !at_fault, "tid %d not responding!\n", pid);
257 return;
258 }
259
260 if (unwound_level == 0) {
261 _LOG(tfd, !at_fault, " #%02d pc %08x %s\n", 0, r.ARM_pc,
262 map_to_name(map, r.ARM_pc, "<unknown>"));
263 }
264 _LOG(tfd, !at_fault, " #%02d lr %08x %s\n", 1, r.ARM_lr,
265 map_to_name(map, r.ARM_lr, "<unknown>"));
266 }
267
dump_registers(int tfd,int pid,bool at_fault)268 void dump_registers(int tfd, int pid, bool at_fault)
269 {
270 struct pt_regs r;
271 bool only_in_tombstone = !at_fault;
272
273 if(ptrace(PTRACE_GETREGS, pid, 0, &r)) {
274 _LOG(tfd, only_in_tombstone,
275 "cannot get registers: %s\n", strerror(errno));
276 return;
277 }
278
279 _LOG(tfd, only_in_tombstone, " r0 %08x r1 %08x r2 %08x r3 %08x\n",
280 r.ARM_r0, r.ARM_r1, r.ARM_r2, r.ARM_r3);
281 _LOG(tfd, only_in_tombstone, " r4 %08x r5 %08x r6 %08x r7 %08x\n",
282 r.ARM_r4, r.ARM_r5, r.ARM_r6, r.ARM_r7);
283 _LOG(tfd, only_in_tombstone, " r8 %08x r9 %08x 10 %08x fp %08x\n",
284 r.ARM_r8, r.ARM_r9, r.ARM_r10, r.ARM_fp);
285 _LOG(tfd, only_in_tombstone,
286 " ip %08x sp %08x lr %08x pc %08x cpsr %08x\n",
287 r.ARM_ip, r.ARM_sp, r.ARM_lr, r.ARM_pc, r.ARM_cpsr);
288
289 #ifdef WITH_VFP
290 struct user_vfp vfp_regs;
291 int i;
292
293 if(ptrace(PTRACE_GETVFPREGS, pid, 0, &vfp_regs)) {
294 _LOG(tfd, only_in_tombstone,
295 "cannot get registers: %s\n", strerror(errno));
296 return;
297 }
298
299 for (i = 0; i < NUM_VFP_REGS; i += 2) {
300 _LOG(tfd, only_in_tombstone,
301 " d%-2d %016llx d%-2d %016llx\n",
302 i, vfp_regs.fpregs[i], i+1, vfp_regs.fpregs[i+1]);
303 }
304 _LOG(tfd, only_in_tombstone, " scr %08lx\n\n", vfp_regs.fpscr);
305 #endif
306 }
307
get_signame(int sig)308 const char *get_signame(int sig)
309 {
310 switch(sig) {
311 case SIGILL: return "SIGILL";
312 case SIGABRT: return "SIGABRT";
313 case SIGBUS: return "SIGBUS";
314 case SIGFPE: return "SIGFPE";
315 case SIGSEGV: return "SIGSEGV";
316 case SIGSTKFLT: return "SIGSTKFLT";
317 default: return "?";
318 }
319 }
320
get_sigcode(int signo,int code)321 const char *get_sigcode(int signo, int code)
322 {
323 switch (signo) {
324 case SIGILL:
325 switch (code) {
326 case ILL_ILLOPC: return "ILL_ILLOPC";
327 case ILL_ILLOPN: return "ILL_ILLOPN";
328 case ILL_ILLADR: return "ILL_ILLADR";
329 case ILL_ILLTRP: return "ILL_ILLTRP";
330 case ILL_PRVOPC: return "ILL_PRVOPC";
331 case ILL_PRVREG: return "ILL_PRVREG";
332 case ILL_COPROC: return "ILL_COPROC";
333 case ILL_BADSTK: return "ILL_BADSTK";
334 }
335 break;
336 case SIGBUS:
337 switch (code) {
338 case BUS_ADRALN: return "BUS_ADRALN";
339 case BUS_ADRERR: return "BUS_ADRERR";
340 case BUS_OBJERR: return "BUS_OBJERR";
341 }
342 break;
343 case SIGFPE:
344 switch (code) {
345 case FPE_INTDIV: return "FPE_INTDIV";
346 case FPE_INTOVF: return "FPE_INTOVF";
347 case FPE_FLTDIV: return "FPE_FLTDIV";
348 case FPE_FLTOVF: return "FPE_FLTOVF";
349 case FPE_FLTUND: return "FPE_FLTUND";
350 case FPE_FLTRES: return "FPE_FLTRES";
351 case FPE_FLTINV: return "FPE_FLTINV";
352 case FPE_FLTSUB: return "FPE_FLTSUB";
353 }
354 break;
355 case SIGSEGV:
356 switch (code) {
357 case SEGV_MAPERR: return "SEGV_MAPERR";
358 case SEGV_ACCERR: return "SEGV_ACCERR";
359 }
360 break;
361 }
362 return "?";
363 }
364
dump_fault_addr(int tfd,int pid,int sig)365 void dump_fault_addr(int tfd, int pid, int sig)
366 {
367 siginfo_t si;
368
369 memset(&si, 0, sizeof(si));
370 if(ptrace(PTRACE_GETSIGINFO, pid, 0, &si)){
371 _LOG(tfd, false, "cannot get siginfo: %s\n", strerror(errno));
372 } else {
373 _LOG(tfd, false, "signal %d (%s), code %d (%s), fault addr %08x\n",
374 sig, get_signame(sig),
375 si.si_code, get_sigcode(sig, si.si_code),
376 si.si_addr);
377 }
378 }
379
dump_crash_banner(int tfd,unsigned pid,unsigned tid,int sig)380 void dump_crash_banner(int tfd, unsigned pid, unsigned tid, int sig)
381 {
382 char data[1024];
383 char *x = 0;
384 FILE *fp;
385
386 sprintf(data, "/proc/%d/cmdline", pid);
387 fp = fopen(data, "r");
388 if(fp) {
389 x = fgets(data, 1024, fp);
390 fclose(fp);
391 }
392
393 _LOG(tfd, false,
394 "*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***\n");
395 dump_build_info(tfd);
396 _LOG(tfd, false, "pid: %d, tid: %d >>> %s <<<\n",
397 pid, tid, x ? x : "UNKNOWN");
398
399 if(sig) dump_fault_addr(tfd, tid, sig);
400 }
401
parse_exidx_info(mapinfo * milist,pid_t pid)402 static void parse_exidx_info(mapinfo *milist, pid_t pid)
403 {
404 mapinfo *mi;
405 for (mi = milist; mi != NULL; mi = mi->next) {
406 Elf32_Ehdr ehdr;
407
408 memset(&ehdr, 0, sizeof(Elf32_Ehdr));
409 /* Read in sizeof(Elf32_Ehdr) worth of data from the beginning of
410 * mapped section.
411 */
412 get_remote_struct(pid, (void *) (mi->start), &ehdr,
413 sizeof(Elf32_Ehdr));
414 /* Check if it has the matching magic words */
415 if (IS_ELF(ehdr)) {
416 Elf32_Phdr phdr;
417 Elf32_Phdr *ptr;
418 int i;
419
420 ptr = (Elf32_Phdr *) (mi->start + ehdr.e_phoff);
421 for (i = 0; i < ehdr.e_phnum; i++) {
422 /* Parse the program header */
423 get_remote_struct(pid, (char *) (ptr+i), &phdr,
424 sizeof(Elf32_Phdr));
425 /* Found a EXIDX segment? */
426 if (phdr.p_type == PT_ARM_EXIDX) {
427 mi->exidx_start = mi->start + phdr.p_offset;
428 mi->exidx_end = mi->exidx_start + phdr.p_filesz;
429 break;
430 }
431 }
432 }
433 }
434 }
435
dump_crash_report(int tfd,unsigned pid,unsigned tid,bool at_fault)436 void dump_crash_report(int tfd, unsigned pid, unsigned tid, bool at_fault)
437 {
438 char data[1024];
439 FILE *fp;
440 mapinfo *milist = 0;
441 unsigned int sp_list[STACK_CONTENT_DEPTH];
442 int stack_depth;
443 int frame0_pc_sane = 1;
444
445 if (!at_fault) {
446 _LOG(tfd, true,
447 "--- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---\n");
448 _LOG(tfd, true, "pid: %d, tid: %d\n", pid, tid);
449 }
450
451 dump_registers(tfd, tid, at_fault);
452
453 /* Clear stack pointer records */
454 memset(sp_list, 0, sizeof(sp_list));
455
456 sprintf(data, "/proc/%d/maps", pid);
457 fp = fopen(data, "r");
458 if(fp) {
459 while(fgets(data, 1024, fp)) {
460 mapinfo *mi = parse_maps_line(data);
461 if(mi) {
462 mi->next = milist;
463 milist = mi;
464 }
465 }
466 fclose(fp);
467 }
468
469 parse_exidx_info(milist, tid);
470
471 /* If stack unwinder fails, use the default solution to dump the stack
472 * content.
473 */
474 stack_depth = unwind_backtrace_with_ptrace(tfd, tid, milist, sp_list,
475 &frame0_pc_sane, at_fault);
476
477 /* The stack unwinder should at least unwind two levels of stack. If less
478 * level is seen we make sure at lease pc and lr are dumped.
479 */
480 if (stack_depth < 2) {
481 dump_pc_and_lr(tfd, tid, milist, stack_depth, at_fault);
482 }
483
484 dump_stack_and_code(tfd, tid, milist, stack_depth, sp_list, at_fault);
485
486 while(milist) {
487 mapinfo *next = milist->next;
488 free(milist);
489 milist = next;
490 }
491 }
492
493 #define MAX_TOMBSTONES 10
494
495 #define typecheck(x,y) { \
496 typeof(x) __dummy1; \
497 typeof(y) __dummy2; \
498 (void)(&__dummy1 == &__dummy2); }
499
500 #define TOMBSTONE_DIR "/data/tombstones"
501
502 /*
503 * find_and_open_tombstone - find an available tombstone slot, if any, of the
504 * form tombstone_XX where XX is 00 to MAX_TOMBSTONES-1, inclusive. If no
505 * file is available, we reuse the least-recently-modified file.
506 */
find_and_open_tombstone(void)507 static int find_and_open_tombstone(void)
508 {
509 unsigned long mtime = ULONG_MAX;
510 struct stat sb;
511 char path[128];
512 int fd, i, oldest = 0;
513
514 /*
515 * XXX: Our stat.st_mtime isn't time_t. If it changes, as it probably ought
516 * to, our logic breaks. This check will generate a warning if that happens.
517 */
518 typecheck(mtime, sb.st_mtime);
519
520 /*
521 * In a single wolf-like pass, find an available slot and, in case none
522 * exist, find and record the least-recently-modified file.
523 */
524 for (i = 0; i < MAX_TOMBSTONES; i++) {
525 snprintf(path, sizeof(path), TOMBSTONE_DIR"/tombstone_%02d", i);
526
527 if (!stat(path, &sb)) {
528 if (sb.st_mtime < mtime) {
529 oldest = i;
530 mtime = sb.st_mtime;
531 }
532 continue;
533 }
534 if (errno != ENOENT)
535 continue;
536
537 fd = open(path, O_CREAT | O_EXCL | O_WRONLY, 0600);
538 if (fd < 0)
539 continue; /* raced ? */
540
541 fchown(fd, AID_SYSTEM, AID_SYSTEM);
542 return fd;
543 }
544
545 /* we didn't find an available file, so we clobber the oldest one */
546 snprintf(path, sizeof(path), TOMBSTONE_DIR"/tombstone_%02d", oldest);
547 fd = open(path, O_CREAT | O_TRUNC | O_WRONLY, 0600);
548 fchown(fd, AID_SYSTEM, AID_SYSTEM);
549
550 return fd;
551 }
552
553 /* Return true if some thread is not detached cleanly */
dump_sibling_thread_report(int tfd,unsigned pid,unsigned tid)554 static bool dump_sibling_thread_report(int tfd, unsigned pid, unsigned tid)
555 {
556 char task_path[1024];
557
558 sprintf(task_path, "/proc/%d/task", pid);
559 DIR *d;
560 struct dirent *de;
561 int need_cleanup = 0;
562
563 d = opendir(task_path);
564 /* Bail early if cannot open the task directory */
565 if (d == NULL) {
566 XLOG("Cannot open /proc/%d/task\n", pid);
567 return false;
568 }
569 while ((de = readdir(d)) != NULL) {
570 unsigned new_tid;
571 /* Ignore "." and ".." */
572 if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, ".."))
573 continue;
574 new_tid = atoi(de->d_name);
575 /* The main thread at fault has been handled individually */
576 if (new_tid == tid)
577 continue;
578
579 /* Skip this thread if cannot ptrace it */
580 if (ptrace(PTRACE_ATTACH, new_tid, 0, 0) < 0)
581 continue;
582
583 dump_crash_report(tfd, pid, new_tid, false);
584 need_cleanup |= ptrace(PTRACE_DETACH, new_tid, 0, 0);
585 }
586 closedir(d);
587 return need_cleanup != 0;
588 }
589
590 /* Return true if some thread is not detached cleanly */
engrave_tombstone(unsigned pid,unsigned tid,int debug_uid,int signal)591 static bool engrave_tombstone(unsigned pid, unsigned tid, int debug_uid,
592 int signal)
593 {
594 int fd;
595 bool need_cleanup = false;
596
597 mkdir(TOMBSTONE_DIR, 0755);
598 chown(TOMBSTONE_DIR, AID_SYSTEM, AID_SYSTEM);
599
600 fd = find_and_open_tombstone();
601 if (fd < 0)
602 return need_cleanup;
603
604 dump_crash_banner(fd, pid, tid, signal);
605 dump_crash_report(fd, pid, tid, true);
606 /*
607 * If the user has requested to attach gdb, don't collect the per-thread
608 * information as it increases the chance to lose track of the process.
609 */
610 if ((signed)pid > debug_uid) {
611 need_cleanup = dump_sibling_thread_report(fd, pid, tid);
612 }
613
614 close(fd);
615 return need_cleanup;
616 }
617
618 static int
write_string(const char * file,const char * string)619 write_string(const char* file, const char* string)
620 {
621 int len;
622 int fd;
623 ssize_t amt;
624 fd = open(file, O_RDWR);
625 len = strlen(string);
626 if (fd < 0)
627 return -errno;
628 amt = write(fd, string, len);
629 close(fd);
630 return amt >= 0 ? 0 : -errno;
631 }
632
633 static
init_debug_led(void)634 void init_debug_led(void)
635 {
636 // trout leds
637 write_string("/sys/class/leds/red/brightness", "0");
638 write_string("/sys/class/leds/green/brightness", "0");
639 write_string("/sys/class/leds/blue/brightness", "0");
640 write_string("/sys/class/leds/red/device/blink", "0");
641 // sardine leds
642 write_string("/sys/class/leds/left/cadence", "0,0");
643 }
644
645 static
enable_debug_led(void)646 void enable_debug_led(void)
647 {
648 // trout leds
649 write_string("/sys/class/leds/red/brightness", "255");
650 // sardine leds
651 write_string("/sys/class/leds/left/cadence", "1,0");
652 }
653
654 static
disable_debug_led(void)655 void disable_debug_led(void)
656 {
657 // trout leds
658 write_string("/sys/class/leds/red/brightness", "0");
659 // sardine leds
660 write_string("/sys/class/leds/left/cadence", "0,0");
661 }
662
663 extern int init_getevent();
664 extern void uninit_getevent();
665 extern int get_event(struct input_event* event, int timeout);
666
wait_for_user_action(unsigned tid,struct ucred * cr)667 static void wait_for_user_action(unsigned tid, struct ucred* cr)
668 {
669 (void)tid;
670 /* First log a helpful message */
671 LOG( "********************************************************\n"
672 "* Process %d has been suspended while crashing. To\n"
673 "* attach gdbserver for a gdb connection on port 5039:\n"
674 "*\n"
675 "* adb shell gdbserver :5039 --attach %d &\n"
676 "*\n"
677 "* Press HOME key to let the process continue crashing.\n"
678 "********************************************************\n",
679 cr->pid, cr->pid);
680
681 /* wait for HOME key (TODO: something useful for devices w/o HOME key) */
682 if (init_getevent() == 0) {
683 int ms = 1200 / 10;
684 int dit = 1;
685 int dah = 3*dit;
686 int _ = -dit;
687 int ___ = 3*_;
688 int _______ = 7*_;
689 const signed char codes[] = {
690 dit,_,dit,_,dit,___,dah,_,dah,_,dah,___,dit,_,dit,_,dit,_______
691 };
692 size_t s = 0;
693 struct input_event e;
694 int home = 0;
695 init_debug_led();
696 enable_debug_led();
697 do {
698 int timeout = abs((int)(codes[s])) * ms;
699 int res = get_event(&e, timeout);
700 if (res == 0) {
701 if (e.type==EV_KEY && e.code==KEY_HOME && e.value==0)
702 home = 1;
703 } else if (res == 1) {
704 if (++s >= sizeof(codes)/sizeof(*codes))
705 s = 0;
706 if (codes[s] > 0) {
707 enable_debug_led();
708 } else {
709 disable_debug_led();
710 }
711 }
712 } while (!home);
713 uninit_getevent();
714 }
715
716 /* don't forget to turn debug led off */
717 disable_debug_led();
718
719 /* close filedescriptor */
720 LOG("debuggerd resuming process %d", cr->pid);
721 }
722
handle_crashing_process(int fd)723 static void handle_crashing_process(int fd)
724 {
725 char buf[64];
726 struct stat s;
727 unsigned tid;
728 struct ucred cr;
729 int n, len, status;
730 int tid_attach_status = -1;
731 unsigned retry = 30;
732 bool need_cleanup = false;
733
734 char value[PROPERTY_VALUE_MAX];
735 property_get("debug.db.uid", value, "-1");
736 int debug_uid = atoi(value);
737
738 XLOG("handle_crashing_process(%d)\n", fd);
739
740 len = sizeof(cr);
741 n = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &cr, &len);
742 if(n != 0) {
743 LOG("cannot get credentials\n");
744 goto done;
745 }
746
747 XLOG("reading tid\n");
748 fcntl(fd, F_SETFL, O_NONBLOCK);
749 while((n = read(fd, &tid, sizeof(unsigned))) != sizeof(unsigned)) {
750 if(errno == EINTR) continue;
751 if(errno == EWOULDBLOCK) {
752 if(retry-- > 0) {
753 usleep(100 * 1000);
754 continue;
755 }
756 LOG("timed out reading tid\n");
757 goto done;
758 }
759 LOG("read failure? %s\n", strerror(errno));
760 goto done;
761 }
762
763 sprintf(buf,"/proc/%d/task/%d", cr.pid, tid);
764 if(stat(buf, &s)) {
765 LOG("tid %d does not exist in pid %d. ignoring debug request\n",
766 tid, cr.pid);
767 close(fd);
768 return;
769 }
770
771 XLOG("BOOM: pid=%d uid=%d gid=%d tid=%d\n", cr.pid, cr.uid, cr.gid, tid);
772
773 tid_attach_status = ptrace(PTRACE_ATTACH, tid, 0, 0);
774 if(tid_attach_status < 0) {
775 LOG("ptrace attach failed: %s\n", strerror(errno));
776 goto done;
777 }
778
779 close(fd);
780 fd = -1;
781
782 for(;;) {
783 n = waitpid(tid, &status, __WALL);
784
785 if(n < 0) {
786 if(errno == EAGAIN) continue;
787 LOG("waitpid failed: %s\n", strerror(errno));
788 goto done;
789 }
790
791 XLOG("waitpid: n=%d status=%08x\n", n, status);
792
793 if(WIFSTOPPED(status)){
794 n = WSTOPSIG(status);
795 switch(n) {
796 case SIGSTOP:
797 XLOG("stopped -- continuing\n");
798 n = ptrace(PTRACE_CONT, tid, 0, 0);
799 if(n) {
800 LOG("ptrace failed: %s\n", strerror(errno));
801 goto done;
802 }
803 continue;
804
805 case SIGILL:
806 case SIGABRT:
807 case SIGBUS:
808 case SIGFPE:
809 case SIGSEGV:
810 case SIGSTKFLT: {
811 XLOG("stopped -- fatal signal\n");
812 need_cleanup = engrave_tombstone(cr.pid, tid, debug_uid, n);
813 kill(tid, SIGSTOP);
814 goto done;
815 }
816
817 default:
818 XLOG("stopped -- unexpected signal\n");
819 goto done;
820 }
821 } else {
822 XLOG("unexpected waitpid response\n");
823 goto done;
824 }
825 }
826
827 done:
828 XLOG("detaching\n");
829
830 /* stop the process so we can debug */
831 kill(cr.pid, SIGSTOP);
832
833 /*
834 * If a thread has been attached by ptrace, make sure it is detached
835 * successfully otherwise we will get a zombie.
836 */
837 if (tid_attach_status == 0) {
838 int detach_status;
839 /* detach so we can attach gdbserver */
840 detach_status = ptrace(PTRACE_DETACH, tid, 0, 0);
841 need_cleanup |= (detach_status != 0);
842 }
843
844 /*
845 * if debug.db.uid is set, its value indicates if we should wait
846 * for user action for the crashing process.
847 * in this case, we log a message and turn the debug LED on
848 * waiting for a gdb connection (for instance)
849 */
850
851 if ((signed)cr.uid <= debug_uid) {
852 wait_for_user_action(tid, &cr);
853 }
854
855 /* resume stopped process (so it can crash in peace) */
856 kill(cr.pid, SIGCONT);
857
858 if (need_cleanup) {
859 LOG("debuggerd committing suicide to free the zombie!\n");
860 kill(getpid(), SIGKILL);
861 }
862
863 if(fd != -1) close(fd);
864 }
865
main()866 int main()
867 {
868 int s;
869 struct sigaction act;
870
871 logsocket = socket_local_client("logd",
872 ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_DGRAM);
873 if(logsocket < 0) {
874 logsocket = -1;
875 } else {
876 fcntl(logsocket, F_SETFD, FD_CLOEXEC);
877 }
878
879 act.sa_handler = SIG_DFL;
880 sigemptyset(&act.sa_mask);
881 sigaddset(&act.sa_mask,SIGCHLD);
882 act.sa_flags = SA_NOCLDWAIT;
883 sigaction(SIGCHLD, &act, 0);
884
885 s = socket_local_server("android:debuggerd",
886 ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM);
887 if(s < 0) return -1;
888 fcntl(s, F_SETFD, FD_CLOEXEC);
889
890 LOG("debuggerd: " __DATE__ " " __TIME__ "\n");
891
892 for(;;) {
893 struct sockaddr addr;
894 socklen_t alen;
895 int fd;
896
897 alen = sizeof(addr);
898 fd = accept(s, &addr, &alen);
899 if(fd < 0) continue;
900
901 fcntl(fd, F_SETFD, FD_CLOEXEC);
902
903 handle_crashing_process(fd);
904 }
905 return 0;
906 }
907