BPatch functions that block are now locked (on a finer grain than the rest of the...
[dyninst.git] / dyninstAPI_RT / src / RTposix.c
1 /*
2  * Copyright (c) 1996-2004 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * This license is for research uses.  For such uses, there is no
12  * charge. We define "research use" to mean you may freely use it
13  * inside your organization for whatever purposes you see fit. But you
14  * may not re-distribute Paradyn or parts of Paradyn, in any form
15  * source or binary (including derivatives), electronic or otherwise,
16  * to any other organization or entity without our permission.
17  * 
18  * (for other uses, please contact us at paradyn@cs.wisc.edu)
19  * 
20  * All warranties, including without limitation, any warranty of
21  * merchantability or fitness for a particular purpose, are hereby
22  * excluded.
23  * 
24  * By your use of Paradyn, you understand and agree that we (or any
25  * other person or entity with proprietary rights in Paradyn) are
26  * under no obligation to provide either maintenance services,
27  * update services, notices of latent defects, or correction of
28  * defects for Paradyn.
29  * 
30  * Even if advised of the possibility of such damages, under no
31  * circumstances shall we (or any other person or entity with
32  * proprietary rights in the software licensed hereunder) be liable
33  * to you or any third party for direct, indirect, or consequential
34  * damages of any character regardless of type of action, including,
35  * without limitation, loss of profits, loss of use, loss of good
36  * will, or computer failure or malfunction.  You agree to indemnify
37  * us (and any other person or entity with proprietary rights in the
38  * software licensed hereunder) for any and all liability it may
39  * incur to third parties resulting from your use of Paradyn.
40  */
41
42 /************************************************************************
43  * $Id: RTposix.c,v 1.11 2005/02/25 07:04:48 jaw Exp $
44  * RTposix.c: runtime instrumentation functions for generic posix.
45  ************************************************************************/
46
47 #include <assert.h>
48 #include <errno.h>
49 #include <memory.h>
50 #include <string.h>
51 #include <stdio.h>
52 #include <stdlib.h>
53 #include <fcntl.h>
54 #include <signal.h>
55 #include <unistd.h>
56 #include <sys/types.h>
57 #include <sys/socket.h>
58 #include <sys/un.h>
59 #include <pwd.h>
60 #include "dyninstAPI_RT/h/dyninstAPI_RT.h"
61
62 /************************************************************************
63  * void DYNINSTbreakPoint(void)
64  *
65  * stop oneself.
66 ************************************************************************/
67
68 void DYNINSTbreakPoint(void)
69 {
70
71 #if defined(bug_irix_broken_sigstop)
72      /* there is a bug in all 6.5 versions of IRIX through 6.5.9f that
73         cause a PIOCSTRACE on SIGSTOP to starve (at least under the
74         conditions that we are throwing it in.)  So on IRIX, we use
75         SIGEMT.   -- willb, 10/4/2000 */
76      kill(getpid(), SIGEMT);
77 #else
78      kill(getpid(), SIGSTOP);
79 #endif
80 }
81
82 /************************************************************************
83  * void DYNINSTasyncConnect(int pid)
84  *
85  * Connect to mutator's async handler thread. <pid> is pid of mutator
86 ************************************************************************/
87
88 int async_socket = -1;
89 dyninst_spinlock thelock;
90 int needToDisconnect = 0;
91 extern void DYNINSTlock_spinlock(dyninst_spinlock *);
92 extern void DYNINSTunlock_spinlock(dyninst_spinlock *);
93 int DYNINSTwriteEvent(void *ev, int sz);
94 void exit_func(void)
95 {
96   if (needToDisconnect) close (async_socket);
97 }
98 int DYNINSTasyncConnect(int pid)
99 {
100   
101   int sock_fd;
102   int err = 0;
103   struct sockaddr_un sadr;
104   rtBPatch_asyncEventRecord ev;
105   uid_t euid;
106   struct passwd *passwd_info;
107   char path[100];
108
109   euid = geteuid();
110   passwd_info = getpwuid(euid);
111   assert(passwd_info);
112
113   sprintf(path, "%s/dyninstAsync.%s.%d", P_tmpdir, passwd_info->pw_name, pid); /* P_tmpdir in <stdio.h> */
114
115   sock_fd = socket(PF_UNIX, SOCK_STREAM, 0);
116   if (sock_fd < 0) {
117     perror("DYNINSTasyncConnect() socket()");
118     abort();
119   }
120
121   sadr.sun_family = PF_UNIX;
122   strcpy(sadr.sun_path, path);
123
124   if (connect(sock_fd, (struct sockaddr *) &sadr, sizeof(sadr)) < 0) {
125     perror("DYNINSTasyncConnect() connect()");
126   }
127
128   /* maybe need to do fcntl to set nonblocking writes on this fd */
129
130   async_socket = sock_fd;
131
132   /* after connecting, we need to send along our pid */
133   ev.type = rtBPatch_newConnectionEvent;
134   ev.pid = getpid();
135   err = DYNINSTwriteEvent((void *) &ev, sizeof(rtBPatch_asyncEventRecord));
136
137   if (err) {
138     fprintf(stderr, "%s[%d]:  report new connection failed\n", __FILE__, __LINE__);
139     return 0;
140   }
141   /* initialize spinlock */
142   
143   thelock.lock = 0; 
144   needToDisconnect = 1;
145
146   atexit(exit_func);
147   return 1; /*true*/
148
149 }
150
151 int DYNINSTasyncDisconnect()
152 {
153   if (needToDisconnect)
154    close (async_socket);
155   return 0;
156 }
157
158 int DYNINSTwriteEvent(void *ev, int sz)
159 {
160   int res;
161
162 try_again:
163   res = write(async_socket, ev, sz); 
164   if (-1 == res) {
165     if (errno == EINTR || errno == EAGAIN) 
166        goto try_again;
167     else {
168        perror("write");
169        return -1;
170     }
171   }
172   if (res != sz) {
173     /*  maybe we need logic to handle partial writes? */
174     fprintf(stderr, "%s[%d]:  partial ? write error, %d bytes, should be %d\n",
175             __FILE__, __LINE__, res, sz);
176     return -1;
177   }
178   return 0;
179 }
180
181 void LockCommsMutex()
182 {
183   DYNINSTlock_spinlock(&thelock);
184 }
185 void UnlockCommsMutex()
186 {
187   DYNINSTunlock_spinlock(&thelock);
188 }
189