[apple/xnu.git] / osfmk / ddb / db_task_thread.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 * @OSF_COPYRIGHT@
 */
/* 
 * Mach Operating System
 * Copyright (c) 1991,1990 Carnegie Mellon University
 * All Rights Reserved.
 * 
 * Permission to use, copy, modify and distribute this software and its
 * documentation is hereby granted, provided that both the copyright
 * notice and this permission notice appear in all copies of the
 * software, derivative works or modified versions, and any portions
 * thereof, and that both notices appear in supporting documentation.
 * 
 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
 * 
 * Carnegie Mellon requests users of this software to return to
 * 
 *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
 *  School of Computer Science
 *  Carnegie Mellon University
 *  Pittsburgh PA 15213-3890
 * 
 * any improvements or extensions that they make and grant Carnegie Mellon
 * the rights to redistribute these changes.
 */
/*
 */

#include <kern/kern_types.h>
#include <kern/processor.h>
#include <machine/db_machdep.h>
#include <ddb/db_task_thread.h>
#include <ddb/db_variables.h>
#include <ddb/db_command.h>
#include <ddb/db_expr.h>
#include <ddb/db_lex.h>
#include <ddb/db_output.h>		/* For db_printf() */
#include <ddb/db_sym.h>

/*
 * Following constants are used to prevent infinite loop of task
 * or thread search due to the incorrect list.
 */
#define	DB_MAX_TASKID	0x10000		/* max # of tasks */
#define DB_MAX_THREADID	0x10000		/* max # of threads in a task */
#define DB_MAX_PSETS	0x10000		/* max # of processor sets */

task_t		db_default_task;	/* default target task */
thread_act_t	db_default_act;		/* default target thr_act */


/* Prototypes for functions local to this file.
 */
task_t db_lookup_task_id(register int task_id);

static thread_act_t db_lookup_act_id(
	task_t	 task,
	register int thread_id);


/*
 * search valid task queue, and return the queue position as the task id
 */
int
db_lookup_task(task_t target_task)
{
	register task_t task;
	register int task_id;
	register processor_set_t pset = &default_pset;
	register int npset = 0;

	task_id = 0;
	if (npset++ >= DB_MAX_PSETS)
		return(-1);
	if (queue_first(&pset->tasks) == 0)
		return(-1);
	queue_iterate(&pset->tasks, task, task_t, pset_tasks) {
		if (target_task == task)
		    return(task_id);
		if (task_id++ >= DB_MAX_TASKID)
		    return(-1);
	}
	return(-1);
}

/*
 * search thread queue of the task, and return the queue position
 */
int
db_lookup_task_act(
	task_t		task,
	thread_act_t	target_act)
{
	register thread_act_t thr_act;
	register int act_id;

	act_id = 0;
	if (queue_first(&task->threads) == 0)
	    return(-1);
	queue_iterate(&task->threads, thr_act, thread_act_t, task_threads) {
	    if (target_act == thr_act)
		return(act_id);
	    if (act_id++ >= DB_MAX_THREADID)
		return(-1);
	}
	return(-1);
}

/*
 * search thr_act queue of every valid task, and return the queue position
 * as the thread id.
 */
int
db_lookup_act(thread_act_t target_act)
{
	register int act_id;
	register task_t task;
	register processor_set_t pset = &default_pset;
	register int ntask = 0;
	register int npset = 0;

	if (npset++ >= DB_MAX_PSETS)
		return(-1);
	if (queue_first(&pset->tasks) == 0)
		return(-1);
	queue_iterate(&pset->tasks, task, task_t, pset_tasks) {
		if (ntask++ > DB_MAX_TASKID)
		    return(-1);
		if (task->thread_count == 0)
		    continue;
		act_id = db_lookup_task_act(task, target_act);
		if (act_id >= 0)
		    return(act_id);
	}
	return(-1);
}

/*
 * check the address is a valid thread address
 */
