rebased to master after sw 3rd party completed
[dyninst.git] / dyninstAPI_RT / src / RTvxworks.c
1 /*
2  * See the dyninst/COPYRIGHT file for copyright information.
3  * 
4  * We provide the Paradyn Tools (below described as "Paradyn")
5  * on an AS IS basis, and do not warrant its validity or performance.
6  * We reserve the right to update, modify, or discontinue this
7  * software at any time.  We shall have no obligation to supply such
8  * updates or modifications or any other form of support to you.
9  * 
10  * By your use of Paradyn, you understand and agree that we (or any
11  * other person or entity with proprietary rights in Paradyn) are
12  * under no obligation to provide either maintenance services,
13  * update services, notices of latent defects, or correction of
14  * defects for Paradyn.
15  * 
16  * This library is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU Lesser General Public
18  * License as published by the Free Software Foundation; either
19  * version 2.1 of the License, or (at your option) any later version.
20  * 
21  * This library is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * Lesser General Public License for more details.
25  * 
26  * You should have received a copy of the GNU Lesser General Public
27  * License along with this library; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29  */
30 #include "dyninstAPI_RT/h/dyninstAPI_RT.h"
31 #include "dyninstAPI_RT/src/RTcommon.h"
32 #include "taskLib.h"
33
34 #include <unistd.h>
35
36 void DYNINSTos_init(int calledByFork, int calledByAttach)
37 {
38     rtdebug_printf("DYNINSTos_init(%d,%d)\n", calledByFork, calledByAttach);
39 }
40
41 void DYNINSTsafeBreakPoint()
42 {
43     taskSuspend( taskIdSelf() );
44 }
45
46 int DYNINST_am_initial_thread( dyntid_t tid )
47 {
48     return taskIdSelf();
49 }
50
51 int DYNINSTthreadInfo(BPatch_newThreadEventRecord *ev)
52 {
53     return taskIdSelf();
54 }
55
56 int dyn_pid_self()
57 {
58     return taskIdSelf();
59 }
60
61 int dyn_lwp_self()
62 {
63     return taskIdSelf();
64 }
65
66 dyntid_t dyn_pthread_self()
67 {
68     return (void *)0x0;
69 }
70
71 int getpagesize()
72 {
73     return 1024; // No VM support for vxWorks (yet).
74 }
75
76 void DYNINSTbreakPoint()
77 {  
78     /* We set a global flag here so that we can tell
79       if we're ever in a call to this when we get a
80       SIGBUS */
81     if (DYNINSTstaticMode)
82         return;
83
84     DYNINST_break_point_event = 1;
85     while (DYNINST_break_point_event) {
86         kill(dyn_lwp_self(), 7);
87     }
88     /* Mutator resets to 0... */
89 }
90
91 unsigned int DYNINSTtaskListMax = 0;
92 unsigned int DYNINSTtaskListCount = 0;
93 int *DYNINSTtaskList = NULL;
94 int *DYNINSTrefreshTasks(void)
95 {
96     int newMax;
97     int *newList;
98
99     /* Grow the task list until it's not completely full. */
100     while (1) {
101         memset(DYNINSTtaskList, 0, sizeof(int) * DYNINSTtaskListMax);
102         DYNINSTtaskListCount = taskIdListGet(DYNINSTtaskList,
103                                              DYNINSTtaskListMax);
104
105         if (DYNINSTtaskListCount >= DYNINSTtaskListMax) {
106             // Grow the task list.
107             newMax  = (!DYNINSTtaskListMax ? 16
108                                            : DYNINSTtaskListMax * 2);
109             newList = realloc(DYNINSTtaskList, sizeof(int) * newMax);
110             if (newList) {
111                 DYNINSTtaskListMax = newMax;
112                 DYNINSTtaskList    = newList;
113                 continue;
114             }
115             fprintf(stderr, "Warning: tasklist realloc failure (%d bytes).\n",
116                     sizeof(int) * newMax);
117         }
118         break;
119     }
120 /*
121     fprintf(stderr, "Tasks I've found:\n");
122     for (newMax = 0; newMax < DYNINSTtaskListCount; ++newMax) {
123         fprintf(stderr, "\t0x%x (%d)\n",
124                 DYNINSTtaskList[newMax], DYNINSTtaskList[newMax]);
125     }
126 */
127     return DYNINSTtaskList;
128 }
129
130 unsigned int DYNINSTtaskNameSize = 0;
131 char *DYNINSTtaskNameBuf = NULL;
132 char *DYNINSTtaskInfo(int taskid)
133 {
134     int newSize = 0, statCount = 0;
135     char *newBuf = NULL;
136
137     int   firstStat = 1;
138     char  statStr[64];  // Status string will never be larger than this.
139     int   delayTicks;
140     char *nameStr;
141
142     nameStr = taskName(taskid);
143     strcpy(statStr, " (");
144     if (taskIsReady(taskid)) {
145         strcat(statStr, "READY");
146         firstStat = 0;
147     }
148     if (taskIsSuspended(taskid)) {
149         if (!firstStat) strcat(statStr, "|");
150         strcat(statStr, "SUSPENDED");
151         firstStat = 0;
152     }        
153     if (taskIsStopped(taskid)) {
154         if (!firstStat) strcat(statStr, "|");
155         strcat(statStr, "STOPPED");
156         firstStat = 0;
157     }
158     if (taskIsPended(taskid)) {
159         if (!firstStat) strcat(statStr, "|");
160         strcat(statStr, "PENDED");
161         firstStat = 0;
162     }
163     if (taskIsDelayed(taskid, &delayTicks)) {
164         if (!firstStat) strcat(statStr, "|");
165         sprintf(statStr + strlen(statStr), "DELAYED:%d", delayTicks);
166     }
167     strcat(statStr, ")");
168
169     newSize = strlen(nameStr) + strlen(statStr) + 1;
170     if (newSize > DYNINSTtaskNameSize) {
171         newBuf = (char *)realloc(DYNINSTtaskNameBuf, newSize);
172         if (newBuf) {
173             DYNINSTtaskNameSize = newSize;
174             DYNINSTtaskNameBuf  = newBuf;
175         } else {
176             fprintf(stderr, "Warning: nameBuf realloc failure (%d bytes).\n",
177                     newSize);
178         }
179     }
180
181     DYNINSTtaskNameBuf[0] = '\0';
182     strncpy(DYNINSTtaskNameBuf, nameStr, DYNINSTtaskNameSize);
183     strncat(DYNINSTtaskNameBuf, statStr, DYNINSTtaskNameSize);
184
185     return DYNINSTtaskNameBuf;
186 }
187
188 #include "dyninstAPI_RT/src/RTheap.h"
189 int DYNINSTheap_align = 4;
190 RT_Boolean DYNINSTheap_useMalloc(void *hi, void *lo)
191 {
192     return RT_TRUE;
193 }
194
195
196 int DYNINSTgetMemoryMap(unsigned *a, dyninstmm_t **b)
197 {
198     return -1; // I suppose this could be implemented from memInfo
199 }
200
201 int DYNINSTheap_mmapFdOpen(void)
202 {
203     return -1;
204 }
205
206 void DYNINSTheap_mmapFdClose(int fd)
207 {
208     return;
209 }