 @@ -1,14 +1,14 @@
-/*	$NetBSD: pthread_dbg.c,v 1.43 2015/05/29 07:37:32 manu Exp $	*/
+/*	$NetBSD: pthread_dbg.c,v 1.44 2016/01/23 14:02:21 christos Exp $	*/
 /*-
  * Copyright (c) 2002 Wasabi Systems, Inc.
  * All rights reserved.
+ *
  * Written by Nathan J. Williams for Wasabi Systems, Inc.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
 @@ -26,49 +26,51 @@
  * 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 WASABI SYSTEMS, INC
  * 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.
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: pthread_dbg.c,v 1.43 2015/05/29 07:37:32 manu Exp $");
+__RCSID("$NetBSD: pthread_dbg.c,v 1.44 2016/01/23 14:02:21 christos Exp $");
 #define __EXPOSE_STACK 1
 #include <sys/param.h>
 #include <sys/types.h>
 #include <sys/lock.h>
 #include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 #include <unistd.h>
 #include <lwp.h>
 #include <machine/reg.h>
 #include <pthread.h>
 #include <pthread_int.h>
 #include <pthread_dbg.h>
 #include <pthread_dbg_int.h>
 #define PT_STACKMASK (proc->stackmask)
 #define OFFSET(thread, field) \
     (((char *)(thread)->addr) + offsetof(struct __pthread_st, field))
 /* Compensate for debuggers that want a zero ID to be a sentinel */
 #define TN_OFFSET 1
 static int td__getthread(td_proc_t *proc, caddr_t addr, td_thread_t **threadp);
 int
 td_open(struct td_proc_callbacks_t *cb, void *arg, td_proc_t **procp)
+{
 	td_proc_t *proc;
 	caddr_t addr;
 	int dbg;
 	int val;
 @@ -206,132 +208,125 @@ td_thr_iter(td_proc_t *proc, int (*call)
 int
 td_thr_info(td_thread_t *thread, td_thread_info_t *info)
+{
 	int tmp, val;
 	val = READ(thread->proc, thread->addr, &tmp, sizeof(tmp));
 	if (val != 0)
 		return val;
 	if (tmp != PT_MAGIC)
 		return TD_ERR_BADTHREAD;
 	info->thread_addr = thread->addr;
 	if ((val = READ(thread->proc,
-		      thread->addr + offsetof(struct __pthread_st, pt_state),
+	    OFFSET(thread, pt_state), &tmp, sizeof(tmp))) != 0)
 		      &tmp, sizeof(tmp))) != 0)
 		return val;
 	switch (tmp) {
 	case PT_STATE_RUNNING:
 		info->thread_state = TD_STATE_RUNNING;
 		break;
 #ifdef XXXLWP
 	case PT_STATE_SUSPENDED:
 		info->thread_state = TD_STATE_SUSPENDED;
 		break;
 #endif
 	case PT_STATE_ZOMBIE:
 		info->thread_state = TD_STATE_ZOMBIE;
 		break;
 	default:
 		info->thread_state = TD_STATE_UNKNOWN;
+	}
 	info->thread_type = TD_TYPE_USER;
-	if ((val = READ(thread->proc,
+	if ((val = READ(thread->proc, OFFSET(thread, pt_stack),
 	    thread->addr + offsetof(struct __pthread_st, pt_stack),
 	    &info->thread_stack, sizeof(stack_t))) != 0)
 		return val;
-	if ((val = READ(thread->proc,
+	if ((val = READ(thread->proc, OFFSET(thread, pt_errno),
 	    thread->addr + offsetof(struct __pthread_st, pt_errno),
 	    &info->thread_errno, sizeof(info->thread_errno))) != 0)
 		return val;
-	if ((val = READ(thread->proc,
+	if ((val = READ(thread->proc, OFFSET(thread, pt_lid),
 	    thread->addr + offsetof(struct __pthread_st, pt_lid),
 	    &info->thread_id, sizeof(info->thread_id))) != 0)
 		return val;
 	info->thread_id += TN_OFFSET;
 	return 0;
+}
 int
 td_thr_getname(td_thread_t *thread, char *name, int len)
+{
 	int val, tmp;
 	caddr_t nameaddr;
 	val = READ(thread->proc, thread->addr, &tmp, sizeof(tmp));
 	if (val != 0)
 		return val;
 	if (tmp != PT_MAGIC)
 		return TD_ERR_BADTHREAD;
-	if ((val = READ(thread->proc,
+	if ((val = READ(thread->proc, OFFSET(thread, pt_name),
 	    thread->addr + offsetof(struct __pthread_st, pt_name),
 	    &nameaddr, sizeof(nameaddr))) != 0)
 		return val;
 	if (nameaddr == 0)
 		name[0] = '\0';
 	else if ((val = READ(thread->proc, nameaddr,
 	    name, (size_t)MIN(PTHREAD_MAX_NAMELEN_NP, len))) != 0)
 		return val;
 	return 0;
+}
 int
 td_thr_getregs(td_thread_t *thread, int regset, void *buf)
+{
 	int tmp, val;
-	if ((val = READ(thread->proc,
+	if ((val = READ(thread->proc, OFFSET(thread, pt_state),
-		      thread->addr + offsetof(struct __pthread_st, pt_state),
+	    &tmp, sizeof(tmp))) != 0)
 		      &tmp, sizeof(tmp))) != 0)
 		return val;
 	switch (tmp) {
 	case PT_STATE_RUNNING:
 		/*
 		 * The register state of the thread is live in the
 		 * inferior process's register state.
 		 */
 		val = GETREGS(thread->proc, regset, thread->lwp, buf);
 		if (val != 0)
 			return val;
 		break;
 	case PT_STATE_ZOMBIE:
 	default:
 		return TD_ERR_BADTHREAD;
+	}
 	return 0;
+}
 int
 td_thr_setregs(td_thread_t *thread, int regset, void *buf)
+{
 	int val, tmp;
-	if ((val = READ(thread->proc,
+	if ((val = READ(thread->proc, OFFSET(thread, pt_state),
-		      thread->addr + offsetof(struct __pthread_st, pt_state),
+	    &tmp, sizeof(tmp))) != 0)
 		      &tmp, sizeof(tmp))) != 0)
 		return val;
 	switch (tmp) {
 	case PT_STATE_RUNNING:
 		/*
 		 * The register state of the thread is live in the
 		 * inferior process's register state.
 		 */
 		val = SETREGS(thread->proc, regset, thread->lwp, buf);
 		if (val != 0)
 			return val;
 		break;
 	case PT_STATE_ZOMBIE:
 @@ -368,28 +363,27 @@ td_map_id2thr(td_proc_t *proc, int threa
 	caddr_t next;
 	pthread_queue_t allq;
 	td_thread_t *thread;
 	val = READ(proc, proc->allqaddr, &allq, sizeof(allq));
 	if (val != 0)
 		return val;
 	/* Correct for offset */
 	threadid -= TN_OFFSET;
 	next = (void *)allq.ptqh_first;
 	while (next != NULL) {
-		val = READ(proc,
+		val = READ(proc, next + offsetof(struct __pthread_st, pt_lid),
 		    next + offsetof(struct __pthread_st, pt_lid),
 		    &num, sizeof(num));
 		if (num == threadid)
 			break;
 		val = READ(proc,
 		    next + offsetof(struct __pthread_st, pt_allq.ptqe_next),
 		    &next, sizeof(next));
 		if (val != 0)
 			return val;
+	}
 	if (next == 0) {
 @@ -443,53 +437,49 @@ td_tsd_iter(td_proc_t *proc,
 /* Suspend a thread from running */
 int
 td_thr_suspend(td_thread_t *thread)
+{
 	int tmp, val;
 	/* validate the thread */
 	val = READ(thread->proc, thread->addr, &tmp, sizeof(tmp));
 	if (val != 0)
 		return val;
 	if (tmp != PT_MAGIC)
 		return TD_ERR_BADTHREAD;
-	val = READ(thread->proc, thread->addr +
+	val = READ(thread->proc, OFFSET(thread, pt_lid), &tmp, sizeof(tmp));
 	    offsetof(struct __pthread_st, pt_lid),
 	    &tmp, sizeof(tmp));
 	if (val != 0)
 		return val;
 	/* XXXLWP continue the sucker */;
 	return 0;
+}
 /* Restore a suspended thread to its previous state */
 int
 td_thr_resume(td_thread_t *thread)
+{
 	int tmp, val;
 	/* validate the thread */
 	val = READ(thread->proc, thread->addr, &tmp, sizeof(tmp));
 	if (val != 0)
 		return val;
 	if (tmp != PT_MAGIC)
 		return TD_ERR_BADTHREAD;
-	val = READ(thread->proc, thread->addr +
+	val = READ(thread->proc, OFFSET(thread, pt_lid), &tmp, sizeof(tmp));
 	    offsetof(struct __pthread_st, pt_lid),
 	    &tmp, sizeof(tmp));
 	if (val != 0)
 		return val;
 	/* XXXLWP continue the sucker */;
 	return 0;
+}
 static int
 td__getthread(td_proc_t *proc, caddr_t addr, td_thread_t **threadp)
+{
 	td_thread_t *thread;
 @@ -512,19 +502,18 @@ td__getthread(td_proc_t *proc, caddr_t a
 		thread->lwp  = 0;
 		PTQ_INSERT_HEAD(&proc->threads, thread, list);
+	}
 	*threadp = thread;
 	return 0;
+}
 int
 td_thr_tsd(td_thread_t *thread, pthread_key_t key, void **value)
+{
 	int val;
-	val = READ(thread->proc, thread->addr +
+	val = READ(thread->proc, OFFSET(thread, pt_specific) +
 	    offsetof(struct __pthread_st, pt_specific) +
 	    key * sizeof(void *), value, sizeof(*value));
 	return val;
+}

 @@ -1,48 +1,48 @@
 PTQ_HEAD(thread_queue_t, td_thread_st);
 PTQ_HEAD(sync_queue_t, td_sync_st);
 struct td_proc_st {
 	struct td_proc_callbacks_t *cb;
 	void *arg;
-	caddr_t dbgaddr;
+	void *dbgaddr;
-	caddr_t allqaddr;
+	void *allqaddr;
-	caddr_t runqaddr;
+	void *runqaddr;
-	caddr_t idleqaddr;
+	void *idleqaddr;
-	caddr_t suspqaddr;
+	void *suspqaddr;
-	caddr_t maxlwpsaddr;
+	void *maxlwpsaddr;
-	caddr_t tsdlistaddr;
+	void *tsdlistaddr;
-	caddr_t tsddestaddr;
+	void *tsddestaddr;
-	caddr_t stacksizeaddr;
+	void *stacksizeaddr;
 	int stacksizelg;
 	size_t stacksize;
-	vaddr_t stackmask;
+	uintptr_t stackmask;
 	struct reg *regbuf;
 	struct fpreg *fpregbuf;
 	struct thread_queue_t threads;
 };
 struct td_thread_st {
 	td_proc_t *proc;
-	caddr_t addr;
+	void *addr;
 	lwpid_t lwp;
 	PTQ_ENTRY(td_thread_st)	list;
 };
 struct td_sync_st {
 	td_proc_t *proc;
-	caddr_t addr;
+	void *addr;
 	PTQ_ENTRY(td_sync_st) list;
 };
 #define READ(proc, addr, buf, size) ((proc)->cb->proc_read((proc)->arg, (addr), (buf), (size)))
 #define WRITE(proc, addr, buf, size) ((proc)->cb->proc_write((proc)->arg, (addr), (buf), (size)))
 #define LOOKUP(proc, sym, addr) ((proc)->cb->proc_lookup((proc)->arg, (sym), (addr)))
 #define REGSIZE(proc, regset, size) ((proc)->cb->proc_regsize((proc)->arg, (regset), (size)))
 #define GETREGS(proc, regset, lwp, buf) ((proc)->cb->proc_getregs((proc)->arg, (regset), (lwp), (buf)))
 #define SETREGS(proc, regset, lwp, buf) ((proc)->cb->proc_setregs((proc)->arg, (regset), (lwp), (buf)))