WebSVN – HelenOS – Diff – /branches/tracing/uspace/app/debug/cmd.c


/*
 * Copyright (c) 2008 Jiri Svoboda
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup debug
 * @{
 */
/** @file
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <bool.h>
#include <udebug.h>
#include <sys/types.h>
 
#include "main.h"
#include "cons.h"
#include "dthread.h"
#include "breakpoint.h"
#include "include/arch.h"
#include "cmd.h"
 
static void cmd_break(int argc, char *argv[]);
static void cmd_ct(int argc, char *argv[]);
static void cmd_dbreak(int argc, char *argv[]);
static void cmd_go(int argc, char *argv[]);
static void cmd_istep(int argc, char *argv[]);
static void cmd_lbrk(int argc, char *argv[]);
void        cmd_help(int argc, char *argv[]);
static void cmd_memr(int argc, char *argv[]);
static void cmd_pwt(int argc, char *argv[]);
static void cmd_regs(int argc, char *argv[]);
static void cmd_stop(int argc, char *argv[]);
static void cmd_threads(int argc, char *argv[]);
static void cmd_quit(int argc, char *argv[]);
 
volatile bool quit = false;
 
cmd_desc_t cmd_table[] = {
    { 1,    "break",    cmd_break },
    { 1,    "ct",       cmd_ct },
    { 1,    "dbreak",   cmd_dbreak },
    { 0,    "go",       cmd_go },
    { 0,    "help",     cmd_help },
    { 2,    "memr",     cmd_memr },
    { 0,    "pwt",      cmd_pwt },
    { 0,    "regs",     cmd_regs },
    { 0 ,   "stop",     cmd_stop },
    { 0,    "istep",    cmd_istep },
    { 0,    "lbrk",     cmd_lbrk },
    { 0,    "threads",  cmd_threads },
    { 0,    "quit",     cmd_quit },
    { -1,   NULL,       NULL }
};
 
static void cmd_break(int argc, char *argv[])
{
    uintptr_t addr;
 
    (void)argc;
    addr = strtoul(argv[1], NULL, 0);
 
    cons_printf("You requested a breakpoint at 0x%lx\n", addr);
//  arch_breakpoint_add(addr);
    breakpoint_add(addr);
}
 
static void cmd_ct(int argc, char *argv[])
{
    int tid;
 
    link_t *cur;
    dthread_t *dt;
 
    (void)argc;
    tid = strtoul(argv[1], NULL, 0);
 
    dt = NULL;
    for (cur = dthreads.next; cur != &dthreads; cur = cur->next) {
        dt = list_get_instance(cur, dthread_t, link);
        if (dt->id == tid) break;
    }
   
    if (dt->id == tid) {
        cwt = dt;
        cons_printf("changed working thread to: %d [hash 0x%lx]\n",
            cwt->id, cwt->hash);
    } else {
        cons_printf("no such thread\n");
    }
}
 
static void cmd_dbreak(int argc, char *argv[])
{
    int bid;
 
    (void)argc;
    bid = strtoul(argv[1], NULL, 0);
 
    printf("remove breakpoint %d\n", bid);
 
//  arch_breakpoint_remove(bid);
    breakpoint_remove(bid);
}
 
 
void cmd_go(int argc, char *argv[])
{
    link_t *cur;
    dthread_t *dt;
 
    (void)argc; (void)argv;
 
    dt = NULL;
    for (cur = dthreads.next; cur != &dthreads; cur = cur->next) {
        dt = list_get_instance(cur, dthread_t, link);
        dthread_resume(dt);
    }  
}
 
void cmd_help(int argc, char *argv[])
{
    int i;
 
    (void)argc; (void)argv;
    i = 0;
    while (cmd_table[i].name != NULL) {
        cons_printf("%s\n", cmd_table[i].name);
        ++i;
    }
}
 
void cmd_istep(int argc, char *argv[])
{
    (void)argc; (void)argv;
 
    arch_singlestep(cwt);
}
 
static void cmd_lbrk(int argc, char *argv[])
{
    (void)argc; (void)argv;
 
    //arch_breakpoint_list();
    breakpoint_list();
}
 
 
#define BYTES_PER_LINE 16
 
static void cmd_memr(int argc, char *argv[])
{
    uintptr_t addr;
    size_t length;
    uint8_t buf[BYTES_PER_LINE];
    int to_read, i;
    int rc;
 
    (void)argc;
    addr = strtoul(argv[1], NULL, 0);
    length = strtoul(argv[2], NULL, 0);
 
    while (length > 0) {
        to_read = length < BYTES_PER_LINE ? length : BYTES_PER_LINE;
 
        rc = udebug_mem_read(app_phone, buf, addr, to_read);
        if (rc < 0) {
            cons_printf("error %d\n", rc);
            return;
        }
 
        cons_printf("0x%lx:", addr);
        for (i = 0; i < to_read; ++i) {
            cons_printf(" %02x", buf[i]);
        }
        for (i = to_read; i < BYTES_PER_LINE; ++i) {
            cons_printf("   ");
        }
 
        putchar ('\t');
 
        for (i = 0; i < to_read; ++i) {
            if (buf[i] >= 32 && buf[i] < 127)
                putchar(buf[i]);
            else
                putchar('.');
        }
        cons_printf("\n");
 
        addr += to_read;
        length -= to_read;
    }
}
 
void cmd_pwt(int argc, char *argv[])
{
    (void)argc; (void)argv;
 
    cons_printf("working thread: %d [hash 0x%x]\n", cwt->id, cwt->hash);
}
 
void cmd_regs(int argc, char *argv[])
{
    (void)argc; (void)argv;
 
    if (cwt) arch_dump_regs(cwt->hash);
}
 
void cmd_stop(int argc, char *argv[])
{
    link_t *cur;
    dthread_t *dt;
    int rc;
 
    (void)argc; (void)argv;
 
    dt = NULL;
    for (cur = dthreads.next; cur != &dthreads; cur = cur->next) {
        dt = list_get_instance(cur, dthread_t, link);
        if (!dt->stopped) {
            rc = udebug_stop(app_phone, dt->hash);
            if (rc < 0) {
                printf("failed halting thread %d\n", dt->id);
            }
        }
    }  
}
 
 
void cmd_threads(int argc, char *argv[])
{
    link_t *cur;
    dthread_t *dt;
 
    (void)argc;
 
    dt = NULL;
    for (cur = dthreads.next; cur != &dthreads; cur = cur->next) {
        dt = list_get_instance(cur, dthread_t, link);
        cons_printf("%d [hash 0x%lx]\n", dt->id, dt->hash);
    }  
}
 
 
static void cmd_quit(int argc, char *argv[])
{
    (void)argc; (void)argv;
    quit = true;
}
 
/** @}
 */
 

