1 /* Copyright (C) 2021-2024 Free Software Foundation, Inc.
2 Contributed by Oracle.
3
4 This file is part of GNU Binutils.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
9 any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
20
21 /*
22 * IO events
23 */
24 #include "config.h"
25 #include <dlfcn.h>
26 #include <errno.h>
27 #include <stdarg.h>
28 #include <stddef.h>
29 #include <stdlib.h>
30
31 // create() and others are defined in fcntl.h.
32 // Our 'create' should not have the __nonnull attribute
33 #undef __nonnull
34 #define __nonnull(x)
35 #include <fcntl.h>
36
37 #include "gp-defs.h"
38 #include "collector.h"
39 #include "gp-experiment.h"
40 #include "tsd.h"
41
42
43 /* define the packet that will be written out */
44 typedef struct IOTrace_packet
45 { /* IO tracing packet */
46 Common_packet comm;
47 IOTrace_type iotype; /* IO type */
48 int32_t fd; /* file descriptor */
49 Size_type nbyte; /* number of bytes */
50 hrtime_t requested; /* time of IO requested */
51 int32_t ofd; /* original file descriptor */
52 FileSystem_type fstype; /* file system type */
53 char fname; /* file name */
54 } IOTrace_packet;
55
56 typedef long long offset_t;
57
58 static int open_experiment (const char *);
59 static int start_data_collection (void);
60 static int stop_data_collection (void);
61 static int close_experiment (void);
62 static int detach_experiment (void);
63 static int init_io_intf ();
64
65 static ModuleInterface module_interface ={
66 SP_IOTRACE_FILE, /* description */
67 NULL, /* initInterface */
68 open_experiment, /* openExperiment */
69 start_data_collection, /* startDataCollection */
70 stop_data_collection, /* stopDataCollection */
71 close_experiment, /* closeExperiment */
72 detach_experiment /* detachExperiment (fork child) */
73 };
74
75 static CollectorInterface *collector_interface = NULL;
76 static struct Heap *io_heap = NULL;
77 static int io_mode = 0;
78 static CollectorModule io_hndl = COLLECTOR_MODULE_ERR;
79 static unsigned io_key = COLLECTOR_TSD_INVALID_KEY;
80
81 #define CHCK_REENTRANCE(x) (!io_mode || ((x) = collector_interface->getKey( io_key )) == NULL || (*(x) != 0))
82 #define RECHCK_REENTRANCE(x) (!io_mode || ((x) = collector_interface->getKey( io_key )) == NULL || (*(x) == 0))
83 #define PUSH_REENTRANCE(x) ((*(x))++)
84 #define POP_REENTRANCE(x) ((*(x))--)
85 #define gethrtime collector_interface->getHiResTime
86
87
88 /* interposition function handles */
89 static int (*__real_open)(const char *path, int oflag, ...) = NULL;
90 static int (*__real_fcntl)(int fildes, int cmd, ...) = NULL;
91 static int (*__real_openat)(int fildes, const char *path, int oflag, ...) = NULL;
92 static int (*__real_close)(int fildes) = NULL;
93 static FILE *(*__real_fopen)(const char *filename, const char *mode) = NULL;
94 static int (*__real_fclose)(FILE *stream) = NULL;
95 static int (*__real_dup)(int fildes) = NULL;
96 static int (*__real_dup2)(int fildes, int fildes2) = NULL;
97 static int (*__real_pipe)(int fildes[2]) = NULL;
98 static int (*__real_socket)(int domain, int type, int protocol) = NULL;
99 static int (*__real_mkstemp)(char *template) = NULL;
100 static int (*__real_mkstemps)(char *template, int slen) = NULL;
101 static int (*__real_creat)(const char *path, mode_t mode) = NULL;
102 static FILE *(*__real_fdopen)(int fildes, const char *mode) = NULL;
103 static ssize_t (*__real_read)(int fildes, void *buf, size_t nbyte) = NULL;
104 static ssize_t (*__real_write)(int fildes, const void *buf, size_t nbyte) = NULL;
105 static ssize_t (*__real_readv)(int fildes, const struct iovec *iov, int iovcnt) = NULL;
106 static ssize_t (*__real_writev)(int fildes, const struct iovec *iov, int iovcnt) = NULL;
107 static size_t (*__real_fread)(void *ptr, size_t size, size_t nitems, FILE *stream) = NULL;
108 static size_t (*__real_fwrite)(const void *ptr, size_t size, size_t nitems, FILE *stream) = NULL;
109 static ssize_t (*__real_pread)(int fildes, void *buf, size_t nbyte, off_t offset) = NULL;
110 static ssize_t (*__real_pwrite)(int fildes, const void *buf, size_t nbyte, off_t offset) = NULL;
111 static ssize_t (*__real_pwrite64)(int fildes, const void *buf, size_t nbyte, off64_t offset) = NULL;
112 static char *(*__real_fgets)(char *s, int n, FILE *stream) = NULL;
113 static int (*__real_fputs)(const char *s, FILE *stream) = NULL;
114 static int (*__real_fputc)(int c, FILE *stream) = NULL;
115 static int (*__real_fprintf)(FILE *stream, const char *format, ...) = NULL;
116 static int (*__real_vfprintf)(FILE *stream, const char *format, va_list ap) = NULL;
117 static off_t (*__real_lseek)(int fildes, off_t offset, int whence) = NULL;
118 static offset_t (*__real_llseek)(int fildes, offset_t offset, int whence) = NULL;
119 static int (*__real_chmod)(const char *path, mode_t mode) = NULL;
120 static int (*__real_access)(const char *path, int amode) = NULL;
121 static int (*__real_rename)(const char *old, const char *new) = NULL;
122 static int (*__real_mkdir)(const char *path, mode_t mode) = NULL;
123 static int (*__real_getdents)(int fildes, struct dirent *buf, size_t nbyte) = NULL;
124 static int (*__real_unlink)(const char *path) = NULL;
125 static int (*__real_fseek)(FILE *stream, long offset, int whence) = NULL;
126 static void (*__real_rewind)(FILE *stream) = NULL;
127 static long (*__real_ftell)(FILE *stream) = NULL;
128 static int (*__real_fgetpos)(FILE *stream, fpos_t *pos) = NULL;
129 static int (*__real_fsetpos)(FILE *stream, const fpos_t *pos) = NULL;
130 static int (*__real_fsync)(int fildes) = NULL;
131 static struct dirent *(*__real_readdir)(DIR *dirp) = NULL;
132 static int (*__real_flock)(int fd, int operation) = NULL;
133 static int (*__real_lockf)(int fildes, int function, off_t size) = NULL;
134 static int (*__real_fflush)(FILE *stream) = NULL;
135 static int (*__real_open64)(const char *path, int oflag, ...) = NULL;
136 static int (*__real_open64_2_2)(const char *path, int oflag, ...) = NULL;
137 static int (*__real_creat64)(const char *path, mode_t mode) = NULL;
138 static int (*__real_fgetpos64)(FILE *stream, fpos64_t *pos) = NULL;
139 static int (*__real_fsetpos64)(FILE *stream, const fpos64_t *pos) = NULL;
140 static FILE *(*__real_fopen_2_17)(const char *filename, const char *mode) = NULL;
141 static FILE *(*__real_fopen_2_2_5)(const char *filename, const char *mode) = NULL;
142 static FILE *(*__real_fopen_2_1)(const char *filename, const char *mode) = NULL;
143 static FILE *(*__real_fopen_2_0)(const char *filename, const char *mode) = NULL;
144 static int (*__real_fclose_2_17)(FILE *stream) = NULL;
145 static int (*__real_fclose_2_2_5)(FILE *stream) = NULL;
146 static int (*__real_fclose_2_1)(FILE *stream) = NULL;
147 static int (*__real_fclose_2_0)(FILE *stream) = NULL;
148 static FILE *(*__real_fdopen_2_17)(int fildes, const char *mode) = NULL;
149 static FILE *(*__real_fdopen_2_2_5)(int fildes, const char *mode) = NULL;
150 static FILE *(*__real_fdopen_2_1)(int fildes, const char *mode) = NULL;
151 static FILE *(*__real_fdopen_2_0)(int fildes, const char *mode) = NULL;
152 static int (*__real_fgetpos_2_17)(FILE *stream, fpos_t *pos) = NULL;
153 static int (*__real_fgetpos_2_2_5)(FILE *stream, fpos_t *pos) = NULL;
154 static int (*__real_fgetpos_2_2)(FILE *stream, fpos_t *pos) = NULL;
155 static int (*__real_fgetpos_2_0)(FILE *stream, fpos_t *pos) = NULL;
156 static int (*__real_fsetpos_2_17)(FILE *stream, const fpos_t *pos) = NULL;
157 static int (*__real_fsetpos_2_2_5)(FILE *stream, const fpos_t *pos) = NULL;
158 static int (*__real_fsetpos_2_2)(FILE *stream, const fpos_t *pos) = NULL;
159 static int (*__real_fsetpos_2_0)(FILE *stream, const fpos_t *pos) = NULL;
160 static ssize_t (*__real_pread_2_2)(int fildes, void *buf, size_t nbyte, off_t offset) = NULL;
161 static ssize_t (*__real_pwrite_2_2)(int fildes, const void *buf, size_t nbyte, off_t offset) = NULL;
162 static int (*__real_fgetpos64_2_17)(FILE *stream, fpos64_t *pos) = NULL;
163 static int (*__real_fgetpos64_2_2_5)(FILE *stream, fpos64_t *pos) = NULL;
164 static int (*__real_fgetpos64_2_2)(FILE *stream, fpos64_t *pos) = NULL;
165 static int (*__real_fgetpos64_2_1)(FILE *stream, fpos64_t *pos) = NULL;
166 static int (*__real_fsetpos64_2_17)(FILE *stream, const fpos64_t *pos) = NULL;
167 static int (*__real_fsetpos64_2_2_5)(FILE *stream, const fpos64_t *pos) = NULL;
168 static int (*__real_fsetpos64_2_2)(FILE *stream, const fpos64_t *pos) = NULL;
169 static int (*__real_fsetpos64_2_1)(FILE *stream, const fpos64_t *pos) = NULL;
170 static ssize_t (*__real_pwrite64_2_2)(int fildes, const void *buf, size_t nbyte, off64_t offset) = NULL;
171
172 static int
collector_align_pktsize(int sz)173 collector_align_pktsize (int sz)
174 {
175 int pktSize = sz;
176 if (sz <= 0)
177 return sz;
178 if ((sz % 8) != 0)
179 {
180 pktSize = (sz / 8) + 1;
181 pktSize *= 8;
182 }
183 return pktSize;
184 }
185
186 static void
collector_memset(void * s,int c,size_t n)187 collector_memset (void *s, int c, size_t n)
188 {
189 unsigned char *s1 = s;
190 while (n--)
191 *s1++ = (unsigned char) c;
192 }
193
194 static size_t
collector_strlen(const char * s)195 collector_strlen (const char *s)
196 {
197 if (s == NULL)
198 return 0;
199 int len = -1;
200 while (s[++len] != '\0')
201 ;
202 return len;
203 }
204
205 static size_t
collector_strncpy(char * dst,const char * src,size_t dstsize)206 collector_strncpy (char *dst, const char *src, size_t dstsize)
207 {
208 size_t i;
209 for (i = 0; i < dstsize; i++)
210 {
211 dst[i] = src[i];
212 if (src[i] == '\0')
213 break;
214 }
215 return i;
216 }
217
218 static char *
collector_strchr(const char * s,int c)219 collector_strchr (const char *s, int c)
220 {
221 do
222 {
223 if (*s == (char) c)
224 return ((char *) s);
225 }
226 while (*s++);
227 return (NULL);
228 }
229
230 static FileSystem_type
collector_fstype(const char * path)231 collector_fstype (const char *path)
232 {
233 return UNKNOWNFS_TYPE;
234 }
235
236 void
__collector_module_init(CollectorInterface * _collector_interface)237 __collector_module_init (CollectorInterface *_collector_interface)
238 {
239 if (_collector_interface == NULL)
240 return;
241 collector_interface = _collector_interface;
242 Tprintf (0, "iotrace: __collector_module_init\n");
243 io_hndl = collector_interface->registerModule (&module_interface);
244 /* Initialize next module */
245 ModuleInitFunc next_init = (ModuleInitFunc) dlsym (RTLD_NEXT, "__collector_module_init");
246 if (next_init != NULL)
247 next_init (_collector_interface);
248 return;
249 }
250
251 static int
open_experiment(const char * exp)252 open_experiment (const char *exp)
253 {
254 if (collector_interface == NULL)
255 {
256 Tprintf (0, "iotrace: collector_interface is null.\n");
257 return COL_ERROR_IOINIT;
258 }
259 if (io_hndl == COLLECTOR_MODULE_ERR)
260 {
261 Tprintf (0, "iotrace: handle create failed.\n");
262 collector_interface->writeLog ("<event kind=\"%s\" id=\"%d\">data handle not created</event>\n",
263 SP_JCMD_CERROR, COL_ERROR_IOINIT);
264 return COL_ERROR_IOINIT;
265 }
266 TprintfT (0, "iotrace: open_experiment %s\n", exp);
267 if (NULL_PTR (fopen))
268 init_io_intf ();
269 if (io_heap == NULL)
270 {
271 io_heap = collector_interface->newHeap ();
272 if (io_heap == NULL)
273 {
274 Tprintf (0, "iotrace: new heap failed.\n");
275 collector_interface->writeLog ("<event kind=\"%s\" id=\"%d\">new iotrace heap not created</event>\n",
276 SP_JCMD_CERROR, COL_ERROR_IOINIT);
277 return COL_ERROR_IOINIT;
278 }
279 }
280
281 const char *params = collector_interface->getParams ();
282 while (params)
283 {
284 if ((params[0] == 'i') && (params[1] == ':'))
285 {
286 params += 2;
287 break;
288 }
289 params = collector_strchr (params, ';');
290 if (params)
291 params++;
292 }
293 if (params == NULL) /* IO data collection not specified */
294 return COL_ERROR_IOINIT;
295
296 io_key = collector_interface->createKey (sizeof ( int), NULL, NULL);
297 if (io_key == (unsigned) - 1)
298 {
299 Tprintf (0, "iotrace: TSD key create failed.\n");
300 collector_interface->writeLog ("<event kind=\"%s\" id=\"%d\">TSD key not created</event>\n",
301 SP_JCMD_CERROR, COL_ERROR_IOINIT);
302 return COL_ERROR_IOINIT;
303 }
304
305 collector_interface->writeLog ("<profile name=\"%s\">\n", SP_JCMD_IOTRACE);
306 collector_interface->writeLog (" <profdata fname=\"%s\"/>\n",
307 module_interface.description);
308 /* Record IOTrace_packet description */
309 collector_interface->writeLog (" <profpckt kind=\"%d\" uname=\"IO tracing data\">\n", IOTRACE_PCKT);
310 collector_interface->writeLog (" <field name=\"LWPID\" uname=\"Lightweight process id\" offset=\"%d\" type=\"%s\"/>\n",
311 (int) offsetof (IOTrace_packet, comm.lwp_id),
312 fld_sizeof (IOTrace_packet, comm.lwp_id) == 4 ? "INT32" : "INT64");
313 collector_interface->writeLog (" <field name=\"THRID\" uname=\"Thread number\" offset=\"%d\" type=\"%s\"/>\n",
314 (int) offsetof (IOTrace_packet, comm.thr_id),
315 fld_sizeof (IOTrace_packet, comm.thr_id) == 4 ? "INT32" : "INT64");
316 collector_interface->writeLog (" <field name=\"CPUID\" uname=\"CPU id\" offset=\"%d\" type=\"%s\"/>\n",
317 (int) offsetof (IOTrace_packet, comm.cpu_id),
318 fld_sizeof (IOTrace_packet, comm.cpu_id) == 4 ? "INT32" : "INT64");
319 collector_interface->writeLog (" <field name=\"TSTAMP\" uname=\"High resolution timestamp\" offset=\"%d\" type=\"%s\"/>\n",
320 (int) offsetof (IOTrace_packet, comm.tstamp),
321 fld_sizeof (IOTrace_packet, comm.tstamp) == 4 ? "INT32" : "INT64");
322 collector_interface->writeLog (" <field name=\"FRINFO\" offset=\"%d\" type=\"%s\"/>\n",
323 (int) offsetof (IOTrace_packet, comm.frinfo),
324 fld_sizeof (IOTrace_packet, comm.frinfo) == 4 ? "INT32" : "INT64");
325 collector_interface->writeLog (" <field name=\"IOTYPE\" uname=\"IO trace function type\" offset=\"%d\" type=\"%s\"/>\n",
326 (int) offsetof (IOTrace_packet, iotype),
327 fld_sizeof (IOTrace_packet, iotype) == 4 ? "INT32" : "INT64");
328 collector_interface->writeLog (" <field name=\"IOFD\" uname=\"File descriptor\" offset=\"%d\" type=\"%s\"/>\n",
329 (int) offsetof (IOTrace_packet, fd),
330 fld_sizeof (IOTrace_packet, fd) == 4 ? "INT32" : "INT64");
331 collector_interface->writeLog (" <field name=\"IONBYTE\" uname=\"Number of bytes\" offset=\"%d\" type=\"%s\"/>\n",
332 (int) offsetof (IOTrace_packet, nbyte),
333 fld_sizeof (IOTrace_packet, nbyte) == 4 ? "INT32" : "INT64");
334 collector_interface->writeLog (" <field name=\"IORQST\" uname=\"Time of IO requested\" offset=\"%d\" type=\"%s\"/>\n",
335 (int) offsetof (IOTrace_packet, requested),
336 fld_sizeof (IOTrace_packet, requested) == 4 ? "INT32" : "INT64");
337 collector_interface->writeLog (" <field name=\"IOOFD\" uname=\"Original file descriptor\" offset=\"%d\" type=\"%s\"/>\n",
338 (int) offsetof (IOTrace_packet, ofd),
339 fld_sizeof (IOTrace_packet, ofd) == 4 ? "INT32" : "INT64");
340 collector_interface->writeLog (" <field name=\"IOFSTYPE\" uname=\"File system type\" offset=\"%d\" type=\"%s\"/>\n",
341 (int) offsetof (IOTrace_packet, fstype),
342 fld_sizeof (IOTrace_packet, fstype) == 4 ? "INT32" : "INT64");
343 collector_interface->writeLog (" <field name=\"IOFNAME\" uname=\"File name\" offset=\"%d\" type=\"%s\"/>\n",
344 (int) offsetof (IOTrace_packet, fname), "STRING");
345 collector_interface->writeLog (" </profpckt>\n");
346 collector_interface->writeLog ("</profile>\n");
347 return COL_ERROR_NONE;
348 }
349
350 static int
start_data_collection(void)351 start_data_collection (void)
352 {
353 io_mode = 1;
354 Tprintf (0, "iotrace: start_data_collection\n");
355 return 0;
356 }
357
358 static int
stop_data_collection(void)359 stop_data_collection (void)
360 {
361 io_mode = 0;
362 Tprintf (0, "iotrace: stop_data_collection\n");
363 return 0;
364 }
365
366 static int
close_experiment(void)367 close_experiment (void)
368 {
369 io_mode = 0;
370 io_key = COLLECTOR_TSD_INVALID_KEY;
371 if (io_heap != NULL)
372 {
373 collector_interface->deleteHeap (io_heap);
374 io_heap = NULL;
375 }
376 Tprintf (0, "iotrace: close_experiment\n");
377 return 0;
378 }
379
380 static int
detach_experiment(void)381 detach_experiment (void)
382 {
383 /* fork child. Clean up state but don't write to experiment */
384 io_mode = 0;
385 io_key = COLLECTOR_TSD_INVALID_KEY;
386 if (io_heap != NULL)
387 {
388 collector_interface->deleteHeap (io_heap);
389 io_heap = NULL;
390 }
391 Tprintf (0, "iotrace: detach_experiment\n");
392 return 0;
393 }
394
395 static int
init_fopen(void * dlflag)396 init_fopen (void *dlflag)
397 {
398 __real_fopen_2_17 = dlvsym (dlflag, "fopen", "GLIBC_2.17");
399 __real_fopen_2_2_5 = dlvsym (dlflag, "fopen", "GLIBC_2.2.5");
400 __real_fopen_2_1 = dlvsym (dlflag, "fopen", "GLIBC_2.1");
401 __real_fopen_2_0 = dlvsym (dlflag, "fopen", "GLIBC_2.0");
402 if (__real_fopen_2_17)
403 __real_fopen = __real_fopen_2_17;
404 else if (__real_fopen_2_2_5)
405 __real_fopen = __real_fopen_2_2_5;
406 else if (__real_fopen_2_1)
407 __real_fopen = __real_fopen_2_1;
408 else if (__real_fopen_2_0)
409 __real_fopen = __real_fopen_2_0;
410 else
411 __real_fopen = dlsym (dlflag, "fopen");
412 return __real_fopen ? 1 : 0;
413 }
414
415 static int
init_io_intf()416 init_io_intf ()
417 {
418 void *dlflag;
419 int rc = 0;
420 /* if we detect recursion/reentrance, SEGV so we can get a stack */
421 static int init_io_intf_started;
422 static int init_io_intf_finished;
423 init_io_intf_started++;
424 if (!init_io_intf_finished && init_io_intf_started >= 3)
425 {
426 /* pull the plug if recursion occurs... */
427 abort ();
428 }
429
430 /* lookup fprint to print fatal error message */
431 void *ptr = dlsym (RTLD_NEXT, "fprintf");
432 if (ptr)
433 __real_fprintf = (int (*)(FILE*, const char*, ...)) ptr;
434 else
435 abort ();
436
437 dlflag = RTLD_NEXT;
438 if (init_fopen (dlflag) == 0)
439 {
440 if (init_fopen (RTLD_DEFAULT))
441 dlflag = RTLD_DEFAULT;
442 else
443 {
444 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT fopen\n");
445 rc = COL_ERROR_IOINIT;
446 }
447 }
448
449 __real_fgetpos64_2_17 = dlvsym (dlflag, "fgetpos64", "GLIBC_2.17");
450 __real_fgetpos64_2_2_5 = dlvsym (dlflag, "fgetpos64", "GLIBC_2.2.5");
451 __real_fgetpos64_2_2 = dlvsym (dlflag, "fgetpos64", "GLIBC_2.2");
452 __real_fgetpos64_2_1 = dlvsym (dlflag, "fgetpos64", "GLIBC_2.1");
453 if (__real_fgetpos64_2_17)
454 __real_fgetpos64 = __real_fgetpos64_2_17;
455 else if (__real_fgetpos64_2_2_5)
456 __real_fgetpos64 = __real_fgetpos64_2_2_5;
457 else if (__real_fgetpos64_2_2)
458 __real_fgetpos64 = __real_fgetpos64_2_2;
459 else if (__real_fgetpos64_2_1)
460 __real_fgetpos64 = __real_fgetpos64_2_1;
461 else
462 __real_fgetpos64 = dlsym (dlflag, "fgetpos64");
463
464 __real_fsetpos64_2_17 = dlvsym (dlflag, "fsetpos64", "GLIBC_2.17");
465 __real_fsetpos64_2_2_5 = dlvsym (dlflag, "fsetpos64", "GLIBC_2.2.5");
466 __real_fsetpos64_2_2 = dlvsym (dlflag, "fsetpos64", "GLIBC_2.2");
467 __real_fsetpos64_2_1 = dlvsym (dlflag, "fsetpos64", "GLIBC_2.1");
468 if (__real_fsetpos64_2_17)
469 __real_fsetpos64 = __real_fsetpos64_2_17;
470 else if (__real_fsetpos64_2_2_5)
471 __real_fsetpos64 = __real_fsetpos64_2_2_5;
472 else if (__real_fsetpos64_2_2)
473 __real_fsetpos64 = __real_fsetpos64_2_2;
474 else if (__real_fsetpos64_2_1)
475 __real_fsetpos64 = __real_fsetpos64_2_1;
476 else
477 __real_fsetpos64 = dlsym (dlflag, "fsetpos64");
478
479 __real_pread_2_2 = dlvsym (dlflag, "pread", "GLIBC_2.2");
480 if (__real_pread_2_2)
481 __real_pread = __real_pread_2_2;
482 else
483 __real_pread = dlsym (dlflag, "pread");
484 if (__real_pread == NULL)
485 {
486 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT pread\n");
487 rc = COL_ERROR_IOINIT;
488 }
489
490 __real_pwrite_2_2 = dlvsym (dlflag, "pwrite", "GLIBC_2.2");
491 if (__real_pwrite_2_2)
492 __real_pwrite = __real_pwrite_2_2;
493 else
494 __real_pwrite = dlsym (dlflag, "pwrite");
495 if (__real_pwrite == NULL)
496 {
497 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT pwrite\n");
498 rc = COL_ERROR_IOINIT;
499 }
500
501
502 __real_pwrite64_2_2 = dlvsym (dlflag, "pwrite64", "GLIBC_2.2");
503 if (__real_pwrite64_2_2)
504 __real_pwrite64 = __real_pwrite64_2_2;
505 else
506 __real_pwrite64 = dlsym (dlflag, "pwrite64");
507
508 __real_fclose_2_17 = dlvsym (dlflag, "fclose", "GLIBC_2.17");
509 __real_fclose_2_2_5 = dlvsym (dlflag, "fclose", "GLIBC_2.2.5");
510 __real_fclose_2_1 = dlvsym (dlflag, "fclose", "GLIBC_2.1");
511 __real_fclose_2_0 = dlvsym (dlflag, "fclose", "GLIBC_2.0");
512 if (__real_fclose_2_17)
513 __real_fclose = __real_fclose_2_17;
514 else if (__real_fclose_2_2_5)
515 __real_fclose = __real_fclose_2_2_5;
516 else if (__real_fclose_2_1)
517 __real_fclose = __real_fclose_2_1;
518 else if (__real_fclose_2_0)
519 __real_fclose = __real_fclose_2_0;
520 else
521 __real_fclose = dlsym (dlflag, "fclose");
522 if (__real_fclose == NULL)
523 {
524 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT fclose\n");
525 rc = COL_ERROR_IOINIT;
526 }
527
528 __real_fdopen_2_17 = dlvsym (dlflag, "fdopen", "GLIBC_2.17");
529 __real_fdopen_2_2_5 = dlvsym (dlflag, "fdopen", "GLIBC_2.2.5");
530 __real_fdopen_2_1 = dlvsym (dlflag, "fdopen", "GLIBC_2.1");
531 __real_fdopen_2_0 = dlvsym (dlflag, "fdopen", "GLIBC_2.0");
532 if (__real_fdopen_2_17)
533 __real_fdopen = __real_fdopen_2_17;
534 else if (__real_fdopen_2_2_5)
535 __real_fdopen = __real_fdopen_2_2_5;
536 else if (__real_fdopen_2_1)
537 __real_fdopen = __real_fdopen_2_1;
538 else if (__real_fdopen_2_0)
539 __real_fdopen = __real_fdopen_2_0;
540 else
541 __real_fdopen = dlsym (dlflag, "fdopen");
542 if (__real_fdopen == NULL)
543 {
544 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT fdopen\n");
545 rc = COL_ERROR_IOINIT;
546 }
547
548 __real_fgetpos_2_17 = dlvsym (dlflag, "fgetpos", "GLIBC_2.17");
549 __real_fgetpos_2_2_5 = dlvsym (dlflag, "fgetpos", "GLIBC_2.2.5");
550 __real_fgetpos_2_2 = dlvsym (dlflag, "fgetpos", "GLIBC_2.2");
551 __real_fgetpos_2_0 = dlvsym (dlflag, "fgetpos", "GLIBC_2.0");
552 if (__real_fgetpos_2_17)
553 __real_fgetpos = __real_fgetpos_2_17;
554 else if (__real_fgetpos_2_2_5)
555 __real_fgetpos = __real_fgetpos_2_2_5;
556 else if (__real_fgetpos_2_2)
557 __real_fgetpos = __real_fgetpos_2_2;
558 else if (__real_fgetpos_2_0)
559 __real_fgetpos = __real_fgetpos_2_0;
560 else
561 __real_fgetpos = dlsym (dlflag, "fgetpos");
562 if (__real_fgetpos == NULL)
563 {
564 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT fgetpos\n");
565 rc = COL_ERROR_IOINIT;
566 }
567
568 __real_fsetpos_2_17 = dlvsym (dlflag, "fsetpos", "GLIBC_2.17");
569 __real_fsetpos_2_2_5 = dlvsym (dlflag, "fsetpos", "GLIBC_2.2.5");
570 __real_fsetpos_2_2 = dlvsym (dlflag, "fsetpos", "GLIBC_2.2");
571 __real_fsetpos_2_0 = dlvsym (dlflag, "fsetpos", "GLIBC_2.0");
572 if (__real_fsetpos_2_17)
573 __real_fsetpos = __real_fsetpos_2_17;
574 else if (__real_fsetpos_2_2_5)
575 __real_fsetpos = __real_fsetpos_2_2_5;
576 else if (__real_fsetpos_2_2)
577 __real_fsetpos = __real_fsetpos_2_2;
578 else if (__real_fsetpos_2_0)
579 __real_fsetpos = __real_fsetpos_2_0;
580 else
581 __real_fsetpos = dlsym (dlflag, "fsetpos");
582 if (__real_fsetpos == NULL)
583 {
584 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT fsetpos\n");
585 rc = COL_ERROR_IOINIT;
586 }
587
588 __real_open = (int (*)(const char*, int, ...))dlsym (dlflag, "open");
589 if (__real_open == NULL)
590 {
591 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT open\n");
592 rc = COL_ERROR_IOINIT;
593 }
594
595 __real_open64_2_2 = dlvsym (dlflag, "open64", "GLIBC_2.2");
596 if (__real_open64_2_2)
597 __real_open64 = __real_open64_2_2;
598 else
599 __real_open64 = dlsym (dlflag, "open64");
600
601 __real_fcntl = (int (*)(int, int, ...))dlsym (dlflag, "fcntl");
602 if (__real_fcntl == NULL)
603 {
604 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT fcntl\n");
605 rc = COL_ERROR_IOINIT;
606 }
607
608 __real_openat = (int (*)(int, const char*, int, ...))dlsym (dlflag, "openat");
609 if (__real_openat == NULL)
610 {
611 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT openat\n");
612 rc = COL_ERROR_IOINIT;
613 }
614
615 __real_close = (int (*)(int))dlsym (dlflag, "close");
616 if (__real_close == NULL)
617 {
618 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT close\n");
619 rc = COL_ERROR_IOINIT;
620 }
621
622 __real_dup = (int (*)(int))dlsym (dlflag, "dup");
623 if (__real_dup == NULL)
624 {
625 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT dup\n");
626 rc = COL_ERROR_IOINIT;
627 }
628
629 __real_dup2 = (int (*)(int, int))dlsym (dlflag, "dup2");
630 if (__real_dup2 == NULL)
631 {
632 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT dup2\n");
633 rc = COL_ERROR_IOINIT;
634 }
635
636 __real_pipe = (int (*)(int[]))dlsym (dlflag, "pipe");
637 if (__real_pipe == NULL)
638 {
639 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT pipe\n");
640 rc = COL_ERROR_IOINIT;
641 }
642
643 __real_socket = (int (*)(int, int, int))dlsym (dlflag, "socket");
644 if (__real_socket == NULL)
645 {
646 __real_socket = (int (*)(int, int, int))dlsym (RTLD_NEXT, "socket");
647 if (__real_socket == NULL)
648 {
649 #if 0
650 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERXXX_IOINIT socket\n");
651 rc = COL_ERROR_IOINIT;
652 #endif
653 }
654 }
655
656 __real_mkstemp = (int (*)(char*))dlsym (dlflag, "mkstemp");
657 if (__real_mkstemp == NULL)
658 {
659 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT mkstemp\n");
660 rc = COL_ERROR_IOINIT;
661 }
662
663 __real_mkstemps = (int (*)(char*, int))dlsym (dlflag, "mkstemps");
664 if (__real_mkstemps == NULL)
665 {
666 #if 0
667 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERXXX_IOINIT mkstemps\n");
668 rc = COL_ERROR_IOINIT;
669 #endif
670 }
671
672 __real_creat = (int (*)(const char*, mode_t))dlsym (dlflag, "creat");
673 if (__real_creat == NULL)
674 {
675 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT creat\n");
676 rc = COL_ERROR_IOINIT;
677 }
678
679 __real_creat64 = (int (*)(const char*, mode_t))dlsym (dlflag, "creat64");
680 if (__real_creat64 == NULL)
681 {
682 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT creat64\n");
683 rc = COL_ERROR_IOINIT;
684 }
685
686 __real_read = (ssize_t (*)(int, void*, size_t))dlsym (dlflag, "read");
687 if (__real_read == NULL)
688 {
689 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT read\n");
690 rc = COL_ERROR_IOINIT;
691 }
692
693 __real_write = (ssize_t (*)(int, const void*, size_t))dlsym (dlflag, "write");
694 if (__real_write == NULL)
695 {
696 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT write\n");
697 rc = COL_ERROR_IOINIT;
698 }
699
700 __real_readv = (ssize_t (*)(int, const struct iovec*, int))dlsym (dlflag, "readv");
701 if (__real_readv == NULL)
702 {
703 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT readv\n");
704 rc = COL_ERROR_IOINIT;
705 }
706
707 __real_writev = (ssize_t (*)(int, const struct iovec*, int))dlsym (dlflag, "writev");
708 if (__real_writev == NULL)
709 {
710 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT writev\n");
711 rc = COL_ERROR_IOINIT;
712 }
713
714 __real_fread = (size_t (*)(void*, size_t, size_t, FILE*))dlsym (dlflag, "fread");
715 if (__real_fread == NULL)
716 {
717 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT fread\n");
718 rc = COL_ERROR_IOINIT;
719 }
720
721 __real_fwrite = (size_t (*)(const void*, size_t, size_t, FILE*))dlsym (dlflag, "fwrite");
722 if (__real_fwrite == NULL)
723 {
724 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT fwrite\n");
725 rc = COL_ERROR_IOINIT;
726 }
727
728 __real_pread = (ssize_t (*)(int, void*, size_t, off_t))dlsym (dlflag, "pread");
729 if (__real_pread == NULL)
730 {
731 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT pread\n");
732 rc = COL_ERROR_IOINIT;
733 }
734
735 __real_pwrite = (ssize_t (*)(int, const void*, size_t, off_t))dlsym (dlflag, "pwrite");
736 if (__real_pwrite == NULL)
737 {
738 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT pwrite\n");
739 rc = COL_ERROR_IOINIT;
740 }
741
742 __real_pwrite64 = (ssize_t (*)(int, const void*, size_t, off64_t))dlsym (dlflag, "pwrite64");
743 if (__real_pwrite64 == NULL)
744 {
745 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT pwrite64\n");
746 rc = COL_ERROR_IOINIT;
747 }
748
749 __real_fgets = (char* (*)(char*, int, FILE*))dlsym (dlflag, "fgets");
750 if (__real_fgets == NULL)
751 {
752 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT fgets\n");
753 rc = COL_ERROR_IOINIT;
754 }
755
756 __real_fputs = (int (*)(const char*, FILE*))dlsym (dlflag, "fputs");
757 if (__real_fputs == NULL)
758 {
759 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT fputs\n");
760 rc = COL_ERROR_IOINIT;
761 }
762
763 __real_fputc = (int (*)(int, FILE*))dlsym (dlflag, "fputc");
764 if (__real_fputc == NULL)
765 {
766 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT fputc\n");
767 rc = COL_ERROR_IOINIT;
768 }
769
770 __real_vfprintf = (int (*)(FILE*, const char*, va_list))dlsym (dlflag, "vfprintf");
771 if (__real_vfprintf == NULL)
772 {
773 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT vfprintf\n");
774 rc = COL_ERROR_IOINIT;
775 }
776
777
778 __real_lseek = (off_t (*)(int, off_t, int))dlsym (dlflag, "lseek");
779 if (__real_lseek == NULL)
780 {
781 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT lseek\n");
782 rc = COL_ERROR_IOINIT;
783 }
784
785 __real_llseek = (offset_t (*)(int, offset_t, int))dlsym (dlflag, "llseek");
786 if (__real_llseek == NULL)
787 {
788 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT llseek\n");
789 rc = COL_ERROR_IOINIT;
790 }
791
792 __real_chmod = (int (*)(const char*, mode_t))dlsym (dlflag, "chmod");
793 if (__real_chmod == NULL)
794 {
795 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT chmod\n");
796 rc = COL_ERROR_IOINIT;
797 }
798
799 __real_access = (int (*)(const char*, int))dlsym (dlflag, "access");
800 if (__real_access == NULL)
801 {
802 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT access\n");
803 rc = COL_ERROR_IOINIT;
804 }
805
806 __real_rename = (int (*)(const char*, const char*))dlsym (dlflag, "rename");
807 if (__real_rename == NULL)
808 {
809 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT rename\n");
810 rc = COL_ERROR_IOINIT;
811 }
812
813 __real_mkdir = (int (*)(const char*, mode_t))dlsym (dlflag, "mkdir");
814 if (__real_mkdir == NULL)
815 {
816 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT mkdir\n");
817 rc = COL_ERROR_IOINIT;
818 }
819
820 __real_getdents = (int (*)(int, struct dirent*, size_t))dlsym (dlflag, "getdents");
821 if (__real_getdents == NULL)
822 {
823 #if 0
824 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERXXX_IOINIT getdents\n");
825 rc = COL_ERROR_IOINIT;
826 #endif
827 }
828
829 __real_unlink = (int (*)(const char*))dlsym (dlflag, "unlink");
830 if (__real_unlink == NULL)
831 {
832 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT unlink\n");
833 rc = COL_ERROR_IOINIT;
834 }
835
836 __real_fseek = (int (*)(FILE*, long, int))dlsym (dlflag, "fseek");
837 if (__real_fseek == NULL)
838 {
839 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT fseek\n");
840 rc = COL_ERROR_IOINIT;
841 }
842
843 __real_rewind = (void (*)(FILE*))dlsym (dlflag, "rewind");
844 if (__real_rewind == NULL)
845 {
846 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT rewind\n");
847 rc = COL_ERROR_IOINIT;
848 }
849
850 __real_ftell = (long (*)(FILE*))dlsym (dlflag, "ftell");
851 if (__real_ftell == NULL)
852 {
853 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT ftell\n");
854 rc = COL_ERROR_IOINIT;
855 }
856
857 __real_fsync = (int (*)(int))dlsym (dlflag, "fsync");
858 if (__real_fsync == NULL)
859 {
860 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT fsync\n");
861 rc = COL_ERROR_IOINIT;
862 }
863
864 __real_readdir = (struct dirent * (*)(DIR*))dlsym (dlflag, "readdir");
865 if (__real_readdir == NULL)
866 {
867 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT readdir\n");
868 rc = COL_ERROR_IOINIT;
869 }
870
871 __real_flock = (int (*)(int, int))dlsym (dlflag, "flock");
872 if (__real_flock == NULL)
873 {
874 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT flock\n");
875 rc = COL_ERROR_IOINIT;
876 }
877
878 __real_lockf = (int (*)(int, int, off_t))dlsym (dlflag, "lockf");
879 if (__real_lockf == NULL)
880 {
881 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT lockf\n");
882 rc = COL_ERROR_IOINIT;
883 }
884
885 __real_fflush = (int (*)(FILE*))dlsym (dlflag, "fflush");
886 if (__real_fflush == NULL)
887 {
888 CALL_REAL (fprintf)(stderr, "iotrace_init COL_ERROR_IOINIT fflush\n");
889 rc = COL_ERROR_IOINIT;
890 }
891
892 init_io_intf_finished++;
893 return rc;
894 }
895
896 static void
write_io_packet(int fd,ssize_t ret,hrtime_t reqt,int iotype)897 write_io_packet (int fd, ssize_t ret, hrtime_t reqt, int iotype)
898 {
899 IOTrace_packet iopkt;
900 collector_memset (&iopkt, 0, sizeof ( IOTrace_packet));
901 iopkt.comm.tsize = sizeof (IOTrace_packet);
902 iopkt.comm.tstamp = gethrtime ();
903 iopkt.requested = reqt;
904 iopkt.iotype = iotype;
905 iopkt.fd = fd;
906 iopkt.nbyte = ret;
907 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl,
908 iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
909 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
910 }
911
912 /*------------------------------------------------------------- open */
913 int
open(const char * path,int oflag,...)914 open (const char *path, int oflag, ...)
915 {
916 int *guard;
917 int fd;
918 void *packet;
919 IOTrace_packet *iopkt;
920 mode_t mode;
921 va_list ap;
922 size_t sz;
923 unsigned pktSize;
924
925 va_start (ap, oflag);
926 mode = va_arg (ap, mode_t);
927 va_end (ap);
928
929 if (NULL_PTR (open))
930 init_io_intf ();
931
932 if (CHCK_REENTRANCE (guard) || path == NULL)
933 return CALL_REAL (open)(path, oflag, mode);
934 PUSH_REENTRANCE (guard);
935 hrtime_t reqt = gethrtime ();
936 fd = CALL_REAL (open)(path, oflag, mode);
937 if (RECHCK_REENTRANCE (guard))
938 {
939 POP_REENTRANCE (guard);
940 return fd;
941 }
942 hrtime_t grnt = gethrtime ();
943 sz = collector_strlen (path);
944 pktSize = sizeof (IOTrace_packet) + sz;
945 pktSize = collector_align_pktsize (pktSize);
946 Tprintf (DBG_LT1, "iotrace allocating %u from io_heap\n", pktSize);
947 packet = collector_interface->allocCSize (io_heap, pktSize, 1);
948 if (packet != NULL)
949 {
950 iopkt = (IOTrace_packet *) packet;
951 collector_memset (iopkt, 0, pktSize);
952 iopkt->comm.tsize = pktSize;
953 iopkt->comm.tstamp = grnt;
954 iopkt->requested = reqt;
955 if (fd != -1)
956 iopkt->iotype = OPEN_TRACE;
957 else
958 iopkt->iotype = OPEN_TRACE_ERROR;
959 iopkt->fd = fd;
960 iopkt->fstype = collector_fstype (path);
961 collector_strncpy (&(iopkt->fname), path, sz);
962 iopkt->comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt->comm.tstamp, FRINFO_FROM_STACK, &iopkt);
963 collector_interface->writeDataRecord (io_hndl, (Common_packet*) iopkt);
964 collector_interface->freeCSize (io_heap, packet, pktSize);
965 }
966 else
967 {
968 Tprintf (0, "iotrace: ERROR: open cannot allocate memory\n");
969 return -1;
970 }
971 POP_REENTRANCE (guard);
972 return fd;
973 }
974
975 /*------------------------------------------------------------- open64 */
976 static int
gprofng_open64(int (real_open64)(const char *,int,...),const char * path,int oflag,mode_t mode)977 gprofng_open64 (int(real_open64) (const char *, int, ...),
978 const char *path, int oflag, mode_t mode)
979 {
980 int *guard;
981 int fd;
982 void *packet;
983 IOTrace_packet *iopkt;
984 size_t sz;
985 unsigned pktSize;
986 if (CHCK_REENTRANCE (guard) || path == NULL)
987 return real_open64 (path, oflag, mode);
988 PUSH_REENTRANCE (guard);
989 hrtime_t reqt = gethrtime ();
990 fd = real_open64 (path, oflag, mode);
991 if (RECHCK_REENTRANCE (guard) || path == NULL)
992 {
993 POP_REENTRANCE (guard);
994 return fd;
995 }
996 hrtime_t grnt = gethrtime ();
997 sz = collector_strlen (path);
998 pktSize = sizeof (IOTrace_packet) + sz;
999 pktSize = collector_align_pktsize (pktSize);
1000 Tprintf (DBG_LT1, "iotrace allocating %u from io_heap\n", pktSize);
1001 packet = collector_interface->allocCSize (io_heap, pktSize, 1);
1002 if (packet != NULL)
1003 {
1004 iopkt = (IOTrace_packet *) packet;
1005 collector_memset (iopkt, 0, pktSize);
1006 iopkt->comm.tsize = pktSize;
1007 iopkt->comm.tstamp = grnt;
1008 iopkt->requested = reqt;
1009 if (fd != -1)
1010 iopkt->iotype = OPEN_TRACE;
1011 else
1012 iopkt->iotype = OPEN_TRACE_ERROR;
1013 iopkt->fd = fd;
1014 iopkt->fstype = collector_fstype (path);
1015 collector_strncpy (&(iopkt->fname), path, sz);
1016 iopkt->comm.frinfo = collector_interface->getFrameInfo (io_hndl,
1017 iopkt->comm.tstamp, FRINFO_FROM_STACK_ARG, &iopkt);
1018 collector_interface->writeDataRecord (io_hndl, (Common_packet*) iopkt);
1019 collector_interface->freeCSize (io_heap, packet, pktSize);
1020 }
1021 else
1022 {
1023 Tprintf (0, "iotrace: ERROR: open64 cannot allocate memory\n");
1024 return -1;
1025 }
1026 POP_REENTRANCE (guard);
1027 return fd;
1028 }
1029
1030 #define DCL_OPEN64(dcl_f) \
1031 int dcl_f (const char *path, int oflag, ...) \
1032 { \
1033 if (__real_open64 == NULL) \
1034 init_io_intf (); \
1035 mode_t mode; \
1036 va_list ap; \
1037 va_start (ap, oflag); \
1038 mode = va_arg (ap, mode_t); \
1039 va_end (ap); \
1040 return gprofng_open64 (__real_open64, path, oflag, mode); \
1041 }
1042
1043 DCL_FUNC_VER (DCL_OPEN64, open64_2_2, open64@GLIBC_2.2)
1044 #if !defined(__USE_LARGEFILE64)
DCL_OPEN64(open64)1045 DCL_OPEN64 (open64)
1046 #endif
1047
1048 #define F_ERROR_ARG 0
1049 #define F_INT_ARG 1
1050 #define F_LONG_ARG 2
1051 #define F_VOID_ARG 3
1052
1053 /*
1054 * The following macro is not defined in the
1055 * older versions of Linux.
1056 * #define F_DUPFD_CLOEXEC 1030
1057 *
1058 * Instead use the command that is defined below
1059 * until we start compiling mpmt on the newer
1060 * versions of Linux.
1061 */
1062 #define TMP_F_DUPFD_CLOEXEC 1030
1063
1064 /*------------------------------------------------------------- fcntl */
1065 int
1066 fcntl (int fildes, int cmd, ...)
1067 {
1068 int *guard;
1069 int fd = 0;
1070 IOTrace_packet iopkt;
1071 long long_arg = 0;
1072 int int_arg = 0;
1073 int which_arg = F_ERROR_ARG;
1074 va_list ap;
1075 switch (cmd)
1076 {
1077 case F_DUPFD:
1078 case TMP_F_DUPFD_CLOEXEC:
1079 case F_SETFD:
1080 case F_SETFL:
1081 case F_SETOWN:
1082 case F_SETSIG:
1083 case F_SETLEASE:
1084 case F_NOTIFY:
1085 case F_SETLK:
1086 case F_SETLKW:
1087 case F_GETLK:
1088 va_start (ap, cmd);
1089 long_arg = va_arg (ap, long);
1090 va_end (ap);
1091 which_arg = F_LONG_ARG;
1092 break;
1093 case F_GETFD:
1094 case F_GETFL:
1095 case F_GETOWN:
1096 case F_GETLEASE:
1097 case F_GETSIG:
1098 which_arg = F_VOID_ARG;
1099 break;
1100 }
1101 if (NULL_PTR (fcntl))
1102 init_io_intf ();
1103 if (CHCK_REENTRANCE (guard))
1104 {
1105 switch (which_arg)
1106 {
1107 case F_INT_ARG:
1108 return CALL_REAL (fcntl)(fildes, cmd, int_arg);
1109 case F_LONG_ARG:
1110 return CALL_REAL (fcntl)(fildes, cmd, long_arg);
1111 case F_VOID_ARG:
1112 return CALL_REAL (fcntl)(fildes, cmd);
1113 case F_ERROR_ARG:
1114 Tprintf (0, "iotrace: ERROR: Unsupported fcntl command\n");
1115 return -1;
1116 }
1117 return -1;
1118 }
1119 if (cmd != F_DUPFD && cmd != TMP_F_DUPFD_CLOEXEC)
1120 {
1121 switch (which_arg)
1122 {
1123 case F_INT_ARG:
1124 return CALL_REAL (fcntl)(fildes, cmd, int_arg);
1125 case F_LONG_ARG:
1126 return CALL_REAL (fcntl)(fildes, cmd, long_arg);
1127 case F_VOID_ARG:
1128 return CALL_REAL (fcntl)(fildes, cmd);
1129 case F_ERROR_ARG:
1130 Tprintf (0, "iotrace: ERROR: Unsupported fcntl command\n");
1131 return -1;
1132 }
1133 return -1;
1134 }
1135 PUSH_REENTRANCE (guard);
1136 hrtime_t reqt = gethrtime ();
1137 switch (cmd)
1138 {
1139 case F_DUPFD:
1140 case TMP_F_DUPFD_CLOEXEC:
1141 fd = CALL_REAL (fcntl)(fildes, cmd, long_arg);
1142 break;
1143 }
1144 if (RECHCK_REENTRANCE (guard))
1145 {
1146 POP_REENTRANCE (guard);
1147 return fd;
1148 }
1149 hrtime_t grnt = gethrtime ();
1150 collector_memset (&iopkt, 0, sizeof (IOTrace_packet));
1151 iopkt.comm.tsize = sizeof (IOTrace_packet);
1152 iopkt.comm.tstamp = grnt;
1153 iopkt.requested = reqt;
1154 if (fd != -1)
1155 iopkt.iotype = OPEN_TRACE;
1156 else
1157 iopkt.iotype = OPEN_TRACE_ERROR;
1158 iopkt.fd = fd;
1159 iopkt.ofd = fildes;
1160 iopkt.fstype = UNKNOWNFS_TYPE;
1161 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
1162 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
1163 POP_REENTRANCE (guard);
1164 return fd;
1165 }
1166
1167 /*------------------------------------------------------------- openat */
1168 int
openat(int fildes,const char * path,int oflag,...)1169 openat (int fildes, const char *path, int oflag, ...)
1170 {
1171 int *guard;
1172 int fd;
1173 void *packet;
1174 IOTrace_packet *iopkt;
1175 mode_t mode;
1176 va_list ap;
1177 size_t sz;
1178 unsigned pktSize;
1179
1180 va_start (ap, oflag);
1181 mode = va_arg (ap, mode_t);
1182 va_end (ap);
1183 if (NULL_PTR (openat))
1184 init_io_intf ();
1185 if (CHCK_REENTRANCE (guard) || path == NULL)
1186 return CALL_REAL (openat)(fildes, path, oflag, mode);
1187 PUSH_REENTRANCE (guard);
1188 hrtime_t reqt = gethrtime ();
1189 fd = CALL_REAL (openat)(fildes, path, oflag, mode);
1190 if (RECHCK_REENTRANCE (guard))
1191 {
1192 POP_REENTRANCE (guard);
1193 return fd;
1194 }
1195 hrtime_t grnt = gethrtime ();
1196 sz = collector_strlen (path);
1197 pktSize = sizeof (IOTrace_packet) + sz;
1198 pktSize = collector_align_pktsize (pktSize);
1199 Tprintf (DBG_LT1, "iotrace allocating %u from io_heap\n", pktSize);
1200 packet = collector_interface->allocCSize (io_heap, pktSize, 1);
1201 if (packet != NULL)
1202 {
1203 iopkt = (IOTrace_packet *) packet;
1204 collector_memset (iopkt, 0, pktSize);
1205 iopkt->comm.tsize = pktSize;
1206 iopkt->comm.tstamp = grnt;
1207 iopkt->requested = reqt;
1208 if (fd != -1)
1209 iopkt->iotype = OPEN_TRACE;
1210 else
1211 iopkt->iotype = OPEN_TRACE_ERROR;
1212 iopkt->fd = fd;
1213 iopkt->fstype = collector_fstype (path);
1214 collector_strncpy (&(iopkt->fname), path, sz);
1215 iopkt->comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt->comm.tstamp, FRINFO_FROM_STACK, &iopkt);
1216 collector_interface->writeDataRecord (io_hndl, (Common_packet*) iopkt);
1217 collector_interface->freeCSize (io_heap, packet, pktSize);
1218 }
1219 else
1220 {
1221 Tprintf (0, "iotrace: ERROR: openat cannot allocate memory\n");
1222 return -1;
1223 }
1224 POP_REENTRANCE (guard);
1225 return fd;
1226 }
1227
1228 /*------------------------------------------------------------- creat */
1229 int
creat(const char * path,mode_t mode)1230 creat (const char *path, mode_t mode)
1231 {
1232 int *guard;
1233 int fd;
1234 void *packet;
1235 IOTrace_packet *iopkt;
1236 size_t sz;
1237 unsigned pktSize;
1238 if (NULL_PTR (creat))
1239 init_io_intf ();
1240 if (CHCK_REENTRANCE (guard) || path == NULL)
1241 return CALL_REAL (creat)(path, mode);
1242 PUSH_REENTRANCE (guard);
1243 hrtime_t reqt = gethrtime ();
1244 fd = CALL_REAL (creat)(path, mode);
1245 if (RECHCK_REENTRANCE (guard))
1246 {
1247 POP_REENTRANCE (guard);
1248 return fd;
1249 }
1250 hrtime_t grnt = gethrtime ();
1251 sz = collector_strlen (path);
1252 pktSize = sizeof (IOTrace_packet) + sz;
1253 pktSize = collector_align_pktsize (pktSize);
1254 Tprintf (DBG_LT1, "iotrace allocating %u from io_heap\n", pktSize);
1255 packet = collector_interface->allocCSize (io_heap, pktSize, 1);
1256 if (packet != NULL)
1257 {
1258 iopkt = (IOTrace_packet *) packet;
1259 collector_memset (iopkt, 0, pktSize);
1260 iopkt->comm.tsize = pktSize;
1261 iopkt->comm.tstamp = grnt;
1262 iopkt->requested = reqt;
1263 if (fd != -1)
1264 iopkt->iotype = OPEN_TRACE;
1265 else
1266 iopkt->iotype = OPEN_TRACE_ERROR;
1267 iopkt->fd = fd;
1268 iopkt->fstype = collector_fstype (path);
1269 collector_strncpy (&(iopkt->fname), path, sz);
1270 iopkt->comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt->comm.tstamp, FRINFO_FROM_STACK, &iopkt);
1271 collector_interface->writeDataRecord (io_hndl, (Common_packet*) iopkt);
1272 collector_interface->freeCSize (io_heap, packet, pktSize);
1273 }
1274 else
1275 {
1276 Tprintf (0, "iotrace: ERROR: creat cannot allocate memory\n");
1277 return -1;
1278 }
1279 POP_REENTRANCE (guard);
1280 return fd;
1281 }
1282
1283 /*------------------------------------------------------------- creat64 */
1284 #if WSIZE(32) && !defined(__USE_LARGEFILE64)
1285 int
creat64(const char * path,mode_t mode)1286 creat64 (const char *path, mode_t mode)
1287 {
1288 int *guard;
1289 int fd;
1290 void *packet;
1291 IOTrace_packet *iopkt;
1292 size_t sz;
1293 unsigned pktSize;
1294
1295 if (NULL_PTR (creat64))
1296 init_io_intf ();
1297 if (CHCK_REENTRANCE (guard) || path == NULL)
1298 return CALL_REAL (creat64)(path, mode);
1299 PUSH_REENTRANCE (guard);
1300 hrtime_t reqt = gethrtime ();
1301 fd = CALL_REAL (creat64)(path, mode);
1302 if (RECHCK_REENTRANCE (guard))
1303 {
1304 POP_REENTRANCE (guard);
1305 return fd;
1306 }
1307 hrtime_t grnt = gethrtime ();
1308 sz = collector_strlen (path);
1309 pktSize = sizeof (IOTrace_packet) + sz;
1310 pktSize = collector_align_pktsize (pktSize);
1311 Tprintf (DBG_LT1, "iotrace allocating %u from io_heap\n", pktSize);
1312 packet = collector_interface->allocCSize (io_heap, pktSize, 1);
1313 if (packet != NULL)
1314 {
1315 iopkt = (IOTrace_packet *) packet;
1316 collector_memset (iopkt, 0, pktSize);
1317 iopkt->comm.tsize = pktSize;
1318 iopkt->comm.tstamp = grnt;
1319 iopkt->requested = reqt;
1320 if (fd != -1)
1321 iopkt->iotype = OPEN_TRACE;
1322 else
1323 iopkt->iotype = OPEN_TRACE_ERROR;
1324 iopkt->fd = fd;
1325 iopkt->fstype = collector_fstype (path);
1326 collector_strncpy (&(iopkt->fname), path, sz);
1327 iopkt->comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt->comm.tstamp, FRINFO_FROM_STACK, &iopkt);
1328 collector_interface->writeDataRecord (io_hndl, (Common_packet*) iopkt);
1329 collector_interface->freeCSize (io_heap, packet, pktSize);
1330 }
1331 else
1332 {
1333 Tprintf (0, "iotrace: ERROR: creat64 cannot allocate memory\n");
1334 return -1;
1335 }
1336 POP_REENTRANCE (guard);
1337 return fd;
1338 }
1339 #endif
1340
1341 /*------------------------------------------------------------- mkstemp */
1342 int
mkstemp(char * template)1343 mkstemp (char *template)
1344 {
1345 int *guard;
1346 int fd;
1347 void *packet;
1348 IOTrace_packet *iopkt;
1349 size_t sz;
1350 unsigned pktSize;
1351 if (NULL_PTR (mkstemp))
1352 init_io_intf ();
1353 if (CHCK_REENTRANCE (guard) || template == NULL)
1354 return CALL_REAL (mkstemp)(template);
1355 PUSH_REENTRANCE (guard);
1356 hrtime_t reqt = gethrtime ();
1357 fd = CALL_REAL (mkstemp)(template);
1358 if (RECHCK_REENTRANCE (guard))
1359 {
1360 POP_REENTRANCE (guard);
1361 return fd;
1362 }
1363 hrtime_t grnt = gethrtime ();
1364 sz = collector_strlen (template);
1365 pktSize = sizeof (IOTrace_packet) + sz;
1366 pktSize = collector_align_pktsize (pktSize);
1367 Tprintf (DBG_LT1, "iotrace allocating %u from io_heap\n", pktSize);
1368 packet = collector_interface->allocCSize (io_heap, pktSize, 1);
1369 if (packet != NULL)
1370 {
1371 iopkt = (IOTrace_packet *) packet;
1372 collector_memset (iopkt, 0, pktSize);
1373 iopkt->comm.tsize = pktSize;
1374 iopkt->comm.tstamp = grnt;
1375 iopkt->requested = reqt;
1376 if (fd != -1)
1377 iopkt->iotype = OPEN_TRACE;
1378 else
1379 iopkt->iotype = OPEN_TRACE_ERROR;
1380 iopkt->fd = fd;
1381 iopkt->fstype = collector_fstype (template);
1382 collector_strncpy (&(iopkt->fname), template, sz);
1383 iopkt->comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt->comm.tstamp, FRINFO_FROM_STACK, &iopkt);
1384 collector_interface->writeDataRecord (io_hndl, (Common_packet*) iopkt);
1385 collector_interface->freeCSize (io_heap, packet, pktSize);
1386 }
1387 else
1388 {
1389 Tprintf (0, "iotrace: ERROR: mkstemp cannot allocate memory\n");
1390 return -1;
1391 }
1392 POP_REENTRANCE (guard);
1393 return fd;
1394 }
1395
1396 /*------------------------------------------------------------- mkstemps */
1397 int
mkstemps(char * template,int slen)1398 mkstemps (char *template, int slen)
1399 {
1400 int *guard;
1401 int fd;
1402 void *packet;
1403 IOTrace_packet *iopkt;
1404 size_t sz;
1405 unsigned pktSize;
1406 if (NULL_PTR (mkstemps))
1407 init_io_intf ();
1408 if (CHCK_REENTRANCE (guard) || template == NULL)
1409 return CALL_REAL (mkstemps)(template, slen);
1410 PUSH_REENTRANCE (guard);
1411 hrtime_t reqt = gethrtime ();
1412 fd = CALL_REAL (mkstemps)(template, slen);
1413 if (RECHCK_REENTRANCE (guard))
1414 {
1415 POP_REENTRANCE (guard);
1416 return fd;
1417 }
1418 hrtime_t grnt = gethrtime ();
1419 sz = collector_strlen (template);
1420 pktSize = sizeof (IOTrace_packet) + sz;
1421 pktSize = collector_align_pktsize (pktSize);
1422 Tprintf (DBG_LT1, "iotrace allocating %u from io_heap\n", pktSize);
1423 packet = collector_interface->allocCSize (io_heap, pktSize, 1);
1424 if (packet != NULL)
1425 {
1426 iopkt = (IOTrace_packet *) packet;
1427 collector_memset (iopkt, 0, pktSize);
1428 iopkt->comm.tsize = pktSize;
1429 iopkt->comm.tstamp = grnt;
1430 iopkt->requested = reqt;
1431 if (fd != -1)
1432 iopkt->iotype = OPEN_TRACE;
1433 else
1434 iopkt->iotype = OPEN_TRACE_ERROR;
1435 iopkt->fd = fd;
1436 iopkt->fstype = collector_fstype (template);
1437 collector_strncpy (&(iopkt->fname), template, sz);
1438 iopkt->comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt->comm.tstamp, FRINFO_FROM_STACK, &iopkt);
1439 collector_interface->writeDataRecord (io_hndl, (Common_packet*) iopkt);
1440 collector_interface->freeCSize (io_heap, packet, pktSize);
1441 }
1442 else
1443 {
1444 Tprintf (0, "iotrace: ERROR: mkstemps cannot allocate memory\n");
1445 return -1;
1446 }
1447 POP_REENTRANCE (guard);
1448 return fd;
1449 }
1450
1451 /*------------------------------------------------------------- close */
1452 int
close(int fildes)1453 close (int fildes)
1454 {
1455 int *guard;
1456 int stat;
1457 IOTrace_packet iopkt;
1458 if (NULL_PTR (close))
1459 init_io_intf ();
1460 if (CHCK_REENTRANCE (guard))
1461 return CALL_REAL (close)(fildes);
1462 PUSH_REENTRANCE (guard);
1463 hrtime_t reqt = gethrtime ();
1464 stat = CALL_REAL (close)(fildes);
1465 if (RECHCK_REENTRANCE (guard))
1466 {
1467 POP_REENTRANCE (guard);
1468 return stat;
1469 }
1470 hrtime_t grnt = gethrtime ();
1471 collector_memset (&iopkt, 0, sizeof (IOTrace_packet));
1472 iopkt.comm.tsize = sizeof (IOTrace_packet);
1473 iopkt.comm.tstamp = grnt;
1474 iopkt.requested = reqt;
1475 if (stat == 0)
1476 iopkt.iotype = CLOSE_TRACE;
1477 else
1478 iopkt.iotype = CLOSE_TRACE_ERROR;
1479 iopkt.fd = fildes;
1480 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
1481 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
1482 POP_REENTRANCE (guard);
1483 return stat;
1484 }
1485
1486 /*------------------------------------------------------------- fopen */
1487 static FILE*
gprofng_fopen(FILE * (real_fopen)(),const char * filename,const char * mode)1488 gprofng_fopen (FILE*(real_fopen) (), const char *filename, const char *mode)
1489 {
1490 int *guard;
1491 FILE *fp = NULL;
1492 void *packet;
1493 IOTrace_packet *iopkt;
1494 size_t sz;
1495 unsigned pktSize;
1496 if (CHCK_REENTRANCE (guard) || filename == NULL)
1497 return real_fopen (filename, mode);
1498 PUSH_REENTRANCE (guard);
1499 hrtime_t reqt = gethrtime ();
1500
1501 fp = real_fopen (filename, mode);
1502 if (RECHCK_REENTRANCE (guard))
1503 {
1504 POP_REENTRANCE (guard);
1505 return fp;
1506 }
1507 hrtime_t grnt = gethrtime ();
1508 sz = collector_strlen (filename);
1509 pktSize = sizeof (IOTrace_packet) + sz;
1510 pktSize = collector_align_pktsize (pktSize);
1511 Tprintf (DBG_LT1, "iotrace allocating %u from io_heap\n", pktSize);
1512 packet = collector_interface->allocCSize (io_heap, pktSize, 1);
1513 if (packet != NULL)
1514 {
1515 iopkt = (IOTrace_packet *) packet;
1516 collector_memset (iopkt, 0, pktSize);
1517 iopkt->comm.tsize = pktSize;
1518 iopkt->comm.tstamp = grnt;
1519 iopkt->requested = reqt;
1520 if (fp != NULL)
1521 {
1522 iopkt->iotype = OPEN_TRACE;
1523 iopkt->fd = fileno (fp);
1524 }
1525 else
1526 {
1527 iopkt->iotype = OPEN_TRACE_ERROR;
1528 iopkt->fd = -1;
1529 }
1530 iopkt->fstype = collector_fstype (filename);
1531 collector_strncpy (&(iopkt->fname), filename, sz);
1532 iopkt->comm.frinfo = collector_interface->getFrameInfo (io_hndl,
1533 iopkt->comm.tstamp, FRINFO_FROM_STACK_ARG, &iopkt);
1534 collector_interface->writeDataRecord (io_hndl, (Common_packet*) iopkt);
1535 collector_interface->freeCSize (io_heap, packet, pktSize);
1536 }
1537 else
1538 {
1539 Tprintf (0, "iotrace: ERROR: fopen cannot allocate memory\n");
1540 return NULL;
1541 }
1542 POP_REENTRANCE (guard);
1543 return fp;
1544 }
1545
1546 #define DCL_FOPEN(dcl_f) \
1547 FILE *dcl_f (const char *filename, const char *mode) \
1548 { \
1549 if (__real_fopen == NULL) \
1550 init_io_intf (); \
1551 return gprofng_fopen (__real_fopen, filename, mode); \
1552 }
1553
1554 DCL_FUNC_VER (DCL_FOPEN, fopen_2_17, fopen@GLIBC_2.17)
1555 DCL_FUNC_VER (DCL_FOPEN, fopen_2_2_5, fopen@GLIBC_2.2.5)
1556 DCL_FUNC_VER (DCL_FOPEN, fopen_2_1, fopen@GLIBC_2.1)
1557 DCL_FUNC_VER (DCL_FOPEN, fopen_2_0, fopen@GLIBC_2.0)
DCL_FOPEN(fopen)1558 DCL_FOPEN (fopen)
1559
1560 /*------------------------------------------------------------- fclose */
1561 static int
1562 gprofng_fclose (int(real_fclose) (), FILE *stream)
1563 {
1564 int *guard;
1565 int stat;
1566 IOTrace_packet iopkt;
1567 if (CHCK_REENTRANCE (guard) || stream == NULL)
1568 return real_fclose (stream);
1569 PUSH_REENTRANCE (guard);
1570 hrtime_t reqt = gethrtime ();
1571 stat = real_fclose (stream);
1572 if (RECHCK_REENTRANCE (guard))
1573 {
1574 POP_REENTRANCE (guard);
1575 return stat;
1576 }
1577 hrtime_t grnt = gethrtime ();
1578 collector_memset (&iopkt, 0, sizeof (IOTrace_packet));
1579 iopkt.comm.tsize = sizeof (IOTrace_packet);
1580 iopkt.comm.tstamp = grnt;
1581 iopkt.requested = reqt;
1582 if (stat == 0)
1583 iopkt.iotype = CLOSE_TRACE;
1584 else
1585 iopkt.iotype = CLOSE_TRACE_ERROR;
1586 iopkt.fd = fileno (stream);
1587 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl,
1588 iopkt.comm.tstamp, FRINFO_FROM_STACK_ARG, &iopkt);
1589 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
1590 POP_REENTRANCE (guard);
1591 return stat;
1592 }
1593
1594 #define DCL_FCLOSE(dcl_f) \
1595 int dcl_f (FILE *stream) \
1596 { \
1597 if (__real_fclose == NULL) \
1598 init_io_intf (); \
1599 return gprofng_fclose (__real_fclose, stream); \
1600 }
1601
1602 DCL_FUNC_VER (DCL_FCLOSE, fclose_2_17, fclose@GLIBC_2.17)
1603 DCL_FUNC_VER (DCL_FCLOSE, fclose_2_2_5, fclose@GLIBC_2.2.5)
1604 DCL_FUNC_VER (DCL_FCLOSE, fclose_2_1, fclose@GLIBC_2.1)
1605 DCL_FUNC_VER (DCL_FCLOSE, fclose_2_0, fclose@GLIBC_2.0)
DCL_FCLOSE(fclose)1606 DCL_FCLOSE (fclose)
1607
1608 /*------------------------------------------------------------- fflush */
1609 int
1610 fflush (FILE *stream)
1611 {
1612 int *guard;
1613 int stat;
1614 IOTrace_packet iopkt;
1615 if (NULL_PTR (fflush))
1616 init_io_intf ();
1617 if (CHCK_REENTRANCE (guard))
1618 return CALL_REAL (fflush)(stream);
1619 PUSH_REENTRANCE (guard);
1620 hrtime_t reqt = gethrtime ();
1621 stat = CALL_REAL (fflush)(stream);
1622 if (RECHCK_REENTRANCE (guard))
1623 {
1624 POP_REENTRANCE (guard);
1625 return stat;
1626 }
1627 hrtime_t grnt = gethrtime ();
1628 collector_memset (&iopkt, 0, sizeof (IOTrace_packet));
1629 iopkt.comm.tsize = sizeof (IOTrace_packet);
1630 iopkt.comm.tstamp = grnt;
1631 iopkt.requested = reqt;
1632 if (stat == 0)
1633 iopkt.iotype = OTHERIO_TRACE;
1634 else
1635 iopkt.iotype = OTHERIO_TRACE_ERROR;
1636 if (stream != NULL)
1637 iopkt.fd = fileno (stream);
1638 else
1639 iopkt.fd = -1;
1640 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
1641 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
1642 POP_REENTRANCE (guard);
1643 return stat;
1644 }
1645
1646 /*------------------------------------------------------------- fdopen */
1647 static FILE*
gprofng_fdopen(FILE * (real_fdopen)(),int fildes,const char * mode)1648 gprofng_fdopen (FILE*(real_fdopen) (), int fildes, const char *mode)
1649 {
1650 int *guard;
1651 FILE *fp = NULL;
1652 IOTrace_packet iopkt;
1653 if (NULL_PTR (fdopen))
1654 init_io_intf ();
1655 if (CHCK_REENTRANCE (guard))
1656 return real_fdopen (fildes, mode);
1657 PUSH_REENTRANCE (guard);
1658 hrtime_t reqt = gethrtime ();
1659 fp = real_fdopen (fildes, mode);
1660 if (RECHCK_REENTRANCE (guard))
1661 {
1662 POP_REENTRANCE (guard);
1663 return fp;
1664 }
1665 hrtime_t grnt = gethrtime ();
1666 collector_memset (&iopkt, 0, sizeof (IOTrace_packet));
1667 iopkt.comm.tsize = sizeof (IOTrace_packet);
1668 iopkt.comm.tstamp = grnt;
1669 iopkt.requested = reqt;
1670 if (fp != NULL)
1671 iopkt.iotype = OPEN_TRACE;
1672 else
1673 iopkt.iotype = OPEN_TRACE_ERROR;
1674 iopkt.fd = fildes;
1675 iopkt.fstype = UNKNOWNFS_TYPE;
1676 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl,
1677 iopkt.comm.tstamp, FRINFO_FROM_STACK_ARG, &iopkt);
1678 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
1679 POP_REENTRANCE (guard);
1680 return fp;
1681 }
1682
1683 #define DCL_FDOPEN(dcl_f) \
1684 FILE *dcl_f (int fildes, const char *mode) \
1685 { \
1686 if (__real_fdopen == NULL) \
1687 init_io_intf (); \
1688 return gprofng_fdopen (__real_fdopen, fildes, mode); \
1689 }
1690
1691 DCL_FUNC_VER (DCL_FDOPEN, fdopen_2_17, fdopen@GLIBC_2.17)
1692 DCL_FUNC_VER (DCL_FDOPEN, fdopen_2_2_5, fdopen@GLIBC_2.2.5)
1693 DCL_FUNC_VER (DCL_FDOPEN, fdopen_2_1, fdopen@GLIBC_2.1)
1694 DCL_FUNC_VER (DCL_FDOPEN, fdopen_2_0, fdopen@GLIBC_2.0)
DCL_FDOPEN(fdopen)1695 DCL_FDOPEN (fdopen)
1696
1697 /*------------------------------------------------------------- dup */
1698 int
1699 dup (int fildes)
1700 {
1701 int *guard;
1702 int fd;
1703 IOTrace_packet iopkt;
1704 if (NULL_PTR (dup))
1705 init_io_intf ();
1706 if (CHCK_REENTRANCE (guard))
1707 return CALL_REAL (dup)(fildes);
1708 PUSH_REENTRANCE (guard);
1709 hrtime_t reqt = gethrtime ();
1710 fd = CALL_REAL (dup)(fildes);
1711 if (RECHCK_REENTRANCE (guard))
1712 {
1713 POP_REENTRANCE (guard);
1714 return fd;
1715 }
1716 hrtime_t grnt = gethrtime ();
1717 collector_memset (&iopkt, 0, sizeof (IOTrace_packet));
1718 iopkt.comm.tsize = sizeof (IOTrace_packet);
1719 iopkt.comm.tstamp = grnt;
1720 iopkt.requested = reqt;
1721 if (fd != -1)
1722 iopkt.iotype = OPEN_TRACE;
1723 else
1724 iopkt.iotype = OPEN_TRACE_ERROR;
1725
1726 iopkt.fd = fd;
1727 iopkt.ofd = fildes;
1728 iopkt.fstype = UNKNOWNFS_TYPE;
1729 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
1730 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
1731 POP_REENTRANCE (guard);
1732 return fd;
1733 }
1734
1735 /*------------------------------------------------------------- dup2 */
1736 int
dup2(int fildes,int fildes2)1737 dup2 (int fildes, int fildes2)
1738 {
1739 int *guard;
1740 int fd;
1741 IOTrace_packet iopkt;
1742 if (NULL_PTR (dup2))
1743 init_io_intf ();
1744 if (CHCK_REENTRANCE (guard))
1745 return CALL_REAL (dup2)(fildes, fildes2);
1746 PUSH_REENTRANCE (guard);
1747 hrtime_t reqt = gethrtime ();
1748 fd = CALL_REAL (dup2)(fildes, fildes2);
1749 if (RECHCK_REENTRANCE (guard))
1750 {
1751 POP_REENTRANCE (guard);
1752 return fd;
1753 }
1754 hrtime_t grnt = gethrtime ();
1755 collector_memset (&iopkt, 0, sizeof (IOTrace_packet));
1756 iopkt.comm.tsize = sizeof (IOTrace_packet);
1757 iopkt.comm.tstamp = grnt;
1758 iopkt.requested = reqt;
1759 if (fd != -1)
1760 iopkt.iotype = OPEN_TRACE;
1761 else
1762 iopkt.iotype = OPEN_TRACE_ERROR;
1763 iopkt.fd = fd;
1764 iopkt.ofd = fildes;
1765 iopkt.fstype = UNKNOWNFS_TYPE;
1766 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
1767 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
1768 POP_REENTRANCE (guard);
1769 return fd;
1770 }
1771
1772 /*------------------------------------------------------------- pipe */
1773 int
pipe(int fildes[2])1774 pipe (int fildes[2])
1775 {
1776 int *guard;
1777 int ret;
1778 IOTrace_packet iopkt;
1779 if (NULL_PTR (pipe))
1780 init_io_intf ();
1781 if (CHCK_REENTRANCE (guard))
1782 return CALL_REAL (pipe)(fildes);
1783 PUSH_REENTRANCE (guard);
1784 hrtime_t reqt = gethrtime ();
1785 ret = CALL_REAL (pipe)(fildes);
1786 if (RECHCK_REENTRANCE (guard))
1787 {
1788 POP_REENTRANCE (guard);
1789 return ret;
1790 }
1791 hrtime_t grnt = gethrtime ();
1792 collector_memset (&iopkt, 0, sizeof (IOTrace_packet));
1793 iopkt.comm.tsize = sizeof (IOTrace_packet);
1794 iopkt.comm.tstamp = grnt;
1795 iopkt.requested = reqt;
1796 if (ret != -1)
1797 iopkt.iotype = OPEN_TRACE;
1798 else
1799 iopkt.iotype = OPEN_TRACE_ERROR;
1800 iopkt.fd = fildes[0];
1801 iopkt.fstype = UNKNOWNFS_TYPE;
1802 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
1803 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
1804 collector_memset (&iopkt, 0, sizeof (IOTrace_packet));
1805 iopkt.comm.tsize = sizeof (IOTrace_packet);
1806 iopkt.comm.tstamp = grnt;
1807 iopkt.requested = reqt;
1808 if (ret != -1)
1809 iopkt.iotype = OPEN_TRACE;
1810 else
1811 iopkt.iotype = OPEN_TRACE_ERROR;
1812 iopkt.fd = fildes[1];
1813 iopkt.fstype = UNKNOWNFS_TYPE;
1814 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
1815 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
1816 POP_REENTRANCE (guard);
1817 return ret;
1818 }
1819
1820 /*------------------------------------------------------------- socket */
1821 int
socket(int domain,int type,int protocol)1822 socket (int domain, int type, int protocol)
1823 {
1824 int *guard;
1825 int fd;
1826 IOTrace_packet iopkt;
1827 if (NULL_PTR (socket))
1828 init_io_intf ();
1829 if (CHCK_REENTRANCE (guard))
1830 return CALL_REAL (socket)(domain, type, protocol);
1831 PUSH_REENTRANCE (guard);
1832 hrtime_t reqt = gethrtime ();
1833 fd = CALL_REAL (socket)(domain, type, protocol);
1834 if (RECHCK_REENTRANCE (guard))
1835 {
1836 POP_REENTRANCE (guard);
1837 return fd;
1838 }
1839 hrtime_t grnt = gethrtime ();
1840 collector_memset (&iopkt, 0, sizeof (IOTrace_packet));
1841 iopkt.comm.tsize = sizeof (IOTrace_packet);
1842 iopkt.comm.tstamp = grnt;
1843 iopkt.requested = reqt;
1844 if (fd != -1)
1845 iopkt.iotype = OPEN_TRACE;
1846 else
1847 iopkt.iotype = OPEN_TRACE_ERROR;
1848 iopkt.fd = fd;
1849 iopkt.fstype = UNKNOWNFS_TYPE;
1850 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
1851 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
1852 POP_REENTRANCE (guard);
1853 return fd;
1854 }
1855
1856 /*------------------------------------------------------------- read */
1857 ssize_t
read(int fildes,void * buf,size_t nbyte)1858 read (int fildes, void *buf, size_t nbyte)
1859 {
1860 int *guard;
1861 ssize_t ret;
1862 IOTrace_packet iopkt;
1863 if (NULL_PTR (read))
1864 init_io_intf ();
1865 if (CHCK_REENTRANCE (guard))
1866 return CALL_REAL (read)(fildes, buf, nbyte);
1867 PUSH_REENTRANCE (guard);
1868 hrtime_t reqt = gethrtime ();
1869 ret = CALL_REAL (read)(fildes, buf, nbyte);
1870 if (RECHCK_REENTRANCE (guard))
1871 {
1872 POP_REENTRANCE (guard);
1873 return ret;
1874 }
1875 hrtime_t grnt = gethrtime ();
1876 collector_memset (&iopkt, 0, sizeof ( IOTrace_packet));
1877 iopkt.comm.tsize = sizeof ( IOTrace_packet);
1878 iopkt.comm.tstamp = grnt;
1879 iopkt.requested = reqt;
1880 if (ret >= 0)
1881 iopkt.iotype = READ_TRACE;
1882 else
1883 iopkt.iotype = READ_TRACE_ERROR;
1884 iopkt.fd = fildes;
1885 iopkt.nbyte = ret;
1886 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
1887 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
1888 POP_REENTRANCE (guard);
1889 return ret;
1890 }
1891
1892 /*------------------------------------------------------------- write */
1893 ssize_t
write(int fildes,const void * buf,size_t nbyte)1894 write (int fildes, const void *buf, size_t nbyte)
1895 {
1896 int *guard;
1897 ssize_t ret;
1898 IOTrace_packet iopkt;
1899 if (NULL_PTR (write))
1900 init_io_intf ();
1901 if (CHCK_REENTRANCE (guard))
1902 return CALL_REAL (write)(fildes, buf, nbyte);
1903 PUSH_REENTRANCE (guard);
1904 hrtime_t reqt = gethrtime ();
1905 ret = CALL_REAL (write)(fildes, buf, nbyte);
1906 if (RECHCK_REENTRANCE (guard))
1907 {
1908 POP_REENTRANCE (guard);
1909 return ret;
1910 }
1911 hrtime_t grnt = gethrtime ();
1912 collector_memset (&iopkt, 0, sizeof ( IOTrace_packet));
1913 iopkt.comm.tsize = sizeof ( IOTrace_packet);
1914 iopkt.comm.tstamp = grnt;
1915 iopkt.requested = reqt;
1916 if (ret >= 0)
1917 iopkt.iotype = WRITE_TRACE;
1918 else
1919 iopkt.iotype = WRITE_TRACE_ERROR;
1920 iopkt.fd = fildes;
1921 iopkt.nbyte = ret;
1922 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
1923 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
1924 POP_REENTRANCE (guard);
1925 return ret;
1926 }
1927
1928 /*------------------------------------------------------------- readv */
1929 ssize_t
readv(int fildes,const struct iovec * iov,int iovcnt)1930 readv (int fildes, const struct iovec *iov, int iovcnt)
1931 {
1932 int *guard;
1933 ssize_t ret;
1934 IOTrace_packet iopkt;
1935 if (NULL_PTR (readv))
1936 init_io_intf ();
1937 if (CHCK_REENTRANCE (guard))
1938 return CALL_REAL (readv)(fildes, iov, iovcnt);
1939 PUSH_REENTRANCE (guard);
1940 hrtime_t reqt = gethrtime ();
1941 ret = CALL_REAL (readv)(fildes, iov, iovcnt);
1942 if (RECHCK_REENTRANCE (guard))
1943 {
1944 POP_REENTRANCE (guard);
1945 return ret;
1946 }
1947 hrtime_t grnt = gethrtime ();
1948 collector_memset (&iopkt, 0, sizeof ( IOTrace_packet));
1949 iopkt.comm.tsize = sizeof ( IOTrace_packet);
1950 iopkt.comm.tstamp = grnt;
1951 iopkt.requested = reqt;
1952 if (ret >= 0)
1953 iopkt.iotype = READ_TRACE;
1954 else
1955 iopkt.iotype = READ_TRACE_ERROR;
1956 iopkt.fd = fildes;
1957 iopkt.nbyte = ret;
1958 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
1959 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
1960 POP_REENTRANCE (guard);
1961 return ret;
1962 }
1963
1964 /*------------------------------------------------------------- writev */
1965 ssize_t
writev(int fildes,const struct iovec * iov,int iovcnt)1966 writev (int fildes, const struct iovec *iov, int iovcnt)
1967 {
1968 int *guard;
1969 ssize_t ret;
1970 IOTrace_packet iopkt;
1971 if (NULL_PTR (writev))
1972 init_io_intf ();
1973 if (CHCK_REENTRANCE (guard))
1974 return CALL_REAL (writev)(fildes, iov, iovcnt);
1975 PUSH_REENTRANCE (guard);
1976 hrtime_t reqt = gethrtime ();
1977 ret = CALL_REAL (writev)(fildes, iov, iovcnt);
1978 if (RECHCK_REENTRANCE (guard))
1979 {
1980 POP_REENTRANCE (guard);
1981 return ret;
1982 }
1983 hrtime_t grnt = gethrtime ();
1984 collector_memset (&iopkt, 0, sizeof ( IOTrace_packet));
1985 iopkt.comm.tsize = sizeof ( IOTrace_packet);
1986 iopkt.comm.tstamp = grnt;
1987 iopkt.requested = reqt;
1988 if (ret >= 0)
1989 iopkt.iotype = WRITE_TRACE;
1990 else
1991 iopkt.iotype = WRITE_TRACE_ERROR;
1992 iopkt.fd = fildes;
1993 iopkt.nbyte = ret;
1994 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
1995 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
1996 POP_REENTRANCE (guard);
1997 return ret;
1998 }
1999
2000 /*------------------------------------------------------------- fread */
2001 size_t
fread(void * ptr,size_t size,size_t nitems,FILE * stream)2002 fread (void *ptr, size_t size, size_t nitems, FILE *stream)
2003 {
2004 int *guard;
2005 size_t ret;
2006 IOTrace_packet iopkt;
2007 if (NULL_PTR (fread))
2008 init_io_intf ();
2009 if (CHCK_REENTRANCE (guard) || stream == NULL)
2010 return CALL_REAL (fread)(ptr, size, nitems, stream);
2011 PUSH_REENTRANCE (guard);
2012 hrtime_t reqt = gethrtime ();
2013 ret = CALL_REAL (fread)(ptr, size, nitems, stream);
2014 if (RECHCK_REENTRANCE (guard))
2015 {
2016 POP_REENTRANCE (guard);
2017 return ret;
2018 }
2019 hrtime_t grnt = gethrtime ();
2020 collector_memset (&iopkt, 0, sizeof ( IOTrace_packet));
2021 iopkt.comm.tsize = sizeof ( IOTrace_packet);
2022 iopkt.comm.tstamp = grnt;
2023 iopkt.requested = reqt;
2024 if (ferror (stream) == 0)
2025 {
2026 iopkt.iotype = READ_TRACE;
2027 iopkt.nbyte = ret * size;
2028 }
2029 else
2030 {
2031 iopkt.iotype = READ_TRACE_ERROR;
2032 iopkt.nbyte = 0;
2033 }
2034 iopkt.fd = fileno (stream);
2035 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
2036 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
2037 POP_REENTRANCE (guard);
2038 return ret;
2039 }
2040
2041 /*------------------------------------------------------------- fwrite */
2042 size_t
fwrite(const void * ptr,size_t size,size_t nitems,FILE * stream)2043 fwrite (const void *ptr, size_t size, size_t nitems, FILE *stream)
2044 {
2045 int *guard;
2046 size_t ret;
2047 IOTrace_packet iopkt;
2048 if (NULL_PTR (fwrite))
2049 init_io_intf ();
2050 if (CHCK_REENTRANCE (guard) || stream == NULL)
2051 return CALL_REAL (fwrite)(ptr, size, nitems, stream);
2052 PUSH_REENTRANCE (guard);
2053 hrtime_t reqt = gethrtime ();
2054 ret = CALL_REAL (fwrite)(ptr, size, nitems, stream);
2055 if (RECHCK_REENTRANCE (guard))
2056 {
2057 POP_REENTRANCE (guard);
2058 return ret;
2059 }
2060 hrtime_t grnt = gethrtime ();
2061 collector_memset (&iopkt, 0, sizeof ( IOTrace_packet));
2062 iopkt.comm.tsize = sizeof ( IOTrace_packet);
2063 iopkt.comm.tstamp = grnt;
2064 iopkt.requested = reqt;
2065 if (ferror (stream) == 0)
2066 {
2067 iopkt.iotype = WRITE_TRACE;
2068 iopkt.nbyte = ret * size;
2069 }
2070 else
2071 {
2072 iopkt.iotype = WRITE_TRACE_ERROR;
2073 iopkt.nbyte = 0;
2074 }
2075 iopkt.fd = fileno (stream);
2076 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
2077 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
2078 POP_REENTRANCE (guard);
2079 return ret;
2080 }
2081
2082 /*------------------------------------------------------------- pread */
2083 static ssize_t
gprofng_pread(ssize_t (real_pread)(int,void *,size_t,off_t),int fildes,void * buf,size_t nbyte,off_t offset)2084 gprofng_pread (ssize_t(real_pread) (int, void *, size_t, off_t),
2085 int fildes, void *buf, size_t nbyte, off_t offset)
2086 {
2087 int *guard;
2088 ssize_t ret;
2089 IOTrace_packet iopkt;
2090 if (CHCK_REENTRANCE (guard))
2091 return real_pread (fildes, buf, nbyte, offset);
2092 PUSH_REENTRANCE (guard);
2093 hrtime_t reqt = gethrtime ();
2094 ret = real_pread (fildes, buf, nbyte, offset);
2095 if (RECHCK_REENTRANCE (guard))
2096 {
2097 POP_REENTRANCE (guard);
2098 return ret;
2099 }
2100 hrtime_t grnt = gethrtime ();
2101 collector_memset (&iopkt, 0, sizeof ( IOTrace_packet));
2102 iopkt.comm.tsize = sizeof ( IOTrace_packet);
2103 iopkt.comm.tstamp = grnt;
2104 iopkt.requested = reqt;
2105 if (ret >= 0)
2106 iopkt.iotype = READ_TRACE;
2107 else
2108 iopkt.iotype = READ_TRACE_ERROR;
2109 iopkt.fd = fildes;
2110 iopkt.nbyte = ret;
2111 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl,
2112 iopkt.comm.tstamp, FRINFO_FROM_STACK_ARG, &iopkt);
2113 collector_interface->writeDataRecord (io_hndl, (Common_packet*) &iopkt);
2114 POP_REENTRANCE (guard);
2115 return ret;
2116 }
2117
2118 #define DCL_PREAD(dcl_f) \
2119 ssize_t dcl_f (int fildes, void *buf, size_t nbyte, off_t offset) \
2120 { \
2121 if (__real_pread == NULL) \
2122 init_io_intf (); \
2123 return gprofng_pread (__real_pread, fildes, buf, nbyte, offset); \
2124 }
2125
2126 DCL_FUNC_VER (DCL_PREAD, pread_2_2, pread@GLIBC_2.2)
DCL_PREAD(pread)2127 DCL_PREAD (pread)
2128
2129 /*------------------------------------------------------------- pwrite */
2130
2131 #if !defined(__MUSL_LIBC)
2132 // map interposed symbol versions
2133
2134 SYMVER_ATTRIBUTE (__collector_pwrite_2_2, pwrite@GLIBC_2.2)
2135 int
2136 __collector_pwrite_2_2 (int fildes, const void *buf, size_t nbyte, off_t offset)
2137 {
2138 int *guard;
2139 if (NULL_PTR (pwrite_2_2))
2140 init_io_intf ();
2141 if (CHCK_REENTRANCE (guard))
2142 return CALL_REAL (pwrite_2_2)(fildes, buf, nbyte, offset);
2143 PUSH_REENTRANCE (guard);
2144 hrtime_t reqt = gethrtime ();
2145 ssize_t ret = CALL_REAL (pwrite_2_2)(fildes, buf, nbyte, offset);
2146 if (RECHCK_REENTRANCE (guard))
2147 {
2148 POP_REENTRANCE (guard);
2149 return ret;
2150 }
2151 write_io_packet (fildes, ret, reqt, ret >= 0 ? WRITE_TRACE : WRITE_TRACE_ERROR);
2152 POP_REENTRANCE (guard);
2153 return ret;
2154 }
2155
2156 #endif
2157 ssize_t
pwrite(int fildes,const void * buf,size_t nbyte,off_t offset)2158 pwrite (int fildes, const void *buf, size_t nbyte, off_t offset)
2159 {
2160 int *guard;
2161 if (NULL_PTR (pwrite))
2162 init_io_intf ();
2163 if (CHCK_REENTRANCE (guard))
2164 return CALL_REAL (pwrite)(fildes, buf, nbyte, offset);
2165 PUSH_REENTRANCE (guard);
2166 hrtime_t reqt = gethrtime ();
2167 ssize_t ret = CALL_REAL (pwrite)(fildes, buf, nbyte, offset);
2168 if (RECHCK_REENTRANCE (guard))
2169 {
2170 POP_REENTRANCE (guard);
2171 return ret;
2172 }
2173 write_io_packet (fildes, ret, reqt, ret >= 0 ? WRITE_TRACE : WRITE_TRACE_ERROR);
2174 POP_REENTRANCE (guard);
2175 return ret;
2176 }
2177
2178 /*------------------------------------------------------------- pwrite64 */
2179 #if WSIZE(32) && !defined(__USE_FILE_OFFSET64)
2180 #if !defined(__MUSL_LIBC)
2181 // map interposed symbol versions
2182
2183 SYMVER_ATTRIBUTE (__collector_pwrite64_2_2, pwrite64@GLIBC_2.2)
2184 ssize_t
__collector_pwrite64_2_2(int fildes,const void * buf,size_t nbyte,off64_t offset)2185 __collector_pwrite64_2_2 (int fildes, const void *buf, size_t nbyte, off64_t offset)
2186 {
2187 int *guard;
2188 if (NULL_PTR (pwrite64_2_2))
2189 init_io_intf ();
2190 if (CHCK_REENTRANCE (guard))
2191 return CALL_REAL (pwrite64_2_2)(fildes, buf, nbyte, offset);
2192 PUSH_REENTRANCE (guard);
2193 hrtime_t reqt = gethrtime ();
2194 ssize_t ret = CALL_REAL (pwrite64_2_2)(fildes, buf, nbyte, offset);
2195 if (RECHCK_REENTRANCE (guard))
2196 {
2197 POP_REENTRANCE (guard);
2198 return ret;
2199 }
2200 write_io_packet (fildes, ret, reqt, ret >= 0 ? WRITE_TRACE : WRITE_TRACE_ERROR);
2201 POP_REENTRANCE (guard);
2202 return ret;
2203 }
2204 #endif
2205
2206 ssize_t
pwrite64(int fildes,const void * buf,size_t nbyte,off64_t offset)2207 pwrite64 (int fildes, const void *buf, size_t nbyte, off64_t offset)
2208 {
2209 int *guard;
2210 if (NULL_PTR (pwrite64))
2211 init_io_intf ();
2212 if (CHCK_REENTRANCE (guard))
2213 return CALL_REAL (pwrite64)(fildes, buf, nbyte, offset);
2214 PUSH_REENTRANCE (guard);
2215 hrtime_t reqt = gethrtime ();
2216 ssize_t ret = CALL_REAL (pwrite64)(fildes, buf, nbyte, offset);
2217 if (RECHCK_REENTRANCE (guard))
2218 {
2219 POP_REENTRANCE (guard);
2220 return ret;
2221 }
2222 write_io_packet (fildes, ret, reqt, ret >= 0 ? WRITE_TRACE : WRITE_TRACE_ERROR);
2223 POP_REENTRANCE (guard);
2224 return ret;
2225 }
2226 #endif
2227
2228 /*------------------------------------------------------------- fgets */
2229 char*
fgets(char * s,int n,FILE * stream)2230 fgets (char *s, int n, FILE *stream)
2231 {
2232 int *guard;
2233 char *ptr;
2234 IOTrace_packet iopkt;
2235 if (NULL_PTR (fgets))
2236 init_io_intf ();
2237 if (CHCK_REENTRANCE (guard) || stream == NULL)
2238 return CALL_REAL (fgets)(s, n, stream);
2239 PUSH_REENTRANCE (guard);
2240 hrtime_t reqt = gethrtime ();
2241 ptr = CALL_REAL (fgets)(s, n, stream);
2242 if (RECHCK_REENTRANCE (guard))
2243 {
2244 POP_REENTRANCE (guard);
2245 return ptr;
2246 }
2247 int error = errno;
2248 hrtime_t grnt = gethrtime ();
2249 collector_memset (&iopkt, 0, sizeof ( IOTrace_packet));
2250 iopkt.comm.tsize = sizeof ( IOTrace_packet);
2251 iopkt.comm.tstamp = grnt;
2252 iopkt.requested = reqt;
2253 if (ptr != NULL)
2254 {
2255 iopkt.iotype = READ_TRACE;
2256 iopkt.nbyte = collector_strlen (ptr);
2257 }
2258 else if (ptr == NULL && error != EAGAIN && error != EBADF && error != EINTR &&
2259 error != EIO && error != EOVERFLOW && error != ENOMEM && error != ENXIO)
2260 {
2261 iopkt.iotype = READ_TRACE;
2262 iopkt.nbyte = 0;
2263 }
2264 else
2265 iopkt.iotype = READ_TRACE_ERROR;
2266 iopkt.fd = fileno (stream);
2267 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
2268 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
2269 POP_REENTRANCE (guard);
2270 return ptr;
2271 }
2272
2273 /*------------------------------------------------------------- fputs */
2274 int
fputs(const char * s,FILE * stream)2275 fputs (const char *s, FILE *stream)
2276 {
2277 int *guard;
2278 int ret;
2279 IOTrace_packet iopkt;
2280 if (NULL_PTR (fputs))
2281 init_io_intf ();
2282 if (CHCK_REENTRANCE (guard) || stream == NULL)
2283 return CALL_REAL (fputs)(s, stream);
2284 PUSH_REENTRANCE (guard);
2285 hrtime_t reqt = gethrtime ();
2286 ret = CALL_REAL (fputs)(s, stream);
2287 if (RECHCK_REENTRANCE (guard))
2288 {
2289 POP_REENTRANCE (guard);
2290 return ret;
2291 }
2292 hrtime_t grnt = gethrtime ();
2293 collector_memset (&iopkt, 0, sizeof ( IOTrace_packet));
2294 iopkt.comm.tsize = sizeof ( IOTrace_packet);
2295 iopkt.comm.tstamp = grnt;
2296 iopkt.requested = reqt;
2297 if (ret != EOF)
2298 {
2299 iopkt.iotype = WRITE_TRACE;
2300 iopkt.nbyte = ret;
2301 }
2302 else
2303 {
2304 iopkt.iotype = WRITE_TRACE_ERROR;
2305 iopkt.nbyte = 0;
2306 }
2307 iopkt.fd = fileno (stream);
2308 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
2309 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
2310 POP_REENTRANCE (guard);
2311 return ret;
2312 }
2313
2314 /*------------------------------------------------------------- fputc */
2315 int
fputc(int c,FILE * stream)2316 fputc (int c, FILE *stream)
2317 {
2318 int *guard;
2319 int ret;
2320 IOTrace_packet iopkt;
2321 if (NULL_PTR (fputc))
2322 init_io_intf ();
2323 if (CHCK_REENTRANCE (guard) || stream == NULL)
2324 return CALL_REAL (fputc)(c, stream);
2325 PUSH_REENTRANCE (guard);
2326 hrtime_t reqt = gethrtime ();
2327 ret = CALL_REAL (fputc)(c, stream);
2328 if (RECHCK_REENTRANCE (guard))
2329 {
2330 POP_REENTRANCE (guard);
2331 return ret;
2332 }
2333 hrtime_t grnt = gethrtime ();
2334 collector_memset (&iopkt, 0, sizeof ( IOTrace_packet));
2335 iopkt.comm.tsize = sizeof ( IOTrace_packet);
2336 iopkt.comm.tstamp = grnt;
2337 iopkt.requested = reqt;
2338 if (ret != EOF)
2339 {
2340 iopkt.iotype = WRITE_TRACE;
2341 iopkt.nbyte = ret;
2342 }
2343 else
2344 {
2345 iopkt.iotype = WRITE_TRACE_ERROR;
2346 iopkt.nbyte = 0;
2347 }
2348 iopkt.fd = fileno (stream);
2349 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
2350 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
2351 POP_REENTRANCE (guard);
2352 return ret;
2353 }
2354
2355 /*------------------------------------------------------------- fprintf */
2356 int
fprintf(FILE * stream,const char * format,...)2357 fprintf (FILE *stream, const char *format, ...)
2358 {
2359 int *guard;
2360 int ret;
2361 IOTrace_packet iopkt;
2362 va_list ap;
2363 va_start (ap, format);
2364 if (NULL_PTR (fprintf))
2365 init_io_intf ();
2366 if (NULL_PTR (vfprintf))
2367 init_io_intf ();
2368 if (CHCK_REENTRANCE (guard) || stream == NULL)
2369 {
2370 ret = CALL_REAL (vfprintf)(stream, format, ap);
2371 va_end (ap);
2372 return ret;
2373 }
2374 PUSH_REENTRANCE (guard);
2375 hrtime_t reqt = gethrtime ();
2376 ret = CALL_REAL (vfprintf)(stream, format, ap);
2377 va_end (ap);
2378 if (RECHCK_REENTRANCE (guard))
2379 {
2380 POP_REENTRANCE (guard);
2381 return ret;
2382 }
2383 hrtime_t grnt = gethrtime ();
2384 collector_memset (&iopkt, 0, sizeof ( IOTrace_packet));
2385 iopkt.comm.tsize = sizeof ( IOTrace_packet);
2386 iopkt.comm.tstamp = grnt;
2387 iopkt.requested = reqt;
2388 if (ret >= 0)
2389 iopkt.iotype = WRITE_TRACE;
2390 else
2391 iopkt.iotype = WRITE_TRACE_ERROR;
2392 iopkt.fd = fileno (stream);
2393 iopkt.nbyte = ret;
2394 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
2395 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
2396 POP_REENTRANCE (guard);
2397 return ret;
2398 }
2399
2400 /*------------------------------------------------------------- vfprintf */
2401 int
vfprintf(FILE * stream,const char * format,va_list ap)2402 vfprintf (FILE *stream, const char *format, va_list ap)
2403 {
2404 int *guard;
2405 int ret;
2406 IOTrace_packet iopkt;
2407 if (NULL_PTR (vfprintf))
2408 init_io_intf ();
2409 if (CHCK_REENTRANCE (guard) || stream == NULL)
2410 return CALL_REAL (vfprintf)(stream, format, ap);
2411 PUSH_REENTRANCE (guard);
2412 hrtime_t reqt = gethrtime ();
2413 ret = CALL_REAL (vfprintf)(stream, format, ap);
2414 if (RECHCK_REENTRANCE (guard))
2415 {
2416 POP_REENTRANCE (guard);
2417 return ret;
2418 }
2419 hrtime_t grnt = gethrtime ();
2420 collector_memset (&iopkt, 0, sizeof ( IOTrace_packet));
2421 iopkt.comm.tsize = sizeof ( IOTrace_packet);
2422 iopkt.comm.tstamp = grnt;
2423 iopkt.requested = reqt;
2424 if (ret >= 0)
2425 iopkt.iotype = WRITE_TRACE;
2426 else
2427 iopkt.iotype = WRITE_TRACE_ERROR;
2428 iopkt.fd = fileno (stream);
2429 iopkt.nbyte = ret;
2430 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
2431 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
2432 POP_REENTRANCE (guard);
2433 return ret;
2434 }
2435
2436 /*------------------------------------------------------------- lseek */
2437 off_t
lseek(int fildes,off_t offset,int whence)2438 lseek (int fildes, off_t offset, int whence)
2439 {
2440 int *guard;
2441 off_t ret;
2442 IOTrace_packet iopkt;
2443 if (NULL_PTR (lseek))
2444 init_io_intf ();
2445 if (CHCK_REENTRANCE (guard))
2446 return CALL_REAL (lseek)(fildes, offset, whence);
2447 PUSH_REENTRANCE (guard);
2448 hrtime_t reqt = gethrtime ();
2449 ret = CALL_REAL (lseek)(fildes, offset, whence);
2450 if (RECHCK_REENTRANCE (guard))
2451 {
2452 POP_REENTRANCE (guard);
2453 return ret;
2454 }
2455 hrtime_t grnt = gethrtime ();
2456 collector_memset (&iopkt, 0, sizeof (IOTrace_packet));
2457 iopkt.comm.tsize = sizeof (IOTrace_packet);
2458 iopkt.comm.tstamp = grnt;
2459 iopkt.requested = reqt;
2460 if (ret != -1)
2461 iopkt.iotype = OTHERIO_TRACE;
2462 else
2463 iopkt.iotype = OTHERIO_TRACE_ERROR;
2464 iopkt.fd = fildes;
2465 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
2466 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
2467 POP_REENTRANCE (guard);
2468 return ret;
2469 }
2470
2471 /*------------------------------------------------------------- llseek */
2472 offset_t
llseek(int fildes,offset_t offset,int whence)2473 llseek (int fildes, offset_t offset, int whence)
2474 {
2475 int *guard;
2476 offset_t ret;
2477 IOTrace_packet iopkt;
2478 if (NULL_PTR (llseek))
2479 init_io_intf ();
2480 if (CHCK_REENTRANCE (guard))
2481 return CALL_REAL (llseek)(fildes, offset, whence);
2482 PUSH_REENTRANCE (guard);
2483 hrtime_t reqt = gethrtime ();
2484 ret = CALL_REAL (llseek)(fildes, offset, whence);
2485 if (RECHCK_REENTRANCE (guard))
2486 {
2487 POP_REENTRANCE (guard);
2488 return ret;
2489 }
2490 hrtime_t grnt = gethrtime ();
2491 collector_memset (&iopkt, 0, sizeof (IOTrace_packet));
2492 iopkt.comm.tsize = sizeof (IOTrace_packet);
2493 iopkt.comm.tstamp = grnt;
2494 iopkt.requested = reqt;
2495 if (ret != -1)
2496 iopkt.iotype = OTHERIO_TRACE;
2497 else
2498 iopkt.iotype = OTHERIO_TRACE_ERROR;
2499 iopkt.fd = fildes;
2500 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
2501 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
2502 POP_REENTRANCE (guard);
2503 return ret;
2504 }
2505
2506 /*------------------------------------------------------------- chmod */
2507 int
chmod(const char * path,mode_t mode)2508 chmod (const char *path, mode_t mode)
2509 {
2510 int *guard;
2511 int ret;
2512 void *packet;
2513 IOTrace_packet *iopkt;
2514 size_t sz;
2515 unsigned pktSize;
2516 if (NULL_PTR (chmod))
2517 init_io_intf ();
2518 if (CHCK_REENTRANCE (guard) || path == NULL)
2519 return CALL_REAL (chmod)(path, mode);
2520 PUSH_REENTRANCE (guard);
2521 hrtime_t reqt = gethrtime ();
2522 ret = CALL_REAL (chmod)(path, mode);
2523 if (RECHCK_REENTRANCE (guard))
2524 {
2525 POP_REENTRANCE (guard);
2526 return ret;
2527 }
2528 hrtime_t grnt = gethrtime ();
2529 sz = collector_strlen (path);
2530 pktSize = sizeof (IOTrace_packet) + sz;
2531 pktSize = collector_align_pktsize (pktSize);
2532 Tprintf (DBG_LT1, "iotrace allocating %u from io_heap\n", pktSize);
2533 packet = collector_interface->allocCSize (io_heap, pktSize, 1);
2534 if (packet != NULL)
2535 {
2536 iopkt = (IOTrace_packet *) packet;
2537 collector_memset (iopkt, 0, pktSize);
2538 iopkt->comm.tsize = pktSize;
2539 iopkt->comm.tstamp = grnt;
2540 iopkt->requested = reqt;
2541 if (ret != -1)
2542 iopkt->iotype = OTHERIO_TRACE;
2543 else
2544 iopkt->iotype = OTHERIO_TRACE_ERROR;
2545 collector_strncpy (&(iopkt->fname), path, sz);
2546 iopkt->comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt->comm.tstamp, FRINFO_FROM_STACK, &iopkt);
2547 collector_interface->writeDataRecord (io_hndl, (Common_packet*) iopkt);
2548 collector_interface->freeCSize (io_heap, packet, pktSize);
2549 }
2550 else
2551 {
2552 Tprintf (0, "iotrace: ERROR: chmod cannot allocate memory\n");
2553 return 0;
2554 }
2555 POP_REENTRANCE (guard);
2556 return ret;
2557 }
2558
2559 /*------------------------------------------------------------- access */
2560 int
access(const char * path,int amode)2561 access (const char *path, int amode)
2562 {
2563 int *guard;
2564 int ret;
2565 void *packet;
2566 IOTrace_packet *iopkt;
2567 size_t sz;
2568 unsigned pktSize;
2569 if (NULL_PTR (access))
2570 init_io_intf ();
2571 if (CHCK_REENTRANCE (guard) || path == NULL)
2572 return CALL_REAL (access)(path, amode);
2573 PUSH_REENTRANCE (guard);
2574 hrtime_t reqt = gethrtime ();
2575 ret = CALL_REAL (access)(path, amode);
2576 if (RECHCK_REENTRANCE (guard))
2577 {
2578 POP_REENTRANCE (guard);
2579 return ret;
2580 }
2581 hrtime_t grnt = gethrtime ();
2582 sz = collector_strlen (path);
2583 pktSize = sizeof (IOTrace_packet) + sz;
2584 pktSize = collector_align_pktsize (pktSize);
2585 Tprintf (DBG_LT1, "iotrace allocating %u from io_heap\n", pktSize);
2586 packet = collector_interface->allocCSize (io_heap, pktSize, 1);
2587 if (packet != NULL)
2588 {
2589 iopkt = (IOTrace_packet *) packet;
2590 collector_memset (iopkt, 0, pktSize);
2591 iopkt->comm.tsize = pktSize;
2592 iopkt->comm.tstamp = grnt;
2593 iopkt->requested = reqt;
2594 if (ret != -1)
2595 iopkt->iotype = OTHERIO_TRACE;
2596 else
2597 iopkt->iotype = OTHERIO_TRACE_ERROR;
2598 collector_strncpy (&(iopkt->fname), path, sz);
2599 iopkt->comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt->comm.tstamp, FRINFO_FROM_STACK, &iopkt);
2600 collector_interface->writeDataRecord (io_hndl, (Common_packet*) iopkt);
2601 collector_interface->freeCSize (io_heap, packet, pktSize);
2602 }
2603 else
2604 {
2605 Tprintf (0, "iotrace: ERROR: access cannot allocate memory\n");
2606 return 0;
2607 }
2608 POP_REENTRANCE (guard);
2609 return ret;
2610 }
2611
2612 /*------------------------------------------------------------- rename */
2613 int
rename(const char * old,const char * new)2614 rename (const char *old, const char *new)
2615 {
2616 int *guard;
2617 int ret;
2618 void *packet;
2619 IOTrace_packet *iopkt;
2620 size_t sz;
2621 unsigned pktSize;
2622 if (NULL_PTR (rename))
2623 init_io_intf ();
2624 if (CHCK_REENTRANCE (guard) || new == NULL)
2625 return CALL_REAL (rename)(old, new);
2626 PUSH_REENTRANCE (guard);
2627 hrtime_t reqt = gethrtime ();
2628 ret = CALL_REAL (rename)(old, new);
2629 if (RECHCK_REENTRANCE (guard))
2630 {
2631 POP_REENTRANCE (guard);
2632 return ret;
2633 }
2634 hrtime_t grnt = gethrtime ();
2635 sz = collector_strlen (new);
2636 pktSize = sizeof (IOTrace_packet) + sz;
2637 pktSize = collector_align_pktsize (pktSize);
2638 Tprintf (DBG_LT1, "iotrace allocating %u from io_heap\n", pktSize);
2639 packet = collector_interface->allocCSize (io_heap, pktSize, 1);
2640 if (packet != NULL)
2641 {
2642 iopkt = (IOTrace_packet *) packet;
2643 collector_memset (iopkt, 0, pktSize);
2644 iopkt->comm.tsize = pktSize;
2645 iopkt->comm.tstamp = grnt;
2646 iopkt->requested = reqt;
2647 if (ret != -1)
2648 iopkt->iotype = OTHERIO_TRACE;
2649 else
2650 iopkt->iotype = OTHERIO_TRACE_ERROR;
2651 collector_strncpy (&(iopkt->fname), new, sz);
2652 iopkt->comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt->comm.tstamp, FRINFO_FROM_STACK, &iopkt);
2653 collector_interface->writeDataRecord (io_hndl, (Common_packet*) iopkt);
2654 collector_interface->freeCSize (io_heap, packet, pktSize);
2655 }
2656 else
2657 {
2658 Tprintf (0, "iotrace: ERROR: rename cannot allocate memory\n");
2659 return 0;
2660 }
2661 POP_REENTRANCE (guard);
2662 return ret;
2663 }
2664
2665 /*------------------------------------------------------------- mkdir */
2666 int
mkdir(const char * path,mode_t mode)2667 mkdir (const char *path, mode_t mode)
2668 {
2669 int *guard;
2670 int ret;
2671 void *packet;
2672 IOTrace_packet *iopkt;
2673 size_t sz;
2674 unsigned pktSize;
2675 if (NULL_PTR (mkdir))
2676 init_io_intf ();
2677 if (CHCK_REENTRANCE (guard) || path == NULL)
2678 return CALL_REAL (mkdir)(path, mode);
2679 PUSH_REENTRANCE (guard);
2680 hrtime_t reqt = gethrtime ();
2681 ret = CALL_REAL (mkdir)(path, mode);
2682 if (RECHCK_REENTRANCE (guard))
2683 {
2684 POP_REENTRANCE (guard);
2685 return ret;
2686 }
2687 hrtime_t grnt = gethrtime ();
2688 sz = collector_strlen (path);
2689 pktSize = sizeof (IOTrace_packet) + sz;
2690 pktSize = collector_align_pktsize (pktSize);
2691 Tprintf (DBG_LT1, "iotrace allocating %u from io_heap\n", pktSize);
2692 packet = collector_interface->allocCSize (io_heap, pktSize, 1);
2693 if (packet != NULL)
2694 {
2695 iopkt = (IOTrace_packet *) packet;
2696 collector_memset (iopkt, 0, pktSize);
2697 iopkt->comm.tsize = pktSize;
2698 iopkt->comm.tstamp = grnt;
2699 iopkt->requested = reqt;
2700 if (ret != -1)
2701 iopkt->iotype = OTHERIO_TRACE;
2702 else
2703 iopkt->iotype = OTHERIO_TRACE_ERROR;
2704 collector_strncpy (&(iopkt->fname), path, sz);
2705 iopkt->comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt->comm.tstamp, FRINFO_FROM_STACK, &iopkt);
2706 collector_interface->writeDataRecord (io_hndl, (Common_packet*) iopkt);
2707 collector_interface->freeCSize (io_heap, packet, pktSize);
2708 }
2709 else
2710 {
2711 Tprintf (0, "iotrace: ERROR: mkdir cannot allocate memory\n");
2712 return 0;
2713 }
2714 POP_REENTRANCE (guard);
2715 return ret;
2716 }
2717
2718 /*------------------------------------------------------------- getdents */
2719 int
getdents(int fildes,struct dirent * buf,size_t nbyte)2720 getdents (int fildes, struct dirent *buf, size_t nbyte)
2721 {
2722 int *guard;
2723 int ret;
2724 IOTrace_packet iopkt;
2725 if (NULL_PTR (getdents))
2726 init_io_intf ();
2727 if (CHCK_REENTRANCE (guard))
2728 return CALL_REAL (getdents)(fildes, buf, nbyte);
2729 PUSH_REENTRANCE (guard);
2730 hrtime_t reqt = gethrtime ();
2731 ret = CALL_REAL (getdents)(fildes, buf, nbyte);
2732 if (RECHCK_REENTRANCE (guard))
2733 {
2734 POP_REENTRANCE (guard);
2735 return ret;
2736 }
2737 hrtime_t grnt = gethrtime ();
2738 collector_memset (&iopkt, 0, sizeof (IOTrace_packet));
2739 iopkt.comm.tsize = sizeof (IOTrace_packet);
2740 iopkt.comm.tstamp = grnt;
2741 iopkt.requested = reqt;
2742 if (ret != -1)
2743 iopkt.iotype = OTHERIO_TRACE;
2744 else
2745 iopkt.iotype = OTHERIO_TRACE_ERROR;
2746 iopkt.fd = fildes;
2747 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
2748 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
2749 POP_REENTRANCE (guard);
2750 return ret;
2751 }
2752
2753 /*------------------------------------------------------------- unlink */
2754 int
unlink(const char * path)2755 unlink (const char *path)
2756 {
2757 int *guard;
2758 int ret;
2759 void *packet;
2760 IOTrace_packet *iopkt;
2761 size_t sz;
2762 unsigned pktSize;
2763 if (NULL_PTR (unlink))
2764 init_io_intf ();
2765 if (CHCK_REENTRANCE (guard) || path == NULL)
2766 return CALL_REAL (unlink)(path);
2767 PUSH_REENTRANCE (guard);
2768 hrtime_t reqt = gethrtime ();
2769 ret = CALL_REAL (unlink)(path);
2770 if (RECHCK_REENTRANCE (guard))
2771 {
2772 POP_REENTRANCE (guard);
2773 return ret;
2774 }
2775 hrtime_t grnt = gethrtime ();
2776 sz = collector_strlen (path);
2777 pktSize = sizeof (IOTrace_packet) + sz;
2778 pktSize = collector_align_pktsize (pktSize);
2779 Tprintf (DBG_LT1, "iotrace allocating %u from io_heap\n", pktSize);
2780 packet = collector_interface->allocCSize (io_heap, pktSize, 1);
2781 if (packet != NULL)
2782 {
2783 iopkt = (IOTrace_packet *) packet;
2784 collector_memset (iopkt, 0, pktSize);
2785 iopkt->comm.tsize = pktSize;
2786 iopkt->comm.tstamp = grnt;
2787 iopkt->requested = reqt;
2788 if (ret != -1)
2789 iopkt->iotype = OTHERIO_TRACE;
2790 else
2791 iopkt->iotype = OTHERIO_TRACE_ERROR;
2792 collector_strncpy (&(iopkt->fname), path, sz);
2793 iopkt->comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt->comm.tstamp, FRINFO_FROM_STACK, &iopkt);
2794 collector_interface->writeDataRecord (io_hndl, (Common_packet*) iopkt);
2795 collector_interface->freeCSize (io_heap, packet, pktSize);
2796 }
2797 else
2798 {
2799 Tprintf (0, "iotrace: ERROR: unlink cannot allocate memory\n");
2800 return 0;
2801 }
2802 POP_REENTRANCE (guard);
2803 return ret;
2804 }
2805
2806 /*------------------------------------------------------------- fseek */
2807 int
fseek(FILE * stream,long offset,int whence)2808 fseek (FILE *stream, long offset, int whence)
2809 {
2810 int *guard;
2811 int ret;
2812 IOTrace_packet iopkt;
2813 if (NULL_PTR (fseek))
2814 init_io_intf ();
2815 if (CHCK_REENTRANCE (guard) || stream == NULL)
2816 return CALL_REAL (fseek)(stream, offset, whence);
2817 PUSH_REENTRANCE (guard);
2818 hrtime_t reqt = gethrtime ();
2819 ret = CALL_REAL (fseek)(stream, offset, whence);
2820 if (RECHCK_REENTRANCE (guard))
2821 {
2822 POP_REENTRANCE (guard);
2823 return ret;
2824 }
2825 hrtime_t grnt = gethrtime ();
2826 collector_memset (&iopkt, 0, sizeof (IOTrace_packet));
2827 iopkt.comm.tsize = sizeof (IOTrace_packet);
2828 iopkt.comm.tstamp = grnt;
2829 iopkt.requested = reqt;
2830 if (ret != -1)
2831 iopkt.iotype = OTHERIO_TRACE;
2832 else
2833 iopkt.iotype = OTHERIO_TRACE_ERROR;
2834 iopkt.fd = fileno (stream);
2835 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
2836 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
2837 POP_REENTRANCE (guard);
2838 return ret;
2839 }
2840
2841 /*------------------------------------------------------------- rewind */
2842 void
rewind(FILE * stream)2843 rewind (FILE *stream)
2844 {
2845 int *guard;
2846 IOTrace_packet iopkt;
2847 if (NULL_PTR (rewind))
2848 init_io_intf ();
2849 if (CHCK_REENTRANCE (guard) || stream == NULL)
2850 {
2851 CALL_REAL (rewind)(stream);
2852 return;
2853 }
2854 PUSH_REENTRANCE (guard);
2855 hrtime_t reqt = gethrtime ();
2856 CALL_REAL (rewind)(stream);
2857 if (RECHCK_REENTRANCE (guard))
2858 {
2859 POP_REENTRANCE (guard);
2860 return;
2861 }
2862 hrtime_t grnt = gethrtime ();
2863 collector_memset (&iopkt, 0, sizeof (IOTrace_packet));
2864 iopkt.comm.tsize = sizeof (IOTrace_packet);
2865 iopkt.comm.tstamp = grnt;
2866 iopkt.requested = reqt;
2867 iopkt.iotype = OTHERIO_TRACE;
2868 iopkt.fd = fileno (stream);
2869 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
2870 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
2871 POP_REENTRANCE (guard);
2872 }
2873
2874 /*------------------------------------------------------------- ftell */
2875 long
ftell(FILE * stream)2876 ftell (FILE *stream)
2877 {
2878 int *guard;
2879 long ret;
2880 IOTrace_packet iopkt;
2881 if (NULL_PTR (ftell))
2882 init_io_intf ();
2883 if (CHCK_REENTRANCE (guard) || stream == NULL)
2884 return CALL_REAL (ftell)(stream);
2885 PUSH_REENTRANCE (guard);
2886 hrtime_t reqt = gethrtime ();
2887 ret = CALL_REAL (ftell)(stream);
2888 if (RECHCK_REENTRANCE (guard))
2889 {
2890 POP_REENTRANCE (guard);
2891 return ret;
2892 }
2893 hrtime_t grnt = gethrtime ();
2894 collector_memset (&iopkt, 0, sizeof (IOTrace_packet));
2895 iopkt.comm.tsize = sizeof (IOTrace_packet);
2896 iopkt.comm.tstamp = grnt;
2897 iopkt.requested = reqt;
2898 if (ret != -1)
2899 iopkt.iotype = OTHERIO_TRACE;
2900 else
2901 iopkt.iotype = OTHERIO_TRACE_ERROR;
2902 iopkt.fd = fileno (stream);
2903 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
2904 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
2905 POP_REENTRANCE (guard);
2906 return ret;
2907 }
2908
2909 /*------------------------------------------------------------- fgetpos */
2910 static int
gprofng_fgetpos(int (real_fgetpos)(FILE * stream,fpos_t * pos),FILE * stream,fpos_t * pos)2911 gprofng_fgetpos (int(real_fgetpos) (FILE *stream, fpos_t *pos),
2912 FILE *stream, fpos_t *pos)
2913 {
2914 int *guard;
2915 int ret;
2916 IOTrace_packet iopkt;
2917 if (CHCK_REENTRANCE (guard) || stream == NULL)
2918 return real_fgetpos (stream, pos);
2919 PUSH_REENTRANCE (guard);
2920 hrtime_t reqt = gethrtime ();
2921 ret = real_fgetpos (stream, pos);
2922 if (RECHCK_REENTRANCE (guard))
2923 {
2924 POP_REENTRANCE (guard);
2925 return ret;
2926 }
2927 hrtime_t grnt = gethrtime ();
2928 collector_memset (&iopkt, 0, sizeof (IOTrace_packet));
2929 iopkt.comm.tsize = sizeof (IOTrace_packet);
2930 iopkt.comm.tstamp = grnt;
2931 iopkt.requested = reqt;
2932 if (ret == 0)
2933 iopkt.iotype = OTHERIO_TRACE;
2934 else
2935 iopkt.iotype = OTHERIO_TRACE_ERROR;
2936 iopkt.fd = fileno (stream);
2937 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl,
2938 iopkt.comm.tstamp, FRINFO_FROM_STACK_ARG, &iopkt);
2939 collector_interface->writeDataRecord (io_hndl, (Common_packet*) &iopkt);
2940 POP_REENTRANCE (guard);
2941 return ret;
2942 }
2943
2944 #define DCL_FGETPOS(dcl_f) \
2945 int dcl_f (FILE *stream, fpos_t *pos) \
2946 { \
2947 if (__real_fgetpos == NULL) \
2948 init_io_intf (); \
2949 return gprofng_fgetpos (__real_fgetpos, stream, pos); \
2950 }
2951
2952 DCL_FUNC_VER (DCL_FGETPOS, fgetpos_2_17, fgetpos@GLIBC_2.17)
2953 DCL_FUNC_VER (DCL_FGETPOS, fgetpos_2_2_5, fgetpos@GLIBC_2.2.5)
2954 DCL_FUNC_VER (DCL_FGETPOS, fgetpos_2_2, fgetpos@GLIBC_2.2)
2955 DCL_FUNC_VER (DCL_FGETPOS, fgetpos_2_0, fgetpos@GLIBC_2.0)
DCL_FGETPOS(fgetpos)2956 DCL_FGETPOS (fgetpos)
2957
2958 /*------------------------------------------------------------- fgetpos64 */
2959 static int
2960 gprofng_fgetpos64 (int(real_fgetpos64) (), FILE *stream, fpos64_t *pos)
2961 {
2962 int *guard;
2963 int ret;
2964 IOTrace_packet iopkt;
2965 if (CHCK_REENTRANCE (guard) || stream == NULL)
2966 return real_fgetpos64 (stream, pos);
2967 PUSH_REENTRANCE (guard);
2968 hrtime_t reqt = gethrtime ();
2969 ret = real_fgetpos64 (stream, pos);
2970 if (RECHCK_REENTRANCE (guard))
2971 {
2972 POP_REENTRANCE (guard);
2973 return ret;
2974 }
2975 hrtime_t grnt = gethrtime ();
2976 collector_memset (&iopkt, 0, sizeof (IOTrace_packet));
2977 iopkt.comm.tsize = sizeof (IOTrace_packet);
2978 iopkt.comm.tstamp = grnt;
2979 iopkt.requested = reqt;
2980 if (ret == 0)
2981 iopkt.iotype = OTHERIO_TRACE;
2982 else
2983 iopkt.iotype = OTHERIO_TRACE_ERROR;
2984 iopkt.fd = fileno (stream);
2985 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl,
2986 iopkt.comm.tstamp, FRINFO_FROM_STACK_ARG, &iopkt);
2987 collector_interface->writeDataRecord (io_hndl, (Common_packet*) &iopkt);
2988 POP_REENTRANCE (guard);
2989 return ret;
2990 }
2991
2992 #define DCL_FGETPOS64(dcl_f) \
2993 int dcl_f (FILE *stream, fpos64_t *pos) \
2994 { \
2995 if (__real_fgetpos64 == NULL) \
2996 init_io_intf (); \
2997 return gprofng_fgetpos64 (__real_fgetpos64, stream, pos); \
2998 }
2999
3000 DCL_FUNC_VER (DCL_FGETPOS64, fgetpos64_2_17, fgetpos64@GLIBC_2.17)
3001 DCL_FUNC_VER (DCL_FGETPOS64, fgetpos64_2_2_5, fgetpos64@GLIBC_2.2.5)
3002 DCL_FUNC_VER (DCL_FGETPOS64, fgetpos64_2_2, fgetpos64@GLIBC_2.2)
3003 DCL_FUNC_VER (DCL_FGETPOS64, fgetpos64_2_1, fgetpos64@GLIBC_2.1)
3004 #if !defined(__USE_LARGEFILE64)
DCL_FGETPOS64(fgetpos64)3005 DCL_FGETPOS64 (fgetpos64)
3006 #endif
3007 /*------------------------------------------------------------- fsetpos */
3008 static int
3009 gprofng_fsetpos (int(real_fsetpos) (FILE *, const fpos_t *),
3010 FILE *stream, const fpos_t *pos)
3011 {
3012 int *guard;
3013 int ret;
3014 IOTrace_packet iopkt;
3015 if (CHCK_REENTRANCE (guard) || stream == NULL)
3016 return real_fsetpos (stream, pos);
3017 PUSH_REENTRANCE (guard);
3018 hrtime_t reqt = gethrtime ();
3019 ret = real_fsetpos (stream, pos);
3020 if (RECHCK_REENTRANCE (guard))
3021 {
3022 POP_REENTRANCE (guard);
3023 return ret;
3024 }
3025 hrtime_t grnt = gethrtime ();
3026 collector_memset (&iopkt, 0, sizeof (IOTrace_packet));
3027 iopkt.comm.tsize = sizeof (IOTrace_packet);
3028 iopkt.comm.tstamp = grnt;
3029 iopkt.requested = reqt;
3030 if (ret == 0)
3031 iopkt.iotype = OTHERIO_TRACE;
3032 else
3033 iopkt.iotype = OTHERIO_TRACE_ERROR;
3034 iopkt.fd = fileno (stream);
3035 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl,
3036 iopkt.comm.tstamp, FRINFO_FROM_STACK_ARG, &iopkt);
3037 collector_interface->writeDataRecord (io_hndl, (Common_packet*) &iopkt);
3038 POP_REENTRANCE (guard);
3039 return ret;
3040 }
3041
3042 #define DCL_FSETPOS(dcl_f) \
3043 int dcl_f (FILE *stream, const fpos_t *pos) \
3044 { \
3045 if (__real_fsetpos == NULL) \
3046 init_io_intf (); \
3047 return gprofng_fsetpos (__real_fsetpos, stream, pos); \
3048 }
3049
3050 DCL_FUNC_VER (DCL_FSETPOS, fsetpos_2_17, fsetpos@GLIBC_2.17)
3051 DCL_FUNC_VER (DCL_FSETPOS, fsetpos_2_2_5, fsetpos@GLIBC_2.2.5)
3052 DCL_FUNC_VER (DCL_FSETPOS, fsetpos_2_2, fsetpos@GLIBC_2.2)
3053 DCL_FUNC_VER (DCL_FSETPOS, fsetpos_2_0, fsetpos@GLIBC_2.0)
DCL_FSETPOS(fsetpos)3054 DCL_FSETPOS (fsetpos)
3055
3056 /*------------------------------------------------------------- fsetpos64 */
3057 static int
3058 gprofng_fsetpos64 (int(real_fsetpos64) (FILE *, const fpos64_t *),
3059 FILE *stream, const fpos64_t *pos)
3060 {
3061 int *guard;
3062 int ret;
3063 IOTrace_packet iopkt;
3064 if (CHCK_REENTRANCE (guard) || stream == NULL)
3065 return real_fsetpos64 (stream, pos);
3066 PUSH_REENTRANCE (guard);
3067 hrtime_t reqt = gethrtime ();
3068 ret = real_fsetpos64 (stream, pos);
3069 if (RECHCK_REENTRANCE (guard))
3070 {
3071 POP_REENTRANCE (guard);
3072 return ret;
3073 }
3074 hrtime_t grnt = gethrtime ();
3075 collector_memset (&iopkt, 0, sizeof (IOTrace_packet));
3076 iopkt.comm.tsize = sizeof (IOTrace_packet);
3077 iopkt.comm.tstamp = grnt;
3078 iopkt.requested = reqt;
3079 if (ret == 0)
3080 iopkt.iotype = OTHERIO_TRACE;
3081 else
3082 iopkt.iotype = OTHERIO_TRACE_ERROR;
3083 iopkt.fd = fileno (stream);
3084 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl,
3085 iopkt.comm.tstamp, FRINFO_FROM_STACK_ARG, &iopkt);
3086 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
3087 POP_REENTRANCE (guard);
3088 return ret;
3089 }
3090
3091 #define DCL_FSETPOS64(dcl_f) \
3092 int dcl_f (FILE *stream, const fpos64_t *pos) \
3093 { \
3094 if (__real_fsetpos64 == NULL) \
3095 init_io_intf (); \
3096 return gprofng_fsetpos64 (__real_fsetpos64, stream, pos); \
3097 }
3098
3099 DCL_FUNC_VER (DCL_FSETPOS64, fsetpos64_2_17, fsetpos64@GLIBC_2.17)
3100 DCL_FUNC_VER (DCL_FSETPOS64, fsetpos64_2_2_5, fsetpos64@GLIBC_2.2.5)
3101 DCL_FUNC_VER (DCL_FSETPOS64, fsetpos64_2_2, fsetpos64@GLIBC_2.2)
3102 DCL_FUNC_VER (DCL_FSETPOS64, fsetpos64_2_1, fsetpos64@GLIBC_2.1)
3103 #if !defined(__USE_LARGEFILE64)
DCL_FSETPOS64(fsetpos64)3104 DCL_FSETPOS64 (fsetpos64)
3105 #endif
3106 /*------------------------------------------------------------- fsync */
3107 int
3108 fsync (int fildes)
3109 {
3110 int *guard;
3111 int ret;
3112 IOTrace_packet iopkt;
3113 if (NULL_PTR (fsync))
3114 init_io_intf ();
3115 if (CHCK_REENTRANCE (guard))
3116 return CALL_REAL (fsync)(fildes);
3117 PUSH_REENTRANCE (guard);
3118 hrtime_t reqt = gethrtime ();
3119 ret = CALL_REAL (fsync)(fildes);
3120 if (RECHCK_REENTRANCE (guard))
3121 {
3122 POP_REENTRANCE (guard);
3123 return ret;
3124 }
3125 hrtime_t grnt = gethrtime ();
3126 collector_memset (&iopkt, 0, sizeof (IOTrace_packet));
3127 iopkt.comm.tsize = sizeof (IOTrace_packet);
3128 iopkt.comm.tstamp = grnt;
3129 iopkt.requested = reqt;
3130 if (ret == 0)
3131 iopkt.iotype = OTHERIO_TRACE;
3132 else
3133 iopkt.iotype = OTHERIO_TRACE_ERROR;
3134 iopkt.fd = fildes;
3135 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
3136 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
3137 POP_REENTRANCE (guard);
3138 return ret;
3139 }
3140
3141 /*------------------------------------------------------------- readdir */
3142 struct dirent*
readdir(DIR * dirp)3143 readdir (DIR *dirp)
3144 {
3145 int *guard;
3146 struct dirent *ptr;
3147 IOTrace_packet iopkt;
3148 if (NULL_PTR (readdir))
3149 init_io_intf ();
3150 if (CHCK_REENTRANCE (guard))
3151 return CALL_REAL (readdir)(dirp);
3152 PUSH_REENTRANCE (guard);
3153 hrtime_t reqt = gethrtime ();
3154 ptr = CALL_REAL (readdir)(dirp);
3155 if (RECHCK_REENTRANCE (guard))
3156 {
3157 POP_REENTRANCE (guard);
3158 return ptr;
3159 }
3160 hrtime_t grnt = gethrtime ();
3161 collector_memset (&iopkt, 0, sizeof ( IOTrace_packet));
3162 iopkt.comm.tsize = sizeof ( IOTrace_packet);
3163 iopkt.comm.tstamp = grnt;
3164 iopkt.requested = reqt;
3165 if (ptr != NULL)
3166 iopkt.iotype = OTHERIO_TRACE;
3167 else
3168 iopkt.iotype = OTHERIO_TRACE_ERROR;
3169 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
3170 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
3171 POP_REENTRANCE (guard);
3172 return ptr;
3173 }
3174
3175 /*------------------------------------------------------------- flock */
3176 int
flock(int fd,int operation)3177 flock (int fd, int operation)
3178 {
3179 int *guard;
3180 int ret;
3181 IOTrace_packet iopkt;
3182 if (NULL_PTR (flock))
3183 init_io_intf ();
3184 if (CHCK_REENTRANCE (guard))
3185 return CALL_REAL (flock)(fd, operation);
3186 PUSH_REENTRANCE (guard);
3187 hrtime_t reqt = gethrtime ();
3188 ret = CALL_REAL (flock)(fd, operation);
3189 if (RECHCK_REENTRANCE (guard))
3190 {
3191 POP_REENTRANCE (guard);
3192 return ret;
3193 }
3194 hrtime_t grnt = gethrtime ();
3195 collector_memset (&iopkt, 0, sizeof (IOTrace_packet));
3196 iopkt.comm.tsize = sizeof (IOTrace_packet);
3197 iopkt.comm.tstamp = grnt;
3198 iopkt.requested = reqt;
3199 if (ret == 0)
3200 iopkt.iotype = OTHERIO_TRACE;
3201 else
3202 iopkt.iotype = OTHERIO_TRACE_ERROR;
3203 iopkt.fd = fd;
3204 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
3205 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
3206 POP_REENTRANCE (guard);
3207 return ret;
3208 }
3209
3210 /*------------------------------------------------------------- lockf */
3211 int
lockf(int fildes,int function,off_t size)3212 lockf (int fildes, int function, off_t size)
3213 {
3214 int *guard;
3215 int ret;
3216 IOTrace_packet iopkt;
3217 if (NULL_PTR (lockf))
3218 init_io_intf ();
3219 if (CHCK_REENTRANCE (guard))
3220 return CALL_REAL (lockf)(fildes, function, size);
3221 PUSH_REENTRANCE (guard);
3222 hrtime_t reqt = gethrtime ();
3223 ret = CALL_REAL (lockf)(fildes, function, size);
3224 if (RECHCK_REENTRANCE (guard))
3225 {
3226 POP_REENTRANCE (guard);
3227 return ret;
3228 }
3229 hrtime_t grnt = gethrtime ();
3230 collector_memset (&iopkt, 0, sizeof (IOTrace_packet));
3231 iopkt.comm.tsize = sizeof (IOTrace_packet);
3232 iopkt.comm.tstamp = grnt;
3233 iopkt.requested = reqt;
3234 if (ret == 0)
3235 iopkt.iotype = OTHERIO_TRACE;
3236 else
3237 iopkt.iotype = OTHERIO_TRACE_ERROR;
3238 iopkt.fd = fildes;
3239 iopkt.comm.frinfo = collector_interface->getFrameInfo (io_hndl, iopkt.comm.tstamp, FRINFO_FROM_STACK, &iopkt);
3240 collector_interface->writeDataRecord (io_hndl, (Common_packet*) & iopkt);
3241 POP_REENTRANCE (guard);
3242 return ret;
3243 }
3244