int force_act_lookup = 0;
boolean_t
db_check_act_address_valid(thread_act_t thr_act)
{
	if (!force_act_lookup && db_lookup_act(thr_act) < 0) {
	    db_printf("Bad thr_act address 0x%x\n", thr_act);
	    db_flush_lex();
	    return(FALSE);
	} else
	    return(TRUE);
}

/*
 * convert task_id(queue postion) to task address
 */
task_t
db_lookup_task_id(register task_id)
{
	register task_t task;
	register processor_set_t pset = &default_pset;
	register int npset = 0;

	if (task_id > DB_MAX_TASKID)
	    return(TASK_NULL);
	if (npset++ >= DB_MAX_PSETS)
		return(TASK_NULL);
	if (queue_first(&pset->tasks) == 0)
		return(TASK_NULL);
	queue_iterate(&pset->tasks, task, task_t, pset_tasks) {
		if (task_id-- <= 0)
			return(task);
	}
	return(TASK_NULL);
}

/*
 * convert (task_id, act_id) pair to thr_act address
 */
static thread_act_t
db_lookup_act_id(
	task_t	 task,
	register int act_id)
{
	register thread_act_t thr_act;

	
	if (act_id > DB_MAX_THREADID)
	    return(THR_ACT_NULL);
	if (queue_first(&task->threads) == 0)
	    return(THR_ACT_NULL);
	queue_iterate(&task->threads, thr_act, thread_act_t, task_threads) {
	    if (act_id-- <= 0)
		return(thr_act);
	}
	return(THR_ACT_NULL);
}

/*
 * get next parameter from a command line, and check it as a valid
 * thread address
 */
boolean_t
db_get_next_act(
	thread_act_t	*actp,
	int		position)
{
	db_expr_t	value;
	thread_act_t	thr_act;

	*actp = THR_ACT_NULL;
	if (db_expression(&value)) {
	    thr_act = (thread_act_t) value;
	    if (!db_check_act_address_valid(thr_act)) {
		db_flush_lex();
		return(FALSE);
	    }
	} else if (position <= 0) {
	    thr_act = db_default_act;
	} else
	    return(FALSE);
	*actp = thr_act;
	return(TRUE);
}

/*
 * check the default thread is still valid
 *	( it is called in entering DDB session )
 */
void
db_init_default_act(void)
{
	if (db_lookup_act(db_default_act) < 0) {
	    db_default_act = THR_ACT_NULL;
	    db_default_task = TASK_NULL;
	} else
	    db_default_task = db_default_act->task;
}

/*
 * set or get default thread which is used when /t or :t option is specified
 * in the command line
 */
int
db_set_default_act(
	struct db_variable	*vp,
	db_expr_t		*valuep,
	int			flag,
	db_var_aux_param_t	ap)			/* unused */
{
	thread_act_t	thr_act;
	int		task_id;
	int		act_id;

	if (flag == DB_VAR_SHOW) {
	    db_printf("%#n", db_default_act);
	    task_id = db_lookup_task(db_default_task);
	    if (task_id != -1) {
		act_id = db_lookup_act(db_default_act);
		if (act_id != -1) {
		    db_printf(" (task%d.%d)", task_id, act_id);
		}
	    }
	    return(0);
	}

	if (flag != DB_VAR_SET) {
	    *valuep = (db_expr_t) db_default_act;
	    return(0);
	}
	thr_act = (thread_act_t) *valuep;
	if (thr_act != THR_ACT_NULL && !db_check_act_address_valid(thr_act))
	    db_error(0);
	    /* NOTREACHED */
	db_default_act = thr_act;
	if (thr_act)
		db_default_task = thr_act->task;
	return(0);
}

/*
 * convert $taskXXX[.YYY] type DDB variable to task or thread address
 */