Rev 3093	Rev 4390
1	/*	1	/*
2	* Copyright (c) 2008 Jiri Svoboda	2	* Copyright (c) 2008 Jiri Svoboda
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup debug	29	/** @addtogroup debug
30	* @{	30	* @{
31	*/	31	*/
32	/** @file	32	/** @file
33	*/	33	*/
34		34
35	#include <stdio.h>	35	#include <stdio.h>
36	#include <stdlib.h>	36	#include <stdlib.h>
37	#include <string.h>	37	#include <string.h>
38	#include <bool.h>	38	#include <bool.h>
39	#include <udebug.h>	39	#include <udebug.h>
40	#include <sys/types.h>	40	#include <sys/types.h>
41		41
42	#include "main.h"	42	#include "main.h"
43	#include "cons.h"	43	#include "cons.h"
44	#include "dthread.h"	44	#include "dthread.h"
45	#include "breakpoint.h"	45	#include "breakpoint.h"
46	#include "include/arch.h"	46	#include "include/arch.h"
47	#include "cmd.h"	47	#include "cmd.h"
48		48
49	static void cmd_break(int argc, char *argv[]);	49	static void cmd_break(int argc, char *argv[]);
50	static void cmd_ct(int argc, char *argv[]);	50	static void cmd_ct(int argc, char *argv[]);
51	static void cmd_dbreak(int argc, char *argv[]);	51	static void cmd_dbreak(int argc, char *argv[]);
52	static void cmd_go(int argc, char *argv[]);	52	static void cmd_go(int argc, char *argv[]);
53	static void cmd_istep(int argc, char *argv[]);	53	static void cmd_istep(int argc, char *argv[]);
54	static void cmd_lbrk(int argc, char *argv[]);	54	static void cmd_lbrk(int argc, char *argv[]);
55	void cmd_help(int argc, char *argv[]);	55	void cmd_help(int argc, char *argv[]);
56	static void cmd_memr(int argc, char *argv[]);	56	static void cmd_memr(int argc, char *argv[]);
57	static void cmd_pwt(int argc, char *argv[]);	57	static void cmd_pwt(int argc, char *argv[]);
58	static void cmd_regs(int argc, char *argv[]);	58	static void cmd_regs(int argc, char *argv[]);
59	static void cmd_stop(int argc, char *argv[]);	59	static void cmd_stop(int argc, char *argv[]);
60	static void cmd_threads(int argc, char *argv[]);	60	static void cmd_threads(int argc, char *argv[]);
61	static void cmd_quit(int argc, char *argv[]);	61	static void cmd_quit(int argc, char *argv[]);
62		62
63	volatile bool quit = false;	63	volatile bool quit = false;
64		64
65	cmd_desc_t cmd_table[] = {	65	cmd_desc_t cmd_table[] = {
66	{ 1, "break", cmd_break },	66	{ 1, "break", cmd_break },
67	{ 1, "ct", cmd_ct },	67	{ 1, "ct", cmd_ct },
68	{ 1, "dbreak", cmd_dbreak },	68	{ 1, "dbreak", cmd_dbreak },
69	{ 0, "go", cmd_go },	69	{ 0, "go", cmd_go },
70	{ 0, "help", cmd_help },	70	{ 0, "help", cmd_help },
71	{ 2, "memr", cmd_memr },	71	{ 2, "memr", cmd_memr },
72	{ 0, "pwt", cmd_pwt },	72	{ 0, "pwt", cmd_pwt },
73	{ 0, "regs", cmd_regs },	73	{ 0, "regs", cmd_regs },
74	{ 0 , "stop", cmd_stop },	74	{ 0 , "stop", cmd_stop },
75	{ 0, "istep", cmd_istep },	75	{ 0, "istep", cmd_istep },
76	{ 0, "lbrk", cmd_lbrk },	76	{ 0, "lbrk", cmd_lbrk },
77	{ 0, "threads", cmd_threads },	77	{ 0, "threads", cmd_threads },
78	{ 0, "quit", cmd_quit },	78	{ 0, "quit", cmd_quit },
79	{ -1, NULL, NULL }	79	{ -1, NULL, NULL }
80	};	80	};
81		81
82	static void cmd_break(int argc, char *argv[])	82	static void cmd_break(int argc, char *argv[])
83	{	83	{
84	uintptr_t addr;	84	uintptr_t addr;
85		85
86	(void)argc;	86	(void)argc;
87	addr = strtoul(argv[1], NULL, 0);	87	addr = strtoul(argv[1], NULL, 0);
88		88
89	cons_printf("You requested a breakpoint at 0x%x\n", addr);	89	cons_printf("You requested a breakpoint at 0x%lx\n", addr);
90	// arch_breakpoint_add(addr);	90	// arch_breakpoint_add(addr);
91	breakpoint_add(addr);	91	breakpoint_add(addr);
92	}	92	}
93		93
94	static void cmd_ct(int argc, char *argv[])	94	static void cmd_ct(int argc, char *argv[])
95	{	95	{
96	int tid;	96	int tid;
97		97
98	link_t *cur;	98	link_t *cur;
99	dthread_t *dt;	99	dthread_t *dt;
100		100
101	(void)argc;	101	(void)argc;
102	tid = strtoul(argv[1], NULL, 0);	102	tid = strtoul(argv[1], NULL, 0);
103		103
104	dt = NULL;	104	dt = NULL;
105	for (cur = dthreads.next; cur != &dthreads; cur = cur->next) {	105	for (cur = dthreads.next; cur != &dthreads; cur = cur->next) {
106	dt = list_get_instance(cur, dthread_t, link);	106	dt = list_get_instance(cur, dthread_t, link);
107	if (dt->id == tid) break;	107	if (dt->id == tid) break;
108	}	108	}
109		109
110	if (dt->id == tid) {	110	if (dt->id == tid) {
111	cwt = dt;	111	cwt = dt;
112	cons_printf("changed working thread to: %d [hash 0x%x]\n",	112	cons_printf("changed working thread to: %d [hash 0x%lx]\n",
113	cwt->id, cwt->hash);	113	cwt->id, cwt->hash);
114	} else {	114	} else {
115	cons_printf("no such thread\n");	115	cons_printf("no such thread\n");
116	}	116	}
117	}	117	}
118		118
119	static void cmd_dbreak(int argc, char *argv[])	119	static void cmd_dbreak(int argc, char *argv[])
120	{	120	{
121	int bid;	121	int bid;
122		122
123	(void)argc;	123	(void)argc;
124	bid = strtoul(argv[1], NULL, 0);	124	bid = strtoul(argv[1], NULL, 0);
125		125
126	printf("remove breakpoint %d\n", bid);	126	printf("remove breakpoint %d\n", bid);
127		127
128	// arch_breakpoint_remove(bid);	128	// arch_breakpoint_remove(bid);
129	breakpoint_remove(bid);	129	breakpoint_remove(bid);
130	}	130	}
131		131
132		132
133	void cmd_go(int argc, char *argv[])	133	void cmd_go(int argc, char *argv[])
134	{	134	{
135	link_t *cur;	135	link_t *cur;
136	dthread_t *dt;	136	dthread_t *dt;
137		137
138	(void)argc; (void)argv;	138	(void)argc; (void)argv;
139		139
140	dt = NULL;	140	dt = NULL;
141	for (cur = dthreads.next; cur != &dthreads; cur = cur->next) {	141	for (cur = dthreads.next; cur != &dthreads; cur = cur->next) {
142	dt = list_get_instance(cur, dthread_t, link);	142	dt = list_get_instance(cur, dthread_t, link);
143	dthread_resume(dt);	143	dthread_resume(dt);
144	}	144	}
145	}	145	}
146		146
147	void cmd_help(int argc, char *argv[])	147	void cmd_help(int argc, char *argv[])
148	{	148	{
149	int i;	149	int i;
150		150
151	(void)argc; (void)argv;	151	(void)argc; (void)argv;
152	i = 0;	152	i = 0;
153	while (cmd_table[i].name != NULL) {	153	while (cmd_table[i].name != NULL) {
154	cons_printf("%s\n", cmd_table[i].name);	154	cons_printf("%s\n", cmd_table[i].name);
155	++i;	155	++i;
156	}	156	}
157	}	157	}
158		158
159	void cmd_istep(int argc, char *argv[])	159	void cmd_istep(int argc, char *argv[])
160	{	160	{
161	(void)argc; (void)argv;	161	(void)argc; (void)argv;
162		162
163	arch_singlestep(cwt);	163	arch_singlestep(cwt);
164	}	164	}
165		165
166	static void cmd_lbrk(int argc, char *argv[])	166	static void cmd_lbrk(int argc, char *argv[])
167	{	167	{
168	(void)argc; (void)argv;	168	(void)argc; (void)argv;
169		169
170	//arch_breakpoint_list();	170	//arch_breakpoint_list();
171	breakpoint_list();	171	breakpoint_list();
172	}	172	}
173		173
174		174
175	#define BYTES_PER_LINE 16	175	#define BYTES_PER_LINE 16
176		176
177	static void cmd_memr(int argc, char *argv[])	177	static void cmd_memr(int argc, char *argv[])
178	{	178	{
179	uintptr_t addr;	179	uintptr_t addr;
180	size_t length;	180	size_t length;
181	uint8_t buf[BYTES_PER_LINE];	181	uint8_t buf[BYTES_PER_LINE];
182	int to_read, i;	182	int to_read, i;
183	int rc;	183	int rc;
184		184
185	(void)argc;	185	(void)argc;
186	addr = strtoul(argv[1], NULL, 0);	186	addr = strtoul(argv[1], NULL, 0);
187	length = strtoul(argv[2], NULL, 0);	187	length = strtoul(argv[2], NULL, 0);
188		188
189	while (length > 0) {	189	while (length > 0) {
190	to_read = length < BYTES_PER_LINE ? length : BYTES_PER_LINE;	190	to_read = length < BYTES_PER_LINE ? length : BYTES_PER_LINE;
191		191
192	rc = udebug_mem_read(app_phone, buf, addr, to_read);	192	rc = udebug_mem_read(app_phone, buf, addr, to_read);
193	if (rc < 0) {	193	if (rc < 0) {
194	cons_printf("error %d\n", rc);	194	cons_printf("error %d\n", rc);
195	return;	195	return;
196	}	196	}
197		197
198	cons_printf("0x%x:", addr);	198	cons_printf("0x%lx:", addr);
199	for (i = 0; i < to_read; ++i) {	199	for (i = 0; i < to_read; ++i) {
200	cons_printf(" %02x", buf[i]);	200	cons_printf(" %02x", buf[i]);
201	}	201	}
202	for (i = to_read; i < BYTES_PER_LINE; ++i) {	202	for (i = to_read; i < BYTES_PER_LINE; ++i) {
203	cons_printf(" ");	203	cons_printf(" ");
204	}	204	}
205		205
206	putchar ('\t');	206	putchar ('\t');
207		207
208	for (i = 0; i < to_read; ++i) {	208	for (i = 0; i < to_read; ++i) {
209	if (buf[i] >= 32 && buf[i] < 127)	209	if (buf[i] >= 32 && buf[i] < 127)
210	putchar(buf[i]);	210	putchar(buf[i]);
211	else	211	else
212	putchar('.');	212	putchar('.');
213	}	213	}
214	cons_printf("\n");	214	cons_printf("\n");
215		215
216	addr += to_read;	216	addr += to_read;
217	length -= to_read;	217	length -= to_read;
218	}	218	}
219	}	219	}
220		220
221	void cmd_pwt(int argc, char *argv[])	221	void cmd_pwt(int argc, char *argv[])
222	{	222	{
223	(void)argc; (void)argv;	223	(void)argc; (void)argv;
224		224
225	cons_printf("working thread: %d [hash 0x%x]\n", cwt->id, cwt->hash);	225	cons_printf("working thread: %d [hash 0x%x]\n", cwt->id, cwt->hash);
226	}	226	}
227		227
228	void cmd_regs(int argc, char *argv[])	228	void cmd_regs(int argc, char *argv[])
229	{	229	{
230	(void)argc; (void)argv;	230	(void)argc; (void)argv;
231		231
232	if (cwt) arch_dump_regs(cwt->hash);	232	if (cwt) arch_dump_regs(cwt->hash);
233	}	233	}
234		234
235	void cmd_stop(int argc, char *argv[])	235	void cmd_stop(int argc, char *argv[])
236	{	236	{
237	link_t *cur;	237	link_t *cur;
238	dthread_t *dt;	238	dthread_t *dt;
239	int rc;	239	int rc;
240		240
241	(void)argc; (void)argv;	241	(void)argc; (void)argv;
242		242
243	dt = NULL;	243	dt = NULL;
244	for (cur = dthreads.next; cur != &dthreads; cur = cur->next) {	244	for (cur = dthreads.next; cur != &dthreads; cur = cur->next) {
245	dt = list_get_instance(cur, dthread_t, link);	245	dt = list_get_instance(cur, dthread_t, link);
246	if (!dt->stopped) {	246	if (!dt->stopped) {
247	rc = udebug_stop(app_phone, dt->hash);	247	rc = udebug_stop(app_phone, dt->hash);
248	if (rc < 0) {	248	if (rc < 0) {
249	printf("failed halting thread %d\n", dt->id);	249	printf("failed halting thread %d\n", dt->id);
250	}	250	}
251	}	251	}
252	}	252	}
253	}	253	}
254		254
255		255
256	void cmd_threads(int argc, char *argv[])	256	void cmd_threads(int argc, char *argv[])
257	{	257	{
258	link_t *cur;	258	link_t *cur;
259	dthread_t *dt;	259	dthread_t *dt;
260		260
261	(void)argc;	261	(void)argc;
262		262
263	dt = NULL;	263	dt = NULL;
264	for (cur = dthreads.next; cur != &dthreads; cur = cur->next) {	264	for (cur = dthreads.next; cur != &dthreads; cur = cur->next) {
265	dt = list_get_instance(cur, dthread_t, link);	265	dt = list_get_instance(cur, dthread_t, link);
266	cons_printf("%d [hash 0x%x]\n", dt->id, dt->hash);	266	cons_printf("%d [hash 0x%lx]\n", dt->id, dt->hash);
267	}	267	}
268	}	268	}
269		269
270		270
271	static void cmd_quit(int argc, char *argv[])	271	static void cmd_quit(int argc, char *argv[])
272	{	272	{
273	(void)argc; (void)argv;	273	(void)argc; (void)argv;
274	quit = true;	274	quit = true;
275	}	275	}
276		276
277	/** @}	277	/** @}
278	*/	278	*/
279		279

Subversion Repositories HelenOS

(root)/branches/tracing/uspace/app/debug/cmd.c @ 3001 – Rev 3093 → 4390