Author: des
Date: Tue Jun  9 00:47:54 2009
New Revision: 193789
URL: http://svn.freebsd.org/changeset/base/193789

Log:
  merge r180982,r181044,r181059,r181065,r181341,r183021: WARNS cleanup,
  add thr_pread_{int,long,ptr} and thr_pwrite_{int,long,ptr}, and change
  definition of psaddr_t (no impact on ABI).  Discussed with marcel@, but
  any screwups are my own.

Modified:
  stable/7/lib/libthr/   (props changed)
  stable/7/lib/libthread_db/   (props changed)
  stable/7/lib/libthread_db/Makefile
  stable/7/lib/libthread_db/arch/amd64/libpthread_md.c
  stable/7/lib/libthread_db/arch/arm/libpthread_md.c
  stable/7/lib/libthread_db/arch/i386/libpthread_md.c
  stable/7/lib/libthread_db/arch/ia64/libpthread_md.c
  stable/7/lib/libthread_db/arch/powerpc/libpthread_md.c
  stable/7/lib/libthread_db/arch/sparc64/libpthread_md.c
  stable/7/lib/libthread_db/libpthread_db.c
  stable/7/lib/libthread_db/libpthread_db.h
  stable/7/lib/libthread_db/libthr_db.c
  stable/7/lib/libthread_db/thread_db.c
  stable/7/lib/libthread_db/thread_db.h
  stable/7/lib/libthread_db/thread_db_int.h
  stable/7/sys/   (props changed)
  stable/7/sys/contrib/pf/   (props changed)
  stable/7/sys/dev/ath/ath_hal/   (props changed)
  stable/7/sys/dev/cxgb/   (props changed)
  stable/7/sys/sys/procfs.h

Modified: stable/7/lib/libthread_db/Makefile
==============================================================================
--- stable/7/lib/libthread_db/Makefile  Tue Jun  9 00:27:23 2009        
(r193788)
+++ stable/7/lib/libthread_db/Makefile  Tue Jun  9 00:47:54 2009        
(r193789)
@@ -8,7 +8,7 @@ SRCS=   thread_db.c
 SRCS+= libpthread_db.c libpthread_md.c
 SRCS+= libthr_db.c
 INCS=  thread_db.h
-WARNS?= 1
+WARNS?= 6
 
 CFLAGS+=-I. -I${.CURDIR}
 SYM_MAPS+=${.CURDIR}/Symbol.map

Modified: stable/7/lib/libthread_db/arch/amd64/libpthread_md.c
==============================================================================
--- stable/7/lib/libthread_db/arch/amd64/libpthread_md.c        Tue Jun  9 
00:27:23 2009        (r193788)
+++ stable/7/lib/libthread_db/arch/amd64/libpthread_md.c        Tue Jun  9 
00:47:54 2009        (r193789)
@@ -30,8 +30,11 @@ __FBSDID("$FreeBSD$");
 
 #include <sys/procfs.h>
 #include <string.h>
+#include <thread_db.h>
 #include <ucontext.h>
 
+#include "libpthread_db.h"
+
 void
 pt_reg_to_ucontext(const struct reg *r, ucontext_t *uc)
 {

Modified: stable/7/lib/libthread_db/arch/arm/libpthread_md.c
==============================================================================
--- stable/7/lib/libthread_db/arch/arm/libpthread_md.c  Tue Jun  9 00:27:23 
2009        (r193788)
+++ stable/7/lib/libthread_db/arch/arm/libpthread_md.c  Tue Jun  9 00:47:54 
2009        (r193789)
@@ -27,9 +27,8 @@
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-#include <string.h>
 #include <sys/types.h>
-#include <proc_service.h>
+#include <string.h>
 #include <thread_db.h>
 
 #include "libpthread_db.h"
@@ -86,7 +85,7 @@ pt_ucontext_to_reg(const ucontext_t *uc,
 }
 
 void
-pt_fpreg_to_ucontext(const struct fpreg *r, ucontext_t *uc)
+pt_fpreg_to_ucontext(const struct fpreg *r __unused, ucontext_t *uc)
 {
        mcontext_t *mc = &uc->uc_mcontext;
 
@@ -95,9 +94,8 @@ pt_fpreg_to_ucontext(const struct fpreg 
 }
 
 void
-pt_ucontext_to_fpreg(const ucontext_t *uc, struct fpreg *r)
+pt_ucontext_to_fpreg(const ucontext_t *uc __unused, struct fpreg *r)
 {
-       const mcontext_t *mc = &uc->uc_mcontext;
 
        /* XXX */
        memset(r, 0, sizeof(*r));
@@ -109,8 +107,9 @@ pt_md_init(void)
 }
 
 int
-pt_reg_sstep(struct reg *reg, int step)
+pt_reg_sstep(struct reg *reg __unused, int step __unused)
 {
 
        /* XXX */
+       return (0);
 }

Modified: stable/7/lib/libthread_db/arch/i386/libpthread_md.c
==============================================================================
--- stable/7/lib/libthread_db/arch/i386/libpthread_md.c Tue Jun  9 00:27:23 
2009        (r193788)
+++ stable/7/lib/libthread_db/arch/i386/libpthread_md.c Tue Jun  9 00:47:54 
2009        (r193789)
@@ -27,11 +27,10 @@
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-#include <string.h>
 #include <sys/types.h>
-#include <proc_service.h>
-#include <thread_db.h>
 #include <machine/npx.h>
+#include <string.h>
+#include <thread_db.h>
 
 #include "libpthread_db.h"
 

Modified: stable/7/lib/libthread_db/arch/ia64/libpthread_md.c
==============================================================================
--- stable/7/lib/libthread_db/arch/ia64/libpthread_md.c Tue Jun  9 00:27:23 
2009        (r193788)
+++ stable/7/lib/libthread_db/arch/ia64/libpthread_md.c Tue Jun  9 00:47:54 
2009        (r193789)
@@ -28,25 +28,28 @@
 __FBSDID("$FreeBSD$");
 
 #include <sys/procfs.h>
+#include <thread_db.h>
 #include <ucontext.h>
 
+#include "libpthread_db.h"
+
 void
-pt_reg_to_ucontext(const struct reg *r, ucontext_t *uc)
+pt_reg_to_ucontext(const struct reg *r __unused, ucontext_t *uc __unused)
 {
 }
 
 void
-pt_ucontext_to_reg(const ucontext_t *uc, struct reg *r)
+pt_ucontext_to_reg(const ucontext_t *uc __unused, struct reg *r __unused)
 {
 }
 
 void
-pt_fpreg_to_ucontext(const struct fpreg* r, ucontext_t *uc)
+pt_fpreg_to_ucontext(const struct fpreg* r __unused, ucontext_t *uc __unused)
 {
 }
 
 void
-pt_ucontext_to_fpreg(const ucontext_t *uc, struct fpreg *r)
+pt_ucontext_to_fpreg(const ucontext_t *uc __unused, struct fpreg *r __unused)
 {
 }
 
@@ -56,7 +59,7 @@ pt_md_init(void)
 }
 
 int
-pt_reg_sstep(struct reg *reg, int step)
+pt_reg_sstep(struct reg *reg __unused, int step __unused)
 {
        return (0);
 }

Modified: stable/7/lib/libthread_db/arch/powerpc/libpthread_md.c
==============================================================================
--- stable/7/lib/libthread_db/arch/powerpc/libpthread_md.c      Tue Jun  9 
00:27:23 2009        (r193788)
+++ stable/7/lib/libthread_db/arch/powerpc/libpthread_md.c      Tue Jun  9 
00:47:54 2009        (r193789)
@@ -27,9 +27,8 @@
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-#include <string.h>
 #include <sys/types.h>
-#include <proc_service.h>
+#include <string.h>
 #include <thread_db.h>
 
 #include "libpthread_db.h"
@@ -76,8 +75,9 @@ pt_md_init(void)
 }
 
 int
-pt_reg_sstep(struct reg *reg, int step)
+pt_reg_sstep(struct reg *reg __unused, int step __unused)
 {
 
        /* XXX */
+       return (0);
 }

Modified: stable/7/lib/libthread_db/arch/sparc64/libpthread_md.c
==============================================================================
--- stable/7/lib/libthread_db/arch/sparc64/libpthread_md.c      Tue Jun  9 
00:27:23 2009        (r193788)
+++ stable/7/lib/libthread_db/arch/sparc64/libpthread_md.c      Tue Jun  9 
00:47:54 2009        (r193789)
@@ -28,25 +28,28 @@
 __FBSDID("$FreeBSD$");
 
 #include <sys/procfs.h>
+#include <thread_db.h>
 #include <ucontext.h>
 
+#include "libpthread_db.h"
+
 void
-pt_reg_to_ucontext(const struct reg *r, ucontext_t *uc)
+pt_reg_to_ucontext(const struct reg *r __unused, ucontext_t *uc __unused)
 {
 }
 
 void
-pt_ucontext_to_reg(const ucontext_t *uc, struct reg *r)
+pt_ucontext_to_reg(const ucontext_t *uc __unused, struct reg *r __unused)
 {
 }
 
 void
-pt_fpreg_to_ucontext(const struct fpreg* r, ucontext_t *uc)
+pt_fpreg_to_ucontext(const struct fpreg* r __unused, ucontext_t *uc __unused)
 {
 }
 
 void
-pt_ucontext_to_fpreg(const ucontext_t *uc, struct fpreg *r)
+pt_ucontext_to_fpreg(const ucontext_t *uc __unused, struct fpreg *r __unused)
 {
 }
 
@@ -56,7 +59,7 @@ pt_md_init(void)
 }
 
 int
-pt_reg_sstep(struct reg *reg, int step)
+pt_reg_sstep(struct reg *reg __unused, int step __unused)
 {
        return (0);
 }

Modified: stable/7/lib/libthread_db/libpthread_db.c
==============================================================================
--- stable/7/lib/libthread_db/libpthread_db.c   Tue Jun  9 00:27:23 2009        
(r193788)
+++ stable/7/lib/libthread_db/libpthread_db.c   Tue Jun  9 00:47:54 2009        
(r193789)
@@ -70,7 +70,7 @@ ps2td(int c)
 }
 
 static long
-pt_map_thread(const td_thragent_t *const_ta, psaddr_t pt, int type)
+pt_map_thread(const td_thragent_t *const_ta, psaddr_t pt, enum pt_type type)
 {
        td_thragent_t *ta = __DECONST(td_thragent_t *, const_ta);
        struct pt_map *new;
@@ -220,7 +220,6 @@ static td_err_e
 pt_ta_map_id2thr(const td_thragent_t *ta, thread_t id, td_thrhandle_t *th)
 {
        prgregset_t gregs;
-       TAILQ_HEAD(, pthread) thread_list;
        psaddr_t pt, tcb_addr;
        lwpid_t lwp;
        int ret;
@@ -229,28 +228,24 @@ pt_ta_map_id2thr(const td_thragent_t *ta
 
        if (id < 0 || id >= ta->map_len || ta->map[id].type == PT_NONE)
                return (TD_NOTHR);
-       ret = ps_pread(ta->ph, ta->thread_list_addr, &thread_list,
-                       sizeof(thread_list));
+
+       ret = thr_pread_ptr(ta, ta->thread_list_addr, &pt);
        if (ret != 0)
-               return (P2T(ret));
-       pt = (psaddr_t)thread_list.tqh_first;
+               return (TD_ERR);
        if (ta->map[id].type == PT_LWP) {
                /*
                 * if we are referencing a lwp, make sure it was not already
                 * mapped to user thread.
                 */
                while (pt != 0) {
-                       ret = ps_pread(ta->ph,
-                               pt + ta->thread_off_tcb,
-                               &tcb_addr, sizeof(tcb_addr));
+                       ret = thr_pread_ptr(ta, pt + ta->thread_off_tcb,
+                           &tcb_addr);
                        if (ret != 0)
-                               return (P2T(ret));
-                       ret = ps_pread(ta->ph,
-                               tcb_addr + ta->thread_off_tmbx + 
-                               offsetof(struct kse_thr_mailbox, tm_lwp),
-                               &lwp, sizeof(lwp));
+                               return (TD_ERR);
+                       ret = thr_pread_int(ta, tcb_addr + ta->thread_off_tmbx +
+                           offsetof(struct kse_thr_mailbox, tm_lwp), &lwp);
                        if (ret != 0)
-                               return (P2T(ret));
+                               return (TD_ERR);
                        /*
                         * If the lwp was already mapped to userland thread,
                         * we shouldn't reference it directly in future.
@@ -260,11 +255,9 @@ pt_ta_map_id2thr(const td_thragent_t *ta
                                return (TD_NOTHR);
                        }
                        /* get next thread */
-                       ret = ps_pread(ta->ph,
-                               pt + ta->thread_off_next,
-                               &pt, sizeof(pt));
+                       ret = thr_pread_ptr(ta, pt + ta->thread_off_next, &pt);
                        if (ret != 0)
-                               return (P2T(ret));
+                               return (TD_ERR);
                }
                /* check lwp */
                ret = ps_lgetregs(ta->ph, ta->map[id].lwp, gregs);
@@ -275,17 +268,14 @@ pt_ta_map_id2thr(const td_thragent_t *ta
                }
        } else {
                while (pt != 0 && ta->map[id].thr != pt) {
-                       ret = ps_pread(ta->ph,
-                               pt + ta->thread_off_tcb,
-                               &tcb_addr, sizeof(tcb_addr));
+                       ret = thr_pread_ptr(ta, pt + ta->thread_off_tcb,
+                           &tcb_addr);
                        if (ret != 0)
-                               return (P2T(ret));
+                               return (TD_ERR);
                        /* get next thread */
-                       ret = ps_pread(ta->ph,
-                               pt + ta->thread_off_next,
-                               &pt, sizeof(pt));
+                       ret = thr_pread_ptr(ta, pt + ta->thread_off_next, &pt);
                        if (ret != 0)
-                               return (P2T(ret));
+                               return (TD_ERR);
                }
 
                if (pt == 0) {
@@ -303,29 +293,24 @@ pt_ta_map_id2thr(const td_thragent_t *ta
 static td_err_e
 pt_ta_map_lwp2thr(const td_thragent_t *ta, lwpid_t lwp, td_thrhandle_t *th)
 {
-       TAILQ_HEAD(, pthread) thread_list;
-       psaddr_t pt, ptr;
-       lwpid_t tmp_lwp;
+       psaddr_t pt, tcb_addr;
+       lwpid_t lwp1;
        int ret;
-       
+
        TDBG_FUNC();
 
-       ret = ps_pread(ta->ph, ta->thread_list_addr, &thread_list,
-                       sizeof(thread_list));
+       ret = thr_pread_ptr(ta, ta->thread_list_addr, &pt);
        if (ret != 0)
-               return (P2T(ret));
-       pt = (psaddr_t)thread_list.tqh_first;
+               return (TD_ERR);
        while (pt != 0) {
-               ret = ps_pread(ta->ph, pt + ta->thread_off_tcb,
-                               &ptr, sizeof(ptr));
+               ret = thr_pread_ptr(ta, pt + ta->thread_off_tcb, &tcb_addr);
                if (ret != 0)
-                       return (P2T(ret));
-               ptr += ta->thread_off_tmbx +
-                      offsetof(struct kse_thr_mailbox, tm_lwp);
-               ret = ps_pread(ta->ph, ptr, &tmp_lwp, sizeof(lwpid_t));
+                       return (TD_ERR);
+               ret = thr_pread_int(ta, tcb_addr + ta->thread_off_tmbx +
+                   offsetof(struct kse_thr_mailbox, tm_lwp), &lwp1);
                if (ret != 0)
-                       return (P2T(ret));
-               if (tmp_lwp == lwp) {
+                       return (TD_ERR);
+               if (lwp1 == lwp) {
                        th->th_ta = ta;
                        th->th_tid = pt_map_thread(ta, pt, PT_USER);
                        if (th->th_tid == -1)
@@ -336,28 +321,23 @@ pt_ta_map_lwp2thr(const td_thragent_t *t
                }
 
                /* get next thread */
-               ret = ps_pread(ta->ph,
-                          pt + ta->thread_off_next,
-                          &pt, sizeof(pt));
+               ret = thr_pread_ptr(ta, pt + ta->thread_off_next, &pt);
                if (ret != 0)
-                       return (P2T(ret));
+                       return (TD_ERR);
        }
 
        return (TD_NOTHR);
 }
 
 static td_err_e
-pt_ta_thr_iter(const td_thragent_t *ta,
-               td_thr_iter_f *callback, void *cbdata_p,
-               td_thr_state_e state, int ti_pri,
-               sigset_t *ti_sigmask_p,
-               unsigned int ti_user_flags)
+pt_ta_thr_iter(const td_thragent_t *ta, td_thr_iter_f *callback,
+    void *cbdata_p, td_thr_state_e state __unused, int ti_pri __unused,
+    sigset_t *ti_sigmask_p __unused, unsigned int ti_user_flags __unused)
 {
-       TAILQ_HEAD(, pthread) thread_list;
        td_thrhandle_t th;
        psaddr_t pt;
        ps_err_e pserr;
-       int activated;
+       int activated, ret;
 
        TDBG_FUNC();
 
@@ -368,11 +348,9 @@ pt_ta_thr_iter(const td_thragent_t *ta,
        if (!activated)
                return (TD_OK);
 
-       pserr = ps_pread(ta->ph, ta->thread_list_addr, &thread_list,
-           sizeof(thread_list));
-       if (pserr != 0)
-               return (P2T(pserr));
-       pt = (psaddr_t)thread_list.tqh_first;
+       ret = thr_pread_ptr(ta, ta->thread_list_addr, &pt);
+       if (ret != 0)
+               return (TD_ERR);
        while (pt != 0) {
                th.th_ta = ta;
                th.th_tid = pt_map_thread(ta, pt, PT_USER);
@@ -383,11 +361,9 @@ pt_ta_thr_iter(const td_thragent_t *ta,
                if ((*callback)(&th, cbdata_p))
                        return (TD_DBERR);
                /* get next thread */
-               pserr = ps_pread(ta->ph,
-                   pt + ta->thread_off_next, &pt,
-                   sizeof(pt));
-               if (pserr != PS_OK)
-                       return (P2T(pserr));
+               ret = thr_pread_ptr(ta, pt + ta->thread_off_next, &pt);
+               if (ret != 0)
+                       return (TD_ERR);
        }
        return (TD_OK);
 }
@@ -395,7 +371,7 @@ pt_ta_thr_iter(const td_thragent_t *ta,
 static td_err_e
 pt_ta_tsd_iter(const td_thragent_t *ta, td_key_iter_f *ki, void *arg)
 {
-       char *keytable;
+       void *keytable;
        void *destructor;
        int i, ret, allocated;
 
@@ -411,10 +387,10 @@ pt_ta_tsd_iter(const td_thragent_t *ta, 
                return (P2T(ret));
        }       
        for (i = 0; i < ta->thread_max_keys; i++) {
-               allocated = *(int *)(keytable + i * ta->thread_size_key +
-                       ta->thread_off_key_allocated);
-               destructor = *(void **)(keytable + i * ta->thread_size_key +
-                       ta->thread_off_key_destructor);
+               allocated = *(int *)(void *)((uintptr_t)keytable +
+                   i * ta->thread_size_key + ta->thread_off_key_allocated);
+               destructor = *(void **)(void *)((uintptr_t)keytable +
+                   i * ta->thread_size_key + ta->thread_off_key_destructor);
                if (allocated) {
                        ret = (ki)(i, destructor, arg);
                        if (ret != 0) {
@@ -428,28 +404,32 @@ pt_ta_tsd_iter(const td_thragent_t *ta, 
 }
 
 static td_err_e
-pt_ta_event_addr(const td_thragent_t *ta, td_event_e event, td_notify_t *ptr)
+pt_ta_event_addr(const td_thragent_t *ta __unused, td_event_e event __unused,
+    td_notify_t *ptr __unused)
 {
        TDBG_FUNC();
        return (TD_ERR);
 }
 
 static td_err_e
-pt_ta_set_event(const td_thragent_t *ta, td_thr_events_t *events)
+pt_ta_set_event(const td_thragent_t *ta __unused,
+    td_thr_events_t *events __unused)
 {
        TDBG_FUNC();
        return (0);
 }
 
 static td_err_e
-pt_ta_clear_event(const td_thragent_t *ta, td_thr_events_t *events)
+pt_ta_clear_event(const td_thragent_t *ta __unused,
+    td_thr_events_t *events __unused)
 {
        TDBG_FUNC();
        return (0);
 }
 
 static td_err_e
-pt_ta_event_getmsg(const td_thragent_t *ta, td_event_msg_t *msg)
+pt_ta_event_getmsg(const td_thragent_t *ta __unused,
+    td_event_msg_t *msg __unused)
 {
        TDBG_FUNC();
        return (TD_NOMSG);
@@ -458,7 +438,7 @@ pt_ta_event_getmsg(const td_thragent_t *
 static td_err_e
 pt_dbsuspend(const td_thrhandle_t *th, int suspend)
 {
-       td_thragent_t *ta = (td_thragent_t *)th->th_ta;
+       const td_thragent_t *ta = th->th_ta;
        psaddr_t tcb_addr, tmbx_addr, ptr;
        lwpid_t lwp;
        uint32_t dflags;
@@ -952,28 +932,31 @@ pt_thr_setgregs(const td_thrhandle_t *th
 }
 
 static td_err_e
-pt_thr_event_enable(const td_thrhandle_t *th, int en)
+pt_thr_event_enable(const td_thrhandle_t *th __unused, int en __unused)
 {
        TDBG_FUNC();
        return (0);
 }
 
 static td_err_e
-pt_thr_set_event(const td_thrhandle_t *th, td_thr_events_t *setp)
+pt_thr_set_event(const td_thrhandle_t *th __unused,
+    td_thr_events_t *setp __unused)
 {
        TDBG_FUNC();
        return (0);
 }
 
 static td_err_e
-pt_thr_clear_event(const td_thrhandle_t *th, td_thr_events_t *setp)
+pt_thr_clear_event(const td_thrhandle_t *th __unused,
+    td_thr_events_t *setp __unused)
 {
        TDBG_FUNC();
        return (0);
 }
 
 static td_err_e
-pt_thr_event_getmsg(const td_thrhandle_t *th, td_event_msg_t *msg)
+pt_thr_event_getmsg(const td_thrhandle_t *th __unused,
+    td_event_msg_t *msg __unused)
 {
        TDBG_FUNC();
        return (TD_NOMSG);
@@ -1074,17 +1057,16 @@ pt_validate(const td_thrhandle_t *th)
        return (TD_OK);
 }
 
-td_err_e
-pt_thr_tls_get_addr(const td_thrhandle_t *th, void *_linkmap, size_t offset,
-                   void **address)
+static td_err_e
+pt_thr_tls_get_addr(const td_thrhandle_t *th, psaddr_t _linkmap, size_t offset,
+    psaddr_t *address)
 {
-       char *obj_entry;
        const td_thragent_t *ta = th->th_ta;
-       psaddr_t tcb_addr, *dtv_addr;
+       psaddr_t dtv_addr, obj_entry, tcb_addr;
        int tls_index, ret;
 
        /* linkmap is a member of Obj_Entry */
-       obj_entry = (char *)_linkmap - ta->thread_off_linkmap;
+       obj_entry = _linkmap - ta->thread_off_linkmap;
 
        /* get tlsindex of the object file */
        ret = ps_pread(ta->ph,
@@ -1106,8 +1088,8 @@ pt_thr_tls_get_addr(const td_thrhandle_t
        if (ret != 0)
                return (P2T(ret));
        /* now get the object's tls block base address */
-       ret = ps_pread(ta->ph, &dtv_addr[tls_index+1], address,
-               sizeof(*address));
+       ret = ps_pread(ta->ph, dtv_addr + sizeof(void *) * (tls_index + 1),
+           address, sizeof(*address));
        if (ret != 0)
                return (P2T(ret));
 

Modified: stable/7/lib/libthread_db/libpthread_db.h
==============================================================================
--- stable/7/lib/libthread_db/libpthread_db.h   Tue Jun  9 00:27:23 2009        
(r193788)
+++ stable/7/lib/libthread_db/libpthread_db.h   Tue Jun  9 00:47:54 2009        
(r193789)
@@ -34,13 +34,14 @@
 
 #include "thread_db_int.h"
 
-struct pt_map {
-       enum {
-               PT_NONE,
-               PT_USER,
-               PT_LWP
-       } type;
+enum pt_type {
+       PT_NONE,
+       PT_USER,
+       PT_LWP
+};
 
+struct pt_map {
+       enum pt_type    type;
        union {
                lwpid_t         lwp;
                psaddr_t        thr;

Modified: stable/7/lib/libthread_db/libthr_db.c
==============================================================================
--- stable/7/lib/libthread_db/libthr_db.c       Tue Jun  9 00:27:23 2009        
(r193788)
+++ stable/7/lib/libthread_db/libthr_db.c       Tue Jun  9 00:47:54 2009        
(r193789)
@@ -201,36 +201,30 @@ pt_ta_delete(td_thragent_t *ta)
 static td_err_e
 pt_ta_map_id2thr(const td_thragent_t *ta, thread_t id, td_thrhandle_t *th)
 {
-       TAILQ_HEAD(, pthread) thread_list;
        psaddr_t pt;
-       long lwp;
+       int32_t lwp;
        int ret;
 
        TDBG_FUNC();
 
        if (id == 0)
                return (TD_NOTHR);
-       ret = ps_pread(ta->ph, ta->thread_list_addr, &thread_list,
-               sizeof(thread_list));
+       ret = thr_pread_ptr(ta, ta->thread_list_addr, &pt);
        if (ret != 0)
-               return (P2T(ret));
+               return (TD_ERR);
        /* Iterate through thread list to find pthread */
-       pt = (psaddr_t)thread_list.tqh_first;
-       while (pt != NULL) {
-               ret = ps_pread(ta->ph, pt + ta->thread_off_tid,
-                              &lwp, sizeof(lwp));
+       while (pt != 0) {
+               ret = thr_pread_int(ta, pt + ta->thread_off_tid, &lwp);
                if (ret != 0)
-                       return (P2T(ret));
+                       return (TD_ERR);
                if (lwp == id)
                        break;
                /* get next thread */
-               ret = ps_pread(ta->ph,
-                               pt + ta->thread_off_next,
-                               &pt, sizeof(pt));
+               ret = thr_pread_ptr(ta, pt + ta->thread_off_next, &pt);
                if (ret != 0)
-                       return (P2T(ret));
+                       return (TD_ERR);
        }
-       if (pt == NULL)
+       if (pt == 0)
                return (TD_NOTHR);
        th->th_ta = ta;
        th->th_tid = id;
@@ -245,30 +239,24 @@ pt_ta_map_lwp2thr(const td_thragent_t *t
 }
 
 static td_err_e
-pt_ta_thr_iter(const td_thragent_t *ta,
-               td_thr_iter_f *callback, void *cbdata_p,
-               td_thr_state_e state, int ti_pri,
-               sigset_t *ti_sigmask_p,
-               unsigned int ti_user_flags)
+pt_ta_thr_iter(const td_thragent_t *ta, td_thr_iter_f *callback,
+    void *cbdata_p, td_thr_state_e state __unused, int ti_pri __unused,
+    sigset_t *ti_sigmask_p __unused, unsigned int ti_user_flags __unused)
 {
-       TAILQ_HEAD(, pthread) thread_list;
        td_thrhandle_t th;
        psaddr_t pt;
-       long lwp;
+       int32_t lwp;
        int ret;
 
        TDBG_FUNC();
 
-       ret = ps_pread(ta->ph, ta->thread_list_addr, &thread_list,
-                      sizeof(thread_list));
+       ret = thr_pread_ptr(ta, ta->thread_list_addr, &pt);
        if (ret != 0)
-               return (P2T(ret));
-       pt = (psaddr_t)thread_list.tqh_first;
+               return (TD_ERR);
        while (pt != 0) {
-               ret = ps_pread(ta->ph, pt + ta->thread_off_tid, &lwp,
-                             sizeof(lwp));
+               ret = thr_pread_int(ta, pt + ta->thread_off_tid, &lwp);
                if (ret != 0)
-                       return (P2T(ret));
+                       return (TD_ERR);
                if (lwp != 0 && lwp != TERMINATED) {
                        th.th_ta = ta;
                        th.th_tid = (thread_t)lwp;
@@ -277,10 +265,9 @@ pt_ta_thr_iter(const td_thragent_t *ta,
                                return (TD_DBERR);
                }
                /* get next thread */
-               ret = ps_pread(ta->ph, pt + ta->thread_off_next, &pt,
-                              sizeof(pt));
+               ret = thr_pread_ptr(ta, pt + ta->thread_off_next, &pt);
                if (ret != 0)
-                       return (P2T(ret));
+                       return (TD_ERR);
        }
        return (TD_OK);
 }
@@ -288,7 +275,7 @@ pt_ta_thr_iter(const td_thragent_t *ta,
 static td_err_e
 pt_ta_tsd_iter(const td_thragent_t *ta, td_key_iter_f *ki, void *arg)
 {
-       char *keytable;
+       void *keytable;
        void *destructor;
        int i, ret, allocated;
 
@@ -304,10 +291,10 @@ pt_ta_tsd_iter(const td_thragent_t *ta, 
                return (P2T(ret));
        }
        for (i = 0; i < ta->thread_max_keys; i++) {
-               allocated = *(int *)(keytable + i * ta->thread_size_key +
-                       ta->thread_off_key_allocated);
-               destructor = *(void **)(keytable + i * ta->thread_size_key +
-                       ta->thread_off_key_destructor);
+               allocated = *(int *)(void *)((uintptr_t)keytable +
+                   i * ta->thread_size_key + ta->thread_off_key_allocated);
+               destructor = *(void **)(void *)((uintptr_t)keytable +
+                   i * ta->thread_size_key + ta->thread_off_key_destructor);
                if (allocated) {
                        ret = (ki)(i, destructor, arg);
                        if (ret != 0) {
@@ -379,24 +366,23 @@ pt_ta_event_getmsg(const td_thragent_t *
 {
        static td_thrhandle_t handle;
 
-       psaddr_t pt, pt_temp;
+       psaddr_t pt;
        td_thr_events_e tmp;
-       long lwp;
+       int32_t lwp;
        int ret;
 
        TDBG_FUNC();
 
-       ret = ps_pread(ta->ph, ta->thread_last_event_addr, &pt, sizeof(pt));
+       ret = thr_pread_ptr(ta, ta->thread_last_event_addr, &pt);
        if (ret != 0)
-               return (P2T(ret));
-       if (pt == NULL)
+               return (TD_ERR);
+       if (pt == 0)
                return (TD_NOMSG);
        /*
         * Take the event pointer, at the time, libthr only reports event
         * once a time, so it is not a link list.
         */
-       pt_temp = NULL;
-       ps_pwrite(ta->ph, ta->thread_last_event_addr, &pt_temp, 
sizeof(pt_temp));
+       thr_pwrite_ptr(ta, ta->thread_last_event_addr, 0);
 
        /* Read event info */
        ret = ps_pread(ta->ph, pt + ta->thread_off_event_buf, msg, 
sizeof(*msg));
@@ -408,21 +394,21 @@ pt_ta_event_getmsg(const td_thragent_t *
        tmp = 0;
        ps_pwrite(ta->ph, pt + ta->thread_off_event_buf, &tmp, sizeof(tmp));
        /* Convert event */
-       pt = (psaddr_t)msg->th_p;
-       ret = ps_pread(ta->ph, pt + ta->thread_off_tid, &lwp, sizeof(lwp));
+       pt = msg->th_p;
+       ret = thr_pread_int(ta, pt + ta->thread_off_tid, &lwp);
        if (ret != 0)
-               return (P2T(ret));
+               return (TD_ERR);
        handle.th_ta = ta;
        handle.th_tid = lwp;
        handle.th_thread = pt;
-       msg->th_p = &handle;
+       msg->th_p = (uintptr_t)&handle;
        return (0);
 }
 
 static td_err_e
 pt_dbsuspend(const td_thrhandle_t *th, int suspend)
 {
-       td_thragent_t *ta = (td_thragent_t *)th->th_ta;
+       const td_thragent_t *ta = th->th_ta;
        int ret;
 
        TDBG_FUNC();
@@ -480,14 +466,13 @@ pt_thr_get_info(const td_thrhandle_t *th
        ret = pt_validate(th);
        if (ret)
                return (ret);
-       ret = ps_pread(ta->ph, th->th_thread + ta->thread_off_state,
-                      &state, sizeof(state));
+       ret = thr_pread_int(ta, th->th_thread + ta->thread_off_state, &state);
        if (ret != 0)
-               return (P2T(ret));
-       ret = ps_pread(ta->ph, th->th_thread + ta->thread_off_report_events,
-               &info->ti_traceme, sizeof(int));
+               return (TD_ERR);
+       ret = thr_pread_int(ta, th->th_thread + ta->thread_off_report_events,
+           &info->ti_traceme);
        if (ret != 0)
-               return (P2T(ret));
+               return (TD_ERR);
        ret = ps_pread(ta->ph, th->th_thread + ta->thread_off_event_mask,
                &info->ti_events, sizeof(td_thr_events_t));
        if (ret != 0)
@@ -662,17 +647,17 @@ static td_err_e
 pt_thr_event_getmsg(const td_thrhandle_t *th, td_event_msg_t *msg)
 {
        static td_thrhandle_t handle;
-       td_thragent_t *ta = (td_thragent_t *)th->th_ta;
+       const td_thragent_t *ta = th->th_ta;
        psaddr_t pt, pt_temp;
-       long lwp;
+       int32_t lwp;
        int ret;
        td_thr_events_e tmp;
 
        TDBG_FUNC();
        pt = th->th_thread;
-       ret = ps_pread(ta->ph, ta->thread_last_event_addr, &pt_temp, 
sizeof(pt_temp));
+       ret = thr_pread_ptr(ta, ta->thread_last_event_addr, &pt_temp);
        if (ret != 0)
-               return (P2T(ret));
+               return (TD_ERR);
        /* Get event */
        ret = ps_pread(ta->ph, pt + ta->thread_off_event_buf, msg, 
sizeof(*msg));
        if (ret != 0)
@@ -683,27 +668,26 @@ pt_thr_event_getmsg(const td_thrhandle_t
         * Take the event pointer, at the time, libthr only reports event
         * once a time, so it is not a link list.
         */
-       if (pt == pt_temp) {
-               pt_temp = NULL;
-               ps_pwrite(ta->ph, ta->thread_last_event_addr, &pt_temp, 
sizeof(pt_temp));
-       }
+       if (pt == pt_temp)
+               thr_pwrite_ptr(ta, ta->thread_last_event_addr, 0);
+
        /* Clear event */
        tmp = 0;
        ps_pwrite(ta->ph, pt + ta->thread_off_event_buf, &tmp, sizeof(tmp));
        /* Convert event */
-       pt = (psaddr_t)msg->th_p;
-       ret = ps_pread(ta->ph, pt + ta->thread_off_tid, &lwp, sizeof(lwp));
+       pt = msg->th_p;
+       ret = thr_pread_int(ta, pt + ta->thread_off_tid, &lwp);
        if (ret != 0)
-               return (P2T(ret));
+               return (TD_ERR);
        handle.th_ta = ta;
        handle.th_tid = lwp;
        handle.th_thread = pt;
-       msg->th_p = &handle;
+       msg->th_p = (uintptr_t)&handle;
        return (0);
 }
 
 static td_err_e
-pt_thr_sstep(const td_thrhandle_t *th, int step)
+pt_thr_sstep(const td_thrhandle_t *th, int step __unused)
 {
        TDBG_FUNC();
 
@@ -714,22 +698,21 @@ static int
 pt_validate(const td_thrhandle_t *th)
 {
 
-       if (th->th_tid == 0 || th->th_thread == NULL)
+       if (th->th_tid == 0 || th->th_thread == 0)
                return (TD_ERR);
        return (TD_OK);
 }
 
 static td_err_e
-pt_thr_tls_get_addr(const td_thrhandle_t *th, void *_linkmap, size_t offset,
-                   void **address)
+pt_thr_tls_get_addr(const td_thrhandle_t *th, psaddr_t _linkmap, size_t offset,
+    psaddr_t *address)
 {
-       char *obj_entry;
        const td_thragent_t *ta = th->th_ta;
-       psaddr_t tcb_addr, *dtv_addr;
+       psaddr_t dtv_addr, obj_entry, tcb_addr;
        int tls_index, ret;
 
        /* linkmap is a member of Obj_Entry */
-       obj_entry = (char *)_linkmap - ta->thread_off_linkmap;
+       obj_entry = _linkmap - ta->thread_off_linkmap;
 
        /* get tlsindex of the object file */
        ret = ps_pread(ta->ph,
@@ -750,8 +733,8 @@ pt_thr_tls_get_addr(const td_thrhandle_t
        if (ret != 0)
                return (P2T(ret));
        /* now get the object's tls block base address */
-       ret = ps_pread(ta->ph, &dtv_addr[tls_index+1], address,
-               sizeof(*address));
+       ret = ps_pread(ta->ph, dtv_addr + sizeof(void *) * (tls_index+1),
+           address, sizeof(*address));
        if (ret != 0)
                return (P2T(ret));
 

Modified: stable/7/lib/libthread_db/thread_db.c
==============================================================================
--- stable/7/lib/libthread_db/thread_db.c       Tue Jun  9 00:27:23 2009        
(r193788)
+++ stable/7/lib/libthread_db/thread_db.c       Tue Jun  9 00:47:54 2009        
(r193789)
@@ -32,6 +32,8 @@ __FBSDID("$FreeBSD$");
 #include <thread_db.h>
 #include <unistd.h>
 #include <sys/cdefs.h>
+#include <sys/endian.h>
+#include <sys/errno.h>
 #include <sys/linker_set.h>
 
 #include "thread_db_int.h"
@@ -50,7 +52,6 @@ td_init(void)
 {
        td_err_e ret, tmp;
        struct ta_ops *ops_p, **ops_pp;
-       size_t i;
 
        ret = 0;
        SET_FOREACH(ops_pp, __ta_ops) {
@@ -104,7 +105,6 @@ td_ta_map_lwp2thr(const td_thragent_t *t
 td_err_e
 td_ta_new(struct ps_prochandle *ph, td_thragent_t **pta)
 {
-       size_t i;
        struct ta_ops *ops_p, **ops_pp;
 
        SET_FOREACH(ops_pp, __ta_ops) {
@@ -244,8 +244,8 @@ td_thr_validate(const td_thrhandle_t *th
 }
 
 td_err_e
-td_thr_tls_get_addr(const td_thrhandle_t *th, void *linkmap, size_t offset,
-                   void **address)
+td_thr_tls_get_addr(const td_thrhandle_t *th, psaddr_t linkmap, size_t offset,
+    psaddr_t *address)
 {
        const td_thragent_t *ta = th->th_ta;
        return (ta->ta_ops->to_thr_tls_get_addr(th, linkmap, offset, address));
@@ -259,3 +259,176 @@ td_thr_sstep(const td_thrhandle_t *th, i
        const td_thragent_t *ta = th->th_ta;
        return (ta->ta_ops->to_thr_sstep(th, step));
 }
+
+/*
+ * Support functions for reading from and writing to the target
+ * address space.
+ */
+
+static int
+thr_pread(struct ps_prochandle *ph, psaddr_t addr, uint64_t *val,
+    u_int size, u_int byteorder)
+{
+       uint8_t buf[sizeof(*val)];
+       ps_err_e err;
+
+       if (size > sizeof(buf))
+               return (EOVERFLOW);
+
+       err = ps_pread(ph, addr, buf, size);
+       if (err != PS_OK)
+               return (EFAULT);
+
+       switch (byteorder) {
+       case BIG_ENDIAN:
+               switch (size) {
+               case 1:
+                       *val = buf[0];
+                       break;
+               case 2:
+                       *val = be16dec(buf);
+                       break;
+               case 4:
+                       *val = be32dec(buf);
+                       break;
+               case 8:
+                       *val = be64dec(buf);
+                       break;
+               default:
+                       return (EINVAL);
+               }
+               break;
+       case LITTLE_ENDIAN:
+               switch (size) {
+               case 1:
+                       *val = buf[0];
+                       break;
+               case 2:
+                       *val = le16dec(buf);
+                       break;
+               case 4:
+                       *val = le32dec(buf);
+                       break;
+               case 8:
+                       *val = le64dec(buf);
+                       break;
+               default:
+                       return (EINVAL);
+               }
+               break;
+       default:
+               return (EINVAL);
+       }
+
+       return (0);
+}
+
+int
+thr_pread_int(const struct td_thragent *ta, psaddr_t addr, uint32_t *val)
+{
+       uint64_t tmp;
+       int error;
+
+       error = thr_pread(ta->ph, addr, &tmp, sizeof(int), BYTE_ORDER);
+       if (!error)
+               *val = tmp;
+
+       return (error);
+}
+
+int
+thr_pread_long(const struct td_thragent *ta, psaddr_t addr, uint64_t *val)
+{
+
+       return (thr_pread(ta->ph, addr, val, sizeof(long), BYTE_ORDER));
+}
+
+int
+thr_pread_ptr(const struct td_thragent *ta, psaddr_t addr, psaddr_t *val)
+{
+       uint64_t tmp;
+       int error;
+
+       error = thr_pread(ta->ph, addr, &tmp, sizeof(void *), BYTE_ORDER);
+       if (!error)
+               *val = tmp;
+
+       return (error);
+}
+
+static int
+thr_pwrite(struct ps_prochandle *ph, psaddr_t addr, uint64_t val,

*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
_______________________________________________
svn-src-all@freebsd.org mailing list
http://lists.freebsd.org/mailman/listinfo/svn-src-all
To unsubscribe, send any mail to "svn-src-all-unsubscr...@freebsd.org"

Reply via email to