int
db_get_task_act(
	struct db_variable	*vp,
	db_expr_t		*valuep,
	int			flag,
	db_var_aux_param_t	ap)
{
	task_t	 		task;
	thread_act_t		thr_act;
	int	 		task_id;

	if (flag == DB_VAR_SHOW) {
	    db_printf("%#n", db_default_task);
	    task_id = db_lookup_task(db_default_task);
	    if (task_id != -1)
		db_printf(" (task%d)", task_id);
	    return(0);
	}

	if (flag != DB_VAR_GET) {
	    db_error("Cannot set to $task variable\n");
	    /* NOTREACHED */
	}
	if ((task = db_lookup_task_id(ap->suffix[0])) == TASK_NULL) {
	    db_printf("no such task($task%d)\n", ap->suffix[0]);
	    db_error(0);
	    /* NOTREACHED */
	}
	if (ap->level <= 1) {
	    *valuep = (db_expr_t) task;
	    return(0);
	}
	if ((thr_act = db_lookup_act_id(task, ap->suffix[1])) == THR_ACT_NULL){
	    db_printf("no such thr_act($task%d.%d)\n", 
					ap->suffix[0], ap->suffix[1]);
	    db_error(0);
	    /* NOTREACHED */
	}
	*valuep = (db_expr_t) thr_act;
	return(0);
}
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
43866e37	6	* Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved.
1c79356b	7	*
43866e37 A	8	* This file contains Original Code and/or Modifications of Original Code
	9	* as defined in and that are subject to the Apple Public Source License
	10	* Version 2.0 (the 'License'). You may not use this file except in
	11	* compliance with the License. Please obtain a copy of the License at
	12	* http://www.opensource.apple.com/apsl/ and read it before using this
	13	* file.
	14	*
	15	* The Original Code and all software distributed under the License are
	16	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
1c79356b A	17	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
1c79356b A	18	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
43866e37 A	19	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	20	* Please see the License for the specific language governing rights and
	21	* limitations under the License.
1c79356b A	22	*
	23	* @APPLE_LICENSE_HEADER_END@
	24	*/
	25	/*
	26	* @OSF_COPYRIGHT@
	27	*/
1c79356b A	28	/*
	29	* Mach Operating System
	30	* Copyright (c) 1991,1990 Carnegie Mellon University
	31	* All Rights Reserved.
	32	*
	33	* Permission to use, copy, modify and distribute this software and its
	34	* documentation is hereby granted, provided that both the copyright
	35	* notice and this permission notice appear in all copies of the
	36	* software, derivative works or modified versions, and any portions
	37	* thereof, and that both notices appear in supporting documentation.
	38	*
	39	* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
	40	* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
	41	* ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
	42	*
	43	* Carnegie Mellon requests users of this software to return to
	44	*
	45	* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
	46	* School of Computer Science
	47	* Carnegie Mellon University
	48	* Pittsburgh PA 15213-3890
	49	*
	50	* any improvements or extensions that they make and grant Carnegie Mellon
	51	* the rights to redistribute these changes.
	52	*/
	53	/*
	54	*/
	55
	56	#include <kern/kern_types.h>
	57	#include <kern/processor.h>
	58	#include <machine/db_machdep.h>
	59	#include <ddb/db_task_thread.h>
	60	#include <ddb/db_variables.h>
	61	#include <ddb/db_command.h>
	62	#include <ddb/db_expr.h>
	63	#include <ddb/db_lex.h>
	64	#include <ddb/db_output.h> /* For db_printf() */
	65	#include <ddb/db_sym.h>
	66
	67	/*
	68	* Following constants are used to prevent infinite loop of task
	69	* or thread search due to the incorrect list.
	70	*/
	71	#define DB_MAX_TASKID 0x10000 /* max # of tasks */
	72	#define DB_MAX_THREADID 0x10000 /* max # of threads in a task */
	73	#define DB_MAX_PSETS 0x10000 /* max # of processor sets */
	74
	75	task_t db_default_task; /* default target task */
	76	thread_act_t db_default_act; /* default target thr_act */
	77
	78
	79
	80	/* Prototypes for functions local to this file.
	81	*/
	82	task_t db_lookup_task_id(register int task_id);
	83
	84	static thread_act_t db_lookup_act_id(
	85	task_t task,
	86	register int thread_id);
	87
	88
	89
	90	/*
	91	* search valid task queue, and return the queue position as the task id
92	*/
93	int
94	db_lookup_task(task_t target_task)
95	{
96	register task_t task;
97	register int task_id;
98	register processor_set_t pset = &default_pset;
99	register int npset = 0;
100
101	task_id = 0;
102	if (npset++ >= DB_MAX_PSETS)
103	return(-1);
104	if (queue_first(&pset->tasks) == 0)
105	return(-1);
106	queue_iterate(&pset->tasks, task, task_t, pset_tasks) {
107	if (target_task == task)
108	return(task_id);
109	if (task_id++ >= DB_MAX_TASKID)
110	return(-1);
111	}
112	return(-1);
113	}
114
115	/*
116	* search thread queue of the task, and return the queue position
117	*/
118	int
119	db_lookup_task_act(
120	task_t task,
121	thread_act_t target_act)
122	{
123	register thread_act_t thr_act;
124	register int act_id;
125
126	act_id = 0;
55e303ae	127	if (queue_first(&task->threads) == 0)
1c79356b	128	return(-1);
55e303ae	129	queue_iterate(&task->threads, thr_act, thread_act_t, task_threads) {
1c79356b A	130	if (target_act == thr_act)
	131	return(act_id);
	132	if (act_id++ >= DB_MAX_THREADID)
	133	return(-1);
	134	}
	135	return(-1);
	136	}
	137
	138	/*
	139	* search thr_act queue of every valid task, and return the queue position
	140	* as the thread id.
	141	*/
	142	int
	143	db_lookup_act(thread_act_t target_act)
	144	{
	145	register int act_id;
	146	register task_t task;
	147	register processor_set_t pset = &default_pset;
	148	register int ntask = 0;
	149	register int npset = 0;
	150
	151	if (npset++ >= DB_MAX_PSETS)
	152	return(-1);
	153	if (queue_first(&pset->tasks) == 0)
	154	return(-1);
	155	queue_iterate(&pset->tasks, task, task_t, pset_tasks) {
	156	if (ntask++ > DB_MAX_TASKID)
	157	return(-1);
55e303ae	158	if (task->thread_count == 0)
1c79356b A	159	continue;
	160	act_id = db_lookup_task_act(task, target_act);
	161	if (act_id >= 0)
	162	return(act_id);
	163	}
	164	return(-1);
	165	}
	166
	167	/*
	168	* check the address is a valid thread address
	169	*/
	170	int force_act_lookup = 0;
	171	boolean_t
	172	db_check_act_address_valid(thread_act_t thr_act)
	173	{
	174	if (!force_act_lookup && db_lookup_act(thr_act) < 0) {
	175	db_printf("Bad thr_act address 0x%x\n", thr_act);
	176	db_flush_lex();
	177	return(FALSE);
	178	} else
	179	return(TRUE);
	180	}
	181
	182	/*
	183	* convert task_id(queue postion) to task address
	184	*/
	185	task_t
	186	db_lookup_task_id(register task_id)
	187	{
	188	register task_t task;
	189	register processor_set_t pset = &default_pset;
	190	register int npset = 0;
	191
	192	if (task_id > DB_MAX_TASKID)
	193	return(TASK_NULL);
	194	if (npset++ >= DB_MAX_PSETS)
	195	return(TASK_NULL);
	196	if (queue_first(&pset->tasks) == 0)
	197	return(TASK_NULL);
	198	queue_iterate(&pset->tasks, task, task_t, pset_tasks) {
	199	if (task_id-- <= 0)
	200	return(task);
	201	}
	202	return(TASK_NULL);
	203	}
	204
	205	/*
	206	* convert (task_id, act_id) pair to thr_act address
	207	*/
	208	static thread_act_t
	209	db_lookup_act_id(
	210	task_t task,
	211	register int act_id)
	212	{
	213	register thread_act_t thr_act;
	214
	215
	216	if (act_id > DB_MAX_THREADID)
	217	return(THR_ACT_NULL);
55e303ae	218	if (queue_first(&task->threads) == 0)
1c79356b	219	return(THR_ACT_NULL);
55e303ae	220	queue_iterate(&task->threads, thr_act, thread_act_t, task_threads) {
1c79356b A	221	if (act_id-- <= 0)
	222	return(thr_act);
	223	}
	224	return(THR_ACT_NULL);
	225	}
	226
	227	/*
	228	* get next parameter from a command line, and check it as a valid
	229	* thread address
	230	*/
	231	boolean_t
	232	db_get_next_act(
	233	thread_act_t *actp,
	234	int position)
	235	{
	236	db_expr_t value;
	237	thread_act_t thr_act;
	238
	239	*actp = THR_ACT_NULL;
	240	if (db_expression(&value)) {
	241	thr_act = (thread_act_t) value;
	242	if (!db_check_act_address_valid(thr_act)) {
	243	db_flush_lex();
	244	return(FALSE);
	245	}
	246	} else if (position <= 0) {
	247	thr_act = db_default_act;
	248	} else
	249	return(FALSE);
	250	*actp = thr_act;
	251	return(TRUE);
	252	}
	253
	254	/*
	255	* check the default thread is still valid
	256	* ( it is called in entering DDB session )
	257	*/
	258	void
	259	db_init_default_act(void)
	260	{
	261	if (db_lookup_act(db_default_act) < 0) {
	262	db_default_act = THR_ACT_NULL;
	263	db_default_task = TASK_NULL;
	264	} else
	265	db_default_task = db_default_act->task;
	266	}
	267
	268	/*
	269	* set or get default thread which is used when /t or :t option is specified
	270	* in the command line
	271	*/
	272	int
	273	db_set_default_act(
	274	struct db_variable *vp,
	275	db_expr_t *valuep,
	276	int flag,
	277	db_var_aux_param_t ap) /* unused */
	278	{
	279	thread_act_t thr_act;
	280	int task_id;
	281	int act_id;
	282
	283	if (flag == DB_VAR_SHOW) {
	284	db_printf("%#n", db_default_act);
285	task_id = db_lookup_task(db_default_task);
286	if (task_id != -1) {
287	act_id = db_lookup_act(db_default_act);
288	if (act_id != -1) {
289	db_printf(" (task%d.%d)", task_id, act_id);
290	}
291	}
292	return(0);
293	}
294
295	if (flag != DB_VAR_SET) {
296	*valuep = (db_expr_t) db_default_act;
297	return(0);
298	}
299	thr_act = (thread_act_t) *valuep;
300	if (thr_act != THR_ACT_NULL && !db_check_act_address_valid(thr_act))
301	db_error(0);
302	/* NOTREACHED */
303	db_default_act = thr_act;
304	if (thr_act)
305	db_default_task = thr_act->task;
306	return(0);
307	}
308
309	/*
310	* convert $taskXXX[.YYY] type DDB variable to task or thread address
311	*/
312	int
313	db_get_task_act(
314	struct db_variable *vp,
315	db_expr_t *valuep,
316	int flag,
317	db_var_aux_param_t ap)
318	{
319	task_t task;
320	thread_act_t thr_act;
321	int task_id;
322
323	if (flag == DB_VAR_SHOW) {
324	db_printf("%#n", db_default_task);
325	task_id = db_lookup_task(db_default_task);
326	if (task_id != -1)
327	db_printf(" (task%d)", task_id);
328	return(0);
329	}
330
331	if (flag != DB_VAR_GET) {
332	db_error("Cannot set to $task variable\n");
333	/* NOTREACHED */
334	}
335	if ((task = db_lookup_task_id(ap->suffix[0])) == TASK_NULL) {
336	db_printf("no such task($task%d)\n", ap->suffix[0]);
337	db_error(0);
338	/* NOTREACHED */
339	}
340	if (ap->level <= 1) {
341	*valuep = (db_expr_t) task;
342	return(0);
343	}
344	if ((thr_act = db_lookup_act_id(task, ap->suffix[1])) == THR_ACT_NULL){
345	db_printf("no such thr_act($task%d.%d)\n",
346	ap->suffix[0], ap->suffix[1]);
347	db_error(0);
348	/* NOTREACHED */
349	}
350	*valuep = (db_expr_t) thr_act;
351	return(0);
352	}