darshan-posix.c 70 KB
Newer Older
1
/*
Shane Snyder's avatar
Shane Snyder committed
2
3
4
 * Copyright (C) 2015 University of Chicago.
 * See COPYRIGHT notice in top-level directory.
 *
5
6
 */

7
8
9
#define _XOPEN_SOURCE 500
#define _GNU_SOURCE

10
#include "darshan-runtime-config.h"
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdarg.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/uio.h>
#include <sys/mman.h>
#include <search.h>
#include <assert.h>
25
#include <libgen.h>
Philip Carns's avatar
Philip Carns committed
26
#include <aio.h>
27
#include <pthread.h>
28
#include <limits.h>
29

30
#include "utlist.h"
31
#include "darshan.h"
32
#include "darshan-dynamic.h"
Shane Snyder's avatar
Shane Snyder committed
33
#include "darshan-dxt.h"
34

35
#ifndef HAVE_OFF64_T
36
37
typedef int64_t off64_t;
#endif
38
39
40
#ifndef HAVE_AIOCB64
#define aiocb64 aiocb
#endif
41

42

43
44
DARSHAN_FORWARD_DECL(open, int, (const char *path, int flags, ...));
DARSHAN_FORWARD_DECL(open64, int, (const char *path, int flags, ...));
45
DARSHAN_FORWARD_DECL(__open_2, int, (const char *path, int oflag));
46
47
DARSHAN_FORWARD_DECL(openat, int, (int dirfd, const char *pathname, int flags, ...));
DARSHAN_FORWARD_DECL(openat64, int, (int dirfd, const char *pathname, int flags, ...));
48
49
DARSHAN_FORWARD_DECL(creat, int, (const char* path, mode_t mode));
DARSHAN_FORWARD_DECL(creat64, int, (const char* path, mode_t mode));
50
51
52
DARSHAN_FORWARD_DECL(dup, int, (int oldfd));
DARSHAN_FORWARD_DECL(dup2, int, (int oldfd, int newfd));
DARSHAN_FORWARD_DECL(dup3, int, (int oldfd, int newfd, int flags));
53
DARSHAN_FORWARD_DECL(fileno, int, (FILE *stream));
54
55
56
57
DARSHAN_FORWARD_DECL(mkstemp, int, (char *template));
DARSHAN_FORWARD_DECL(mkostemp, int, (char *template, int flags));
DARSHAN_FORWARD_DECL(mkstemps, int, (char *template, int suffixlen));
DARSHAN_FORWARD_DECL(mkostemps, int, (char *template, int suffixlen, int flags));
58
59
60
61
62
63
64
65
DARSHAN_FORWARD_DECL(read, ssize_t, (int fd, void *buf, size_t count));
DARSHAN_FORWARD_DECL(write, ssize_t, (int fd, const void *buf, size_t count));
DARSHAN_FORWARD_DECL(pread, ssize_t, (int fd, void *buf, size_t count, off_t offset));
DARSHAN_FORWARD_DECL(pwrite, ssize_t, (int fd, const void *buf, size_t count, off_t offset));
DARSHAN_FORWARD_DECL(pread64, ssize_t, (int fd, void *buf, size_t count, off64_t offset));
DARSHAN_FORWARD_DECL(pwrite64, ssize_t, (int fd, const void *buf, size_t count, off64_t offset));
DARSHAN_FORWARD_DECL(readv, ssize_t, (int fd, const struct iovec *iov, int iovcnt));
DARSHAN_FORWARD_DECL(writev, ssize_t, (int fd, const struct iovec *iov, int iovcnt));
66
67
DARSHAN_FORWARD_DECL(lseek, off_t, (int fd, off_t offset, int whence));
DARSHAN_FORWARD_DECL(lseek64, off64_t, (int fd, off64_t offset, int whence));
68
69
70
71
72
73
DARSHAN_FORWARD_DECL(__xstat, int, (int vers, const char* path, struct stat *buf));
DARSHAN_FORWARD_DECL(__xstat64, int, (int vers, const char* path, struct stat64 *buf));
DARSHAN_FORWARD_DECL(__lxstat, int, (int vers, const char* path, struct stat *buf));
DARSHAN_FORWARD_DECL(__lxstat64, int, (int vers, const char* path, struct stat64 *buf));
DARSHAN_FORWARD_DECL(__fxstat, int, (int vers, int fd, struct stat *buf));
DARSHAN_FORWARD_DECL(__fxstat64, int, (int vers, int fd, struct stat64 *buf));
74
#ifdef DARSHAN_WRAP_MMAP
Shane Snyder's avatar
Shane Snyder committed
75
76
DARSHAN_FORWARD_DECL(mmap, void*, (void *addr, size_t length, int prot, int flags, int fd, off_t offset));
DARSHAN_FORWARD_DECL(mmap64, void*, (void *addr, size_t length, int prot, int flags, int fd, off64_t offset));
77
#endif /* DARSHAN_WRAP_MMAP */
78
79
DARSHAN_FORWARD_DECL(fsync, int, (int fd));
DARSHAN_FORWARD_DECL(fdatasync, int, (int fd));
80
DARSHAN_FORWARD_DECL(close, int, (int fd));
81
82
83
84
85
86
87
88
DARSHAN_FORWARD_DECL(aio_read, int, (struct aiocb *aiocbp));
DARSHAN_FORWARD_DECL(aio_write, int, (struct aiocb *aiocbp));
DARSHAN_FORWARD_DECL(aio_read64, int, (struct aiocb64 *aiocbp));
DARSHAN_FORWARD_DECL(aio_write64, int, (struct aiocb64 *aiocbp));
DARSHAN_FORWARD_DECL(aio_return, ssize_t, (struct aiocb *aiocbp));
DARSHAN_FORWARD_DECL(aio_return64, ssize_t, (struct aiocb64 *aiocbp));
DARSHAN_FORWARD_DECL(lio_listio, int, (int mode, struct aiocb *const aiocb_list[], int nitems, struct sigevent *sevp));
DARSHAN_FORWARD_DECL(lio_listio64, int, (int mode, struct aiocb64 *const aiocb_list[], int nitems, struct sigevent *sevp));
89
DARSHAN_FORWARD_DECL(rename, int, (const char *oldpath, const char *newpath));
90

91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
/* The posix_file_record_ref structure maintains necessary runtime metadata
 * for the POSIX file record (darshan_posix_file structure, defined in
 * darshan-posix-log-format.h) pointed to by 'file_rec'. This metadata
 * assists with the instrumenting of specific statistics in the file record.
 *
 * RATIONALE: the POSIX module needs to track some stateful, volatile 
 * information about each open file (like the current file offset, most recent 
 * access time, etc.) to aid in instrumentation, but this information can't be
 * stored in the darshan_posix_file struct because we don't want it to appear in
 * the final darshan log file.  We therefore associate a posix_file_record_ref
 * struct with each darshan_posix_file struct in order to track this information
 * (i.e., the mapping between posix_file_record_ref structs to darshan_posix_file
 * structs is one-to-one).
 *
 * NOTE: we use the 'darshan_record_ref' interface (in darshan-common) to
 * associate different types of handles with this posix_file_record_ref struct.
 * This allows us to index this struct (and the underlying file record) by using
 * either the corresponding Darshan record identifier (derived from the filename)
109
110
 * or by a generated file descriptor, for instance. Note that, while there should
 * only be a single Darshan record identifier that indexes a posix_file_record_ref,
111
112
 * there could be multiple open file descriptors that index it.
 */
113
struct posix_file_record_ref
114
{
115
    struct darshan_posix_file *file_rec;
116
117
118
    int64_t offset;
    int64_t last_byte_read;
    int64_t last_byte_written;
Shane Snyder's avatar
Shane Snyder committed
119
    enum darshan_io_type last_io_type;
120
121
122
    double last_meta_end;
    double last_read_end;
    double last_write_end;
123
    void *access_root;
124
    int access_count;
125
    void *stride_root;
126
    int stride_count;
127
    struct posix_aio_tracker* aio_list;
128
    int fs_type; /* same as darshan_fs_info->fs_type */
129
130
};

131
132
133
134
/* The posix_runtime structure maintains necessary state for storing
 * POSIX file records and for coordinating with darshan-core at 
 * shutdown time.
 */
135
136
struct posix_runtime
{
137
138
139
    void *rec_id_hash;
    void *fd_hash;
    int file_rec_count;
140
141
};

142
143
144
145
146
/* struct to track information about aio operations in flight */
struct posix_aio_tracker
{
    double tm1;
    void *aiocbp;
147
    struct posix_aio_tracker *next;
148
};
149

150
151
152
static void posix_runtime_initialize(
    void);
static struct posix_file_record_ref *posix_track_new_file_record(
153
    darshan_record_id rec_id, const char *path);
154
155
156
157
static void posix_aio_tracker_add(
    int fd, void *aiocbp);
static struct posix_aio_tracker* posix_aio_tracker_del(
    int fd, void *aiocbp);
158
static void posix_finalize_file_records(
159
    void *rec_ref_p, void *user_ptr);
160
161
static void posix_cleanup_runtime(
    void);
162
#ifdef HAVE_MPI
163
164
165
166
167
static void posix_record_reduction_op(
    void* infile_v, void* inoutfile_v, int *len, MPI_Datatype *datatype);
static void posix_shared_record_variance(
    MPI_Comm mod_comm, struct darshan_posix_file *inrec_array,
    struct darshan_posix_file *outrec_array, int shared_rec_count);
168
169
170
171
static void posix_mpi_redux(
    void *posix_buf, MPI_Comm mod_comm,
    darshan_record_id *shared_recs, int shared_rec_count);
#endif
172
static void posix_shutdown(
173
    void **posix_buf, int *posix_buf_sz);
174

175
176
/* extern function def for querying record name from a STDIO stream */
extern char *darshan_stdio_lookup_record_name(FILE *stream);
177

178
179
180
181
182
static struct posix_runtime *posix_runtime = NULL;
static pthread_mutex_t posix_runtime_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
static int my_rank = -1;
static int darshan_mem_alignment = 1;

183
184
185
#define POSIX_LOCK() pthread_mutex_lock(&posix_runtime_mutex)
#define POSIX_UNLOCK() pthread_mutex_unlock(&posix_runtime_mutex)

186
187
#define POSIX_PRE_RECORD() do { \
    POSIX_LOCK(); \
188
    if(!darshan_core_disabled_instrumentation()) { \
189
190
191
        if(!posix_runtime) { \
            posix_runtime_initialize(); \
        } \
192
        if(posix_runtime) break; \
193
    } \
194
195
    POSIX_UNLOCK(); \
    return(ret); \
196
197
198
199
200
} while(0)

#define POSIX_POST_RECORD() do { \
    POSIX_UNLOCK(); \
} while(0)
201

202
203
204
205
#define POSIX_RECORD_OPEN(__ret, __path, __mode, __tm1, __tm2) do { \
    darshan_record_id __rec_id; \
    struct posix_file_record_ref *__rec_ref; \
    char *__newpath; \
206
    if(__ret < 0) break; \
207
208
209
210
    __newpath = darshan_clean_file_path(__path); \
    if(!__newpath) __newpath = (char *)__path; \
    if(darshan_core_excluded_path(__newpath)) { \
        if(__newpath != __path) free(__newpath); \
211
212
        break; \
    } \
213
214
215
216
217
    __rec_id = darshan_core_gen_record_id(__newpath); \
    __rec_ref = darshan_lookup_record_ref(posix_runtime->rec_id_hash, &__rec_id, sizeof(darshan_record_id)); \
    if(!__rec_ref) __rec_ref = posix_track_new_file_record(__rec_id, __newpath); \
    if(!__rec_ref) { \
        if(__newpath != __path) free(__newpath); \
218
        break; \
219
    } \
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
    _POSIX_RECORD_OPEN(__ret, __rec_ref, __mode, __tm1, __tm2, 1, -1); \
    darshan_instrument_fs_data(__rec_ref->fs_type, __newpath, __ret); \
    if(__newpath != __path) free(__newpath); \
} while(0)

#define POSIX_RECORD_REFOPEN(__ret, __rec_ref, __tm1, __tm2, __ref_counter) do { \
    if(__ret < 0 || !__rec_ref) break; \
    _POSIX_RECORD_OPEN(__ret, __rec_ref, 0, __tm1, __tm2, 0, __ref_counter); \
} while(0)

#define _POSIX_RECORD_OPEN(__ret, __rec_ref, __mode, __tm1, __tm2, __reset_flag, __ref_counter) do { \
    if(__mode) __rec_ref->file_rec->counters[POSIX_MODE] = __mode; \
    if(__reset_flag) { \
        __rec_ref->offset = 0; \
        __rec_ref->last_byte_written = 0; \
        __rec_ref->last_byte_read = 0; \
    } \
    __rec_ref->file_rec->counters[POSIX_OPENS] += 1; \
    if(__ref_counter >= 0) __rec_ref->file_rec->counters[__ref_counter] += 1; \
    if(__rec_ref->file_rec->fcounters[POSIX_F_OPEN_START_TIMESTAMP] == 0 || \
     __rec_ref->file_rec->fcounters[POSIX_F_OPEN_START_TIMESTAMP] > __tm1) \
        __rec_ref->file_rec->fcounters[POSIX_F_OPEN_START_TIMESTAMP] = __tm1; \
    __rec_ref->file_rec->fcounters[POSIX_F_OPEN_END_TIMESTAMP] = __tm2; \
    DARSHAN_TIMER_INC_NO_OVERLAP(__rec_ref->file_rec->fcounters[POSIX_F_META_TIME], \
        __tm1, __tm2, __rec_ref->last_meta_end); \
    darshan_add_record_ref(&(posix_runtime->fd_hash), &__ret, sizeof(int), __rec_ref); \
246
247
} while(0)

248
#define POSIX_RECORD_READ(__ret, __fd, __pread_flag, __pread_offset, __aligned, __tm1, __tm2) do { \
249
    struct posix_file_record_ref* rec_ref; \
250
    int64_t stride; \
251
    int64_t this_offset; \
252
    int64_t file_alignment; \
253
    struct darshan_common_val_counter *cvc; \
254
255
    double __elapsed = __tm2-__tm1; \
    if(__ret < 0) break; \
256
257
    rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &(__fd), sizeof(int)); \
    if(!rec_ref) break; \
258
    if(__pread_flag) \
259
260
        this_offset = __pread_offset; \
    else \
261
        this_offset = rec_ref->offset; \
262
    /* DXT to record detailed read tracing information */ \
Shane Snyder's avatar
Shane Snyder committed
263
    dxt_posix_read(rec_ref->file_rec->base_rec.id, this_offset, __ret, __tm1, __tm2); \
264
265
266
267
268
269
270
    if(this_offset > rec_ref->last_byte_read) \
        rec_ref->file_rec->counters[POSIX_SEQ_READS] += 1;  \
    if(this_offset == (rec_ref->last_byte_read + 1)) \
        rec_ref->file_rec->counters[POSIX_CONSEC_READS] += 1;  \
    if(this_offset > 0 && this_offset > rec_ref->last_byte_read \
        && rec_ref->last_byte_read != 0) \
        stride = this_offset - rec_ref->last_byte_read - 1; \
271
    else \
272
        stride = 0; \
273
274
275
276
277
    rec_ref->last_byte_read = this_offset + __ret - 1; \
    rec_ref->offset = this_offset + __ret; \
    if(rec_ref->file_rec->counters[POSIX_MAX_BYTE_READ] < (this_offset + __ret - 1)) \
        rec_ref->file_rec->counters[POSIX_MAX_BYTE_READ] = (this_offset + __ret - 1); \
    rec_ref->file_rec->counters[POSIX_BYTES_READ] += __ret; \
278
    rec_ref->file_rec->counters[POSIX_READS] += 1; \
279
    DARSHAN_BUCKET_INC(&(rec_ref->file_rec->counters[POSIX_SIZE_READ_0_100]), __ret); \
280
281
282
    cvc = darshan_track_common_val_counters(&rec_ref->access_root, &__ret, 1, \
        &rec_ref->access_count); \
    if(cvc) DARSHAN_UPDATE_COMMON_VAL_COUNTERS( \
283
        &(rec_ref->file_rec->counters[POSIX_ACCESS1_ACCESS]), \
284
285
286
287
288
        &(rec_ref->file_rec->counters[POSIX_ACCESS1_COUNT]), \
        cvc->vals, 1, cvc->freq, 0); \
    cvc = darshan_track_common_val_counters(&rec_ref->stride_root, &stride, 1, \
        &rec_ref->stride_count); \
    if(cvc) DARSHAN_UPDATE_COMMON_VAL_COUNTERS( \
289
        &(rec_ref->file_rec->counters[POSIX_STRIDE1_STRIDE]), \
290
291
        &(rec_ref->file_rec->counters[POSIX_STRIDE1_COUNT]), \
        cvc->vals, 1, cvc->freq, 0); \
292
    if(!__aligned) \
293
294
        rec_ref->file_rec->counters[POSIX_MEM_NOT_ALIGNED] += 1; \
    file_alignment = rec_ref->file_rec->counters[POSIX_FILE_ALIGNMENT]; \
295
    if(file_alignment > 0 && (this_offset % file_alignment) != 0) \
296
297
298
299
        rec_ref->file_rec->counters[POSIX_FILE_NOT_ALIGNED] += 1; \
    if(rec_ref->last_io_type == DARSHAN_IO_WRITE) \
        rec_ref->file_rec->counters[POSIX_RW_SWITCHES] += 1; \
    rec_ref->last_io_type = DARSHAN_IO_READ; \
300
301
    if(rec_ref->file_rec->fcounters[POSIX_F_READ_START_TIMESTAMP] == 0 || \
     rec_ref->file_rec->fcounters[POSIX_F_READ_START_TIMESTAMP] > __tm1) \
302
303
304
305
306
307
308
        rec_ref->file_rec->fcounters[POSIX_F_READ_START_TIMESTAMP] = __tm1; \
    rec_ref->file_rec->fcounters[POSIX_F_READ_END_TIMESTAMP] = __tm2; \
    if(rec_ref->file_rec->fcounters[POSIX_F_MAX_READ_TIME] < __elapsed) { \
        rec_ref->file_rec->fcounters[POSIX_F_MAX_READ_TIME] = __elapsed; \
        rec_ref->file_rec->counters[POSIX_MAX_READ_TIME_SIZE] = __ret; } \
    DARSHAN_TIMER_INC_NO_OVERLAP(rec_ref->file_rec->fcounters[POSIX_F_READ_TIME], \
        __tm1, __tm2, rec_ref->last_read_end); \
309
310
} while(0)

311
#define POSIX_RECORD_WRITE(__ret, __fd, __pwrite_flag, __pwrite_offset, __aligned, __tm1, __tm2) do { \
312
    struct posix_file_record_ref* rec_ref; \
313
    int64_t stride; \
314
    int64_t this_offset; \
315
    int64_t file_alignment; \
316
    struct darshan_common_val_counter *cvc; \
317
318
    double __elapsed = __tm2-__tm1; \
    if(__ret < 0) break; \
319
320
    rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &__fd, sizeof(int)); \
    if(!rec_ref) break; \
321
    if(__pwrite_flag) \
322
323
        this_offset = __pwrite_offset; \
    else \
324
        this_offset = rec_ref->offset; \
325
    /* DXT to record detailed write tracing information */ \
Shane Snyder's avatar
Shane Snyder committed
326
    dxt_posix_write(rec_ref->file_rec->base_rec.id, this_offset, __ret, __tm1, __tm2); \
327
328
329
330
331
332
333
    if(this_offset > rec_ref->last_byte_written) \
        rec_ref->file_rec->counters[POSIX_SEQ_WRITES] += 1; \
    if(this_offset == (rec_ref->last_byte_written + 1)) \
        rec_ref->file_rec->counters[POSIX_CONSEC_WRITES] += 1; \
    if(this_offset > 0 && this_offset > rec_ref->last_byte_written \
        && rec_ref->last_byte_written != 0) \
        stride = this_offset - rec_ref->last_byte_written - 1; \
334
    else \
335
        stride = 0; \
336
337
338
339
340
    rec_ref->last_byte_written = this_offset + __ret - 1; \
    rec_ref->offset = this_offset + __ret; \
    if(rec_ref->file_rec->counters[POSIX_MAX_BYTE_WRITTEN] < (this_offset + __ret - 1)) \
        rec_ref->file_rec->counters[POSIX_MAX_BYTE_WRITTEN] = (this_offset + __ret - 1); \
    rec_ref->file_rec->counters[POSIX_BYTES_WRITTEN] += __ret; \
341
    rec_ref->file_rec->counters[POSIX_WRITES] += 1; \
342
    DARSHAN_BUCKET_INC(&(rec_ref->file_rec->counters[POSIX_SIZE_WRITE_0_100]), __ret); \
343
344
345
    cvc = darshan_track_common_val_counters(&rec_ref->access_root, &__ret, 1, \
        &rec_ref->access_count); \
    if(cvc) DARSHAN_UPDATE_COMMON_VAL_COUNTERS( \
346
        &(rec_ref->file_rec->counters[POSIX_ACCESS1_ACCESS]), \
347
348
349
350
351
        &(rec_ref->file_rec->counters[POSIX_ACCESS1_COUNT]), \
        cvc->vals, 1, cvc->freq, 0); \
    cvc = darshan_track_common_val_counters(&rec_ref->stride_root, &stride, 1, \
        &rec_ref->stride_count); \
    if(cvc) DARSHAN_UPDATE_COMMON_VAL_COUNTERS( \
352
        &(rec_ref->file_rec->counters[POSIX_STRIDE1_STRIDE]), \
353
354
        &(rec_ref->file_rec->counters[POSIX_STRIDE1_COUNT]), \
        cvc->vals, 1, cvc->freq, 0); \
355
    if(!__aligned) \
356
357
        rec_ref->file_rec->counters[POSIX_MEM_NOT_ALIGNED] += 1; \
    file_alignment = rec_ref->file_rec->counters[POSIX_FILE_ALIGNMENT]; \
358
    if(file_alignment > 0 && (this_offset % file_alignment) != 0) \
359
360
361
362
        rec_ref->file_rec->counters[POSIX_FILE_NOT_ALIGNED] += 1; \
    if(rec_ref->last_io_type == DARSHAN_IO_READ) \
        rec_ref->file_rec->counters[POSIX_RW_SWITCHES] += 1; \
    rec_ref->last_io_type = DARSHAN_IO_WRITE; \
363
364
    if(rec_ref->file_rec->fcounters[POSIX_F_WRITE_START_TIMESTAMP] == 0 || \
     rec_ref->file_rec->fcounters[POSIX_F_WRITE_START_TIMESTAMP] > __tm1) \
365
366
367
368
369
370
371
        rec_ref->file_rec->fcounters[POSIX_F_WRITE_START_TIMESTAMP] = __tm1; \
    rec_ref->file_rec->fcounters[POSIX_F_WRITE_END_TIMESTAMP] = __tm2; \
    if(rec_ref->file_rec->fcounters[POSIX_F_MAX_WRITE_TIME] < __elapsed) { \
        rec_ref->file_rec->fcounters[POSIX_F_MAX_WRITE_TIME] = __elapsed; \
        rec_ref->file_rec->counters[POSIX_MAX_WRITE_TIME_SIZE] = __ret; } \
    DARSHAN_TIMER_INC_NO_OVERLAP(rec_ref->file_rec->fcounters[POSIX_F_WRITE_TIME], \
        __tm1, __tm2, rec_ref->last_write_end); \
372
} while(0)
373

374
#define POSIX_LOOKUP_RECORD_STAT(__path, __statbuf, __tm1, __tm2) do { \
375
    darshan_record_id rec_id; \
376
377
378
379
380
381
    struct posix_file_record_ref* rec_ref; \
    char *newpath = darshan_clean_file_path(__path); \
    if(!newpath) newpath = (char *)__path; \
    if(darshan_core_excluded_path(newpath)) { \
        if(newpath != __path) free(newpath); \
        break; \
382
    } \
383
384
    rec_id = darshan_core_gen_record_id(newpath); \
    rec_ref = darshan_lookup_record_ref(posix_runtime->rec_id_hash, &rec_id, sizeof(darshan_record_id)); \
385
    if(!rec_ref) rec_ref = posix_track_new_file_record(rec_id, newpath); \
386
    if(newpath != __path) free(newpath); \
387
388
    if(rec_ref) { \
        POSIX_RECORD_STAT(rec_ref, __statbuf, __tm1, __tm2); \
389
390
391
    } \
} while(0)

392
393
394
395
#define POSIX_RECORD_STAT(__rec_ref, __statbuf, __tm1, __tm2) do { \
    (__rec_ref)->file_rec->counters[POSIX_STATS] += 1; \
    DARSHAN_TIMER_INC_NO_OVERLAP((__rec_ref)->file_rec->fcounters[POSIX_F_META_TIME], \
        __tm1, __tm2, (__rec_ref)->last_meta_end); \
396
397
} while(0)

398

399
400
401
402
/**********************************************************
 *      Wrappers for POSIX I/O functions of interest      * 
 **********************************************************/

403
int DARSHAN_DECL(open)(const char *path, int flags, ...)
404
405
406
407
408
{
    int mode = 0;
    int ret;
    double tm1, tm2;

409
410
    MAP_OR_FAIL(open);

411
    if(flags & O_CREAT) 
412
413
414
415
416
417
    {
        va_list arg;
        va_start(arg, flags);
        mode = va_arg(arg, int);
        va_end(arg);

418
        tm1 = darshan_core_wtime();
419
        ret = __real_open(path, flags, mode);
420
        tm2 = darshan_core_wtime();
421
422
423
    }
    else
    {
424
        tm1 = darshan_core_wtime();
425
        ret = __real_open(path, flags);
426
        tm2 = darshan_core_wtime();
427
428
    }

429
    POSIX_PRE_RECORD();
430
    POSIX_RECORD_OPEN(ret, path, mode, tm1, tm2);
431
    POSIX_POST_RECORD();
432
433
434
435

    return(ret);
}

436
437
438
439
440
441
442
443
444
445
446
447
int DARSHAN_DECL(__open_2)(const char *path, int oflag)
{
    int ret;
    double tm1, tm2;

    MAP_OR_FAIL(__open_2);

    tm1 = darshan_core_wtime();
    ret = __real___open_2(path, oflag);
    tm2 = darshan_core_wtime();

    POSIX_PRE_RECORD();
448
    POSIX_RECORD_OPEN(ret, path, 0, tm1, tm2);
449
450
451
452
453
    POSIX_POST_RECORD();

    return(ret);
}

Shane Snyder's avatar
Shane Snyder committed
454
455
456
457
458
459
int DARSHAN_DECL(open64)(const char *path, int flags, ...)
{
    int mode = 0;
    int ret;
    double tm1, tm2;

460
    MAP_OR_FAIL(open64);
Shane Snyder's avatar
Shane Snyder committed
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479

    if(flags & O_CREAT)
    {
        va_list arg;
        va_start(arg, flags);
        mode = va_arg(arg, int);
        va_end(arg);

        tm1 = darshan_core_wtime();
        ret = __real_open64(path, flags, mode);
        tm2 = darshan_core_wtime();
    }
    else
    {
        tm1 = darshan_core_wtime();
        ret = __real_open64(path, flags);
        tm2 = darshan_core_wtime();
    }

480
    POSIX_PRE_RECORD();
481
    POSIX_RECORD_OPEN(ret, path, mode, tm1, tm2);
482
    POSIX_POST_RECORD();
483
484
485
486

    return(ret);
}

487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
int DARSHAN_DECL(openat)(int dirfd, const char *pathname, int flags, ...)
{
    int mode = 0;
    int ret;
    double tm1, tm2;
    struct posix_file_record_ref *rec_ref;
    char tmp_path[PATH_MAX] = {0};
    char *dirpath = NULL;

    MAP_OR_FAIL(openat);

    if(flags & O_CREAT)
    {
        va_list arg;
        va_start(arg, flags);
        mode = va_arg(arg, int);
        va_end(arg);

        tm1 = darshan_core_wtime();
        ret = __real_openat(dirfd, pathname, flags, mode);
        tm2 = darshan_core_wtime();
    }
    else
    {
        tm1 = darshan_core_wtime();
        ret = __real_openat(dirfd, pathname, flags);
        tm2 = darshan_core_wtime();
    }

    POSIX_PRE_RECORD();
    if(pathname[0] == '/' || dirfd == AT_FDCWD)
    {
        /* ignore dirfd in these cases:
         *    - absolute path
         *    - dirfd equal to CWD
         */
        POSIX_RECORD_OPEN(ret, pathname, mode, tm1, tm2);
    }
    else
    {
        /* construct path relative to dirfd */
        rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash,
            &dirfd, sizeof(dirfd));
        if(rec_ref)
        {
            dirpath = darshan_core_lookup_record_name(rec_ref->file_rec->base_rec.id);
            if(dirpath)
            {
                strcat(tmp_path, dirpath);
                if(dirpath[strlen(dirpath)-1] != '/')
                    strcat(tmp_path, "/");
                strcat(tmp_path, pathname);
            }
        }

        if(dirpath)
        {
            /* we were able to construct an absolute path */
            POSIX_RECORD_OPEN(ret, tmp_path, mode, tm1, tm2);
        }
        else
        {
            /* fallback to relative path if Darshan doesn't know dirfd path */
            POSIX_RECORD_OPEN(ret, pathname, mode, tm1, tm2);
        }
    }
    POSIX_POST_RECORD();

    return(ret);
}

int DARSHAN_DECL(openat64)(int dirfd, const char *pathname, int flags, ...)
{
    int mode = 0;
    int ret;
    double tm1, tm2;
    struct posix_file_record_ref *rec_ref;
    char tmp_path[PATH_MAX] = {0};
    char *dirpath = NULL;

    MAP_OR_FAIL(openat64);

    if(flags & O_CREAT)
    {
        va_list arg;
        va_start(arg, flags);
        mode = va_arg(arg, int);
        va_end(arg);

        tm1 = darshan_core_wtime();
        ret = __real_openat64(dirfd, pathname, flags, mode);
        tm2 = darshan_core_wtime();
    }
    else
    {
        tm1 = darshan_core_wtime();
        ret = __real_openat64(dirfd, pathname, flags);
        tm2 = darshan_core_wtime();
    }

    POSIX_PRE_RECORD();
    if(pathname[0] == '/' || dirfd == AT_FDCWD)
    {
        /* ignore dirfd in these cases:
         *    - absolute path
         *    - dirfd equal to CWD
         */
        POSIX_RECORD_OPEN(ret, pathname, mode, tm1, tm2);
    }
    else
    {
        /* construct path relative to dirfd */
        rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash,
            &dirfd, sizeof(dirfd));
        if(rec_ref)
        {
            dirpath = darshan_core_lookup_record_name(rec_ref->file_rec->base_rec.id);
            if(dirpath)
            {
                strcat(tmp_path, dirpath);
                if(dirpath[strlen(dirpath)-1] != '/')
                    strcat(tmp_path, "/");
                strcat(tmp_path, pathname);
            }
        }

        if(dirpath)
        {
            /* we were able to construct an absolute path */
            POSIX_RECORD_OPEN(ret, tmp_path, mode, tm1, tm2);
        }
        else
        {
            /* fallback to relative path if Darshan doesn't know dirfd path */
            POSIX_RECORD_OPEN(ret, pathname, mode, tm1, tm2);
        }
    }
    POSIX_POST_RECORD();

    return(ret);
}

629
630
631
632
633
634
635
636
637
638
639
int DARSHAN_DECL(creat)(const char* path, mode_t mode)
{
    int ret;
    double tm1, tm2;

    MAP_OR_FAIL(creat);

    tm1 = darshan_core_wtime();
    ret = __real_creat(path, mode);
    tm2 = darshan_core_wtime();

640
    POSIX_PRE_RECORD();
641
    POSIX_RECORD_OPEN(ret, path, mode, tm1, tm2);
642
    POSIX_POST_RECORD();
643
644
645
646
647
648
649
650
651
652

    return(ret);
}

int DARSHAN_DECL(creat64)(const char* path, mode_t mode)
{
    int ret;
    double tm1, tm2;

    MAP_OR_FAIL(creat64);
Shane Snyder's avatar
Shane Snyder committed
653

654
655
656
657
    tm1 = darshan_core_wtime();
    ret = __real_creat64(path, mode);
    tm2 = darshan_core_wtime();

658
    POSIX_PRE_RECORD();
659
    POSIX_RECORD_OPEN(ret, path, mode, tm1, tm2);
660
    POSIX_POST_RECORD();
661
662
663
664

    return(ret);
}

665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
int DARSHAN_DECL(dup)(int oldfd)
{
    int ret;
    struct posix_file_record_ref *rec_ref;
    double tm1, tm2;

    MAP_OR_FAIL(dup);

    tm1 = darshan_core_wtime();
    ret = __real_dup(oldfd);
    tm2 = darshan_core_wtime();

    if(ret >= 0)
    {
        POSIX_PRE_RECORD();
        rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash,
            &oldfd, sizeof(oldfd));
        POSIX_RECORD_REFOPEN(ret, rec_ref, tm1, tm2, POSIX_DUPS);
        POSIX_POST_RECORD();
    }

    return(ret);
}

int DARSHAN_DECL(dup2)(int oldfd, int newfd)
{
    int ret;
    struct posix_file_record_ref *rec_ref;
    double tm1, tm2;

    MAP_OR_FAIL(dup2);

    tm1 = darshan_core_wtime();
    ret = __real_dup2(oldfd, newfd);
    tm2 = darshan_core_wtime();

    if(ret >=0)
    {
        POSIX_PRE_RECORD();
        rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash,
            &oldfd, sizeof(oldfd));
        POSIX_RECORD_REFOPEN(ret, rec_ref, tm1, tm2, POSIX_DUPS);
        POSIX_POST_RECORD();
    }

    return(ret);
}

int DARSHAN_DECL(dup3)(int oldfd, int newfd, int flags)
{
    int ret;
    struct posix_file_record_ref *rec_ref;
    double tm1, tm2;

    MAP_OR_FAIL(dup3);

    tm1 = darshan_core_wtime();
    ret = __real_dup3(oldfd, newfd, flags);
    tm2 = darshan_core_wtime();

    if(ret >=0)
    {
        POSIX_PRE_RECORD();
        rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash,
            &oldfd, sizeof(oldfd));
        POSIX_RECORD_REFOPEN(ret, rec_ref, tm1, tm2, POSIX_DUPS);
        POSIX_POST_RECORD();
    }

    return(ret);
}

737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
int DARSHAN_DECL(fileno)(FILE *stream)
{
    int ret;
    double tm1, tm2;
    darshan_record_id rec_id;
    struct posix_file_record_ref *rec_ref;

    MAP_OR_FAIL(fileno);

    tm1 = darshan_core_wtime();
    ret = __real_fileno(stream);
    tm2 = darshan_core_wtime();

    if(ret >= 0)
    {
        char *rec_name = darshan_stdio_lookup_record_name(stream);
        if(rec_name)
        {
            rec_id = darshan_core_gen_record_id(rec_name);
756
757

            POSIX_PRE_RECORD();
758
759
760
761
762
763
764
765
766
767
768
769
            rec_ref = darshan_lookup_record_ref(posix_runtime->rec_id_hash,
                &rec_id, sizeof(darshan_record_id));
            if(!rec_ref)
                rec_ref = posix_track_new_file_record(rec_id, rec_name);
            POSIX_RECORD_REFOPEN(ret, rec_ref, tm1, tm2, POSIX_FILENOS);
            POSIX_POST_RECORD();
        }
    }

    return(ret);
}

770
771
772
773
774
775
776
777
778
779
780
int DARSHAN_DECL(mkstemp)(char* template)
{
    int ret;
    double tm1, tm2;

    MAP_OR_FAIL(mkstemp);

    tm1 = darshan_core_wtime();
    ret = __real_mkstemp(template);
    tm2 = darshan_core_wtime();

781
    POSIX_PRE_RECORD();
782
    POSIX_RECORD_OPEN(ret, template, 0, tm1, tm2);
783
    POSIX_POST_RECORD();
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798

    return(ret);
}

int DARSHAN_DECL(mkostemp)(char* template, int flags)
{
    int ret;
    double tm1, tm2;

    MAP_OR_FAIL(mkostemp);

    tm1 = darshan_core_wtime();
    ret = __real_mkostemp(template, flags);
    tm2 = darshan_core_wtime();

799
    POSIX_PRE_RECORD();
800
    POSIX_RECORD_OPEN(ret, template, 0, tm1, tm2);
801
    POSIX_POST_RECORD();
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816

    return(ret);
}

int DARSHAN_DECL(mkstemps)(char* template, int suffixlen)
{
    int ret;
    double tm1, tm2;

    MAP_OR_FAIL(mkstemps);

    tm1 = darshan_core_wtime();
    ret = __real_mkstemps(template, suffixlen);
    tm2 = darshan_core_wtime();

817
    POSIX_PRE_RECORD();
818
    POSIX_RECORD_OPEN(ret, template, 0, tm1, tm2);
819
    POSIX_POST_RECORD();
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834

    return(ret);
}

int DARSHAN_DECL(mkostemps)(char* template, int suffixlen, int flags)
{
    int ret;
    double tm1, tm2;

    MAP_OR_FAIL(mkostemps);

    tm1 = darshan_core_wtime();
    ret = __real_mkostemps(template, suffixlen, flags);
    tm2 = darshan_core_wtime();

835
    POSIX_PRE_RECORD();
836
    POSIX_RECORD_OPEN(ret, template, 0, tm1, tm2);
837
    POSIX_POST_RECORD();
838
839
840
841

    return(ret);
}

842
843
844
845
846
847
ssize_t DARSHAN_DECL(read)(int fd, void *buf, size_t count)
{
    ssize_t ret;
    int aligned_flag = 0;
    double tm1, tm2;

Shane Snyder's avatar
Shane Snyder committed
848
    MAP_OR_FAIL(read);
849

850
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
851
852
853
854
855

    tm1 = darshan_core_wtime();
    ret = __real_read(fd, buf, count);
    tm2 = darshan_core_wtime();

856
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
857
    POSIX_RECORD_READ(ret, fd, 0, 0, aligned_flag, tm1, tm2);
858
    POSIX_POST_RECORD();
859
860
861
862
863
864
865
866
867
868
869
870

    return(ret);
}

ssize_t DARSHAN_DECL(write)(int fd, const void *buf, size_t count)
{
    ssize_t ret;
    int aligned_flag = 0;
    double tm1, tm2;

    MAP_OR_FAIL(write);

871
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
872
873
874
875
876

    tm1 = darshan_core_wtime();
    ret = __real_write(fd, buf, count);
    tm2 = darshan_core_wtime();

877
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
878
    POSIX_RECORD_WRITE(ret, fd, 0, 0, aligned_flag, tm1, tm2);
879
    POSIX_POST_RECORD();
880
881
882
883
884
885
886
887
888
889
890
891

    return(ret);
}

ssize_t DARSHAN_DECL(pread)(int fd, void *buf, size_t count, off_t offset)
{
    ssize_t ret;
    int aligned_flag = 0;
    double tm1, tm2;

    MAP_OR_FAIL(pread);

892
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
893
894
895
896
897

    tm1 = darshan_core_wtime();
    ret = __real_pread(fd, buf, count, offset);
    tm2 = darshan_core_wtime();

898
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
899
    POSIX_RECORD_READ(ret, fd, 1, offset, aligned_flag, tm1, tm2);
900
    POSIX_POST_RECORD();
901
902
903
904
905
906
907
908
909
910
911
912

    return(ret);
}

ssize_t DARSHAN_DECL(pwrite)(int fd, const void *buf, size_t count, off_t offset)
{
    ssize_t ret;
    int aligned_flag = 0;
    double tm1, tm2;

    MAP_OR_FAIL(pwrite);

913
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
914
915
916
917
918

    tm1 = darshan_core_wtime();
    ret = __real_pwrite(fd, buf, count, offset);
    tm2 = darshan_core_wtime();

919
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
920
    POSIX_RECORD_WRITE(ret, fd, 1, offset, aligned_flag, tm1, tm2);
921
    POSIX_POST_RECORD();
922
923
924
925
926
927
928
929
930
931
932
933

    return(ret);
}

ssize_t DARSHAN_DECL(pread64)(int fd, void *buf, size_t count, off64_t offset)
{
    ssize_t ret;
    int aligned_flag = 0;
    double tm1, tm2;

    MAP_OR_FAIL(pread64);

934
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
935
936
937
938
939

    tm1 = darshan_core_wtime();
    ret = __real_pread64(fd, buf, count, offset);
    tm2 = darshan_core_wtime();

940
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
941
    POSIX_RECORD_READ(ret, fd, 1, offset, aligned_flag, tm1, tm2);
942
    POSIX_POST_RECORD();
943
944
945
946
947
948
949
950
951
952
953
954

    return(ret);
}

ssize_t DARSHAN_DECL(pwrite64)(int fd, const void *buf, size_t count, off64_t offset)
{
    ssize_t ret;
    int aligned_flag = 0;
    double tm1, tm2;

    MAP_OR_FAIL(pwrite64);

955
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
956
957
958
959
960

    tm1 = darshan_core_wtime();
    ret = __real_pwrite64(fd, buf, count, offset);
    tm2 = darshan_core_wtime();

961
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
962
    POSIX_RECORD_WRITE(ret, fd, 1, offset, aligned_flag, tm1, tm2);
963
    POSIX_POST_RECORD();
964
965
966
967
968
969
970

    return(ret);
}

ssize_t DARSHAN_DECL(readv)(int fd, const struct iovec *iov, int iovcnt)
{
    ssize_t ret;
971
    int aligned_flag = 1;
972
973
974
975
    int i;
    double tm1, tm2;

    MAP_OR_FAIL(readv);
976

977
978
979
980
    for(i=0; i<iovcnt; i++)
    {
        if(((unsigned long)iov[i].iov_base % darshan_mem_alignment) != 0)
            aligned_flag = 0;
981
    }
982
983
984
985
986

    tm1 = darshan_core_wtime();
    ret = __real_readv(fd, iov, iovcnt);
    tm2 = darshan_core_wtime();

987
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
988
    POSIX_RECORD_READ(ret, fd, 0, 0, aligned_flag, tm1, tm2);
989
    POSIX_POST_RECORD();
990
991
992
993
994
995
996

    return(ret);
}

ssize_t DARSHAN_DECL(writev)(int fd, const struct iovec *iov, int iovcnt)
{
    ssize_t ret;
997
    int aligned_flag = 1;
998
999
1000
1001
    int i;
    double tm1, tm2;

    MAP_OR_FAIL(writev);
1002

1003
1004
1005
1006
    for(i=0; i<iovcnt; i++)
    {
        if(((unsigned long)iov[i].iov_base % darshan_mem_alignment) != 0)
            aligned_flag = 0;
1007
    }
1008
1009
1010
1011
1012

    tm1 = darshan_core_wtime();
    ret = __real_writev(fd, iov, iovcnt);
    tm2 = darshan_core_wtime();

1013
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
1014
    POSIX_RECORD_WRITE(ret, fd, 0, 0, aligned_flag, tm1, tm2);
1015
    POSIX_POST_RECORD();
1016
1017
1018
1019
1020
1021
1022

    return(ret);
}

off_t DARSHAN_DECL(lseek)(int fd, off_t offset, int whence)
{
    off_t ret;
1023
    struct posix_file_record_ref *rec_ref;
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
    double tm1, tm2;

    MAP_OR_FAIL(lseek);

    tm1 = darshan_core_wtime();
    ret = __real_lseek(fd, offset, whence);
    tm2 = darshan_core_wtime();

    if(ret >= 0)
    {
1034
        POSIX_PRE_RECORD();
1035
1036
        rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &fd, sizeof(int));
        if(rec_ref)
1037
        {
1038
            rec_ref->offset = ret;
1039
            DARSHAN_TIMER_INC_NO_OVERLAP(
1040
1041
1042
                rec_ref->file_rec->fcounters[POSIX_F_META_TIME],
                tm1, tm2, rec_ref->last_meta_end);
            rec_ref->file_rec->counters[POSIX_SEEKS] += 1;
1043
        }
1044
        POSIX_POST_RECORD();
1045
1046
1047
1048
1049
    }

    return(ret);
}

1050
off64_t DARSHAN_DECL(lseek64)(int fd, off64_t offset, int whence)
1051
1052
{
    off_t ret;
1053
    struct posix_file_record_ref *rec_ref;
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
    double tm1, tm2;

    MAP_OR_FAIL(lseek64);

    tm1 = darshan_core_wtime();
    ret = __real_lseek64(fd, offset, whence);
    tm2 = darshan_core_wtime();

    if(ret >= 0)
    {
1064
        POSIX_PRE_RECORD();
1065
1066
        rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &fd, sizeof(int));
        if(rec_ref)
1067
        {
1068
            rec_ref->offset = ret;
1069
            DARSHAN_TIMER_INC_NO_OVERLAP(
1070
1071
1072
                rec_ref->file_rec->fcounters[POSIX_F_META_TIME],
                tm1, tm2, rec_ref->last_meta_end);
            rec_ref->file_rec->counters[POSIX_SEEKS] += 1;
1073
        }
1074
        POSIX_POST_RECORD();
1075
1076
1077
1078
1079
    }

    return(ret);
}

1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
int DARSHAN_DECL(__xstat)(int vers, const char *path, struct stat *buf)
{
    int ret;
    double tm1, tm2;

    MAP_OR_FAIL(__xstat);

    tm1 = darshan_core_wtime();
    ret = __real___xstat(vers, path, buf);
    tm2 = darshan_core_wtime();

    if(ret < 0 || !S_ISREG(buf->st_mode))
        return(ret);

1094
    POSIX_PRE_RECORD();
1095
    POSIX_LOOKUP_RECORD_STAT(path, buf, tm1, tm2);
1096
    POSIX_POST_RECORD();
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114

    return(ret);
}

int DARSHAN_DECL(__xstat64)(int vers, const char *path, struct stat64 *buf)
{
    int ret;
    double tm1, tm2;

    MAP_OR_FAIL(__xstat64);

    tm1 = darshan_core_wtime();
    ret = __real___xstat64(vers, path, buf);
    tm2 = darshan_core_wtime();

    if(ret < 0 || !S_ISREG(buf->st_mode))
        return(ret);

1115
    POSIX_PRE_RECORD();
1116
    POSIX_LOOKUP_RECORD_STAT(path, buf, tm1, tm2);
1117
    POSIX_POST_RECORD();
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135

    return(ret);
}

int DARSHAN_DECL(__lxstat)(int vers, const char *path, struct stat *buf)
{
    int ret;
    double tm1, tm2;

    MAP_OR_FAIL(__lxstat);

    tm1 = darshan_core_wtime();
    ret = __real___lxstat(vers, path, buf);
    tm2 = darshan_core_wtime();

    if(ret < 0 || !S_ISREG(buf->st_mode))
        return(ret);

1136
    POSIX_PRE_RECORD();
1137
    POSIX_LOOKUP_RECORD_STAT(path, buf, tm1, tm2);
1138
    POSIX_POST_RECORD();
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156

    return(ret);
}

int DARSHAN_DECL(__lxstat64)(int vers, const char *path, struct stat64 *buf)
{
    int ret;
    double tm1, tm2;

    MAP_OR_FAIL(__lxstat64);

    tm1 = darshan_core_wtime();
    ret = __real___lxstat64(vers, path, buf);
    tm2 = darshan_core_wtime();

    if(ret < 0 || !S_ISREG(buf->st_mode))
        return(ret);

1157
    POSIX_PRE_RECORD();
1158
    POSIX_LOOKUP_RECORD_STAT(path, buf, tm1, tm2);
1159
    POSIX_POST_RECORD();
1160
1161
1162
1163
1164
1165
1166

    return(ret);
}

int DARSHAN_DECL(__fxstat)(int vers, int fd, struct stat *buf)
{
    int ret;
1167
    struct posix_file_record_ref *rec_ref;
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
    double tm1, tm2;

    MAP_OR_FAIL(__fxstat);

    tm1 = darshan_core_wtime();
    ret = __real___fxstat(vers, fd, buf);
    tm2 = darshan_core_wtime();

    if(ret < 0 || !S_ISREG(buf->st_mode))
        return(ret);

1179
    POSIX_PRE_RECORD();
1180
1181
    rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &fd, sizeof(int));
    if(rec_ref)
1182
    {
1183
        POSIX_RECORD_STAT(rec_ref, buf, tm1, tm2);
1184
    }
1185
    POSIX_POST_RECORD();
1186
1187
1188
1189
1190
1191
1192

    return(ret);
}

int DARSHAN_DECL(__fxstat64)(int vers, int fd, struct stat64 *buf)
{
    int ret;
1193
    struct posix_file_record_ref *rec_ref;
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
    double tm1, tm2;

    MAP_OR_FAIL(__fxstat64);

    tm1 = darshan_core_wtime();
    ret = __real___fxstat64(vers, fd, buf);
    tm2 = darshan_core_wtime();

    if(ret < 0 || !S_ISREG(buf->st_mode))
        return(ret);

1205
    POSIX_PRE_RECORD();
1206
1207
    rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &fd, sizeof(int));
    if(rec_ref)
1208
    {
1209
        POSIX_RECORD_STAT(rec_ref, buf, tm1, tm2);
1210
    }
1211
    POSIX_POST_RECORD();
1212
1213
1214
1215

    return(ret);
}

1216
#ifdef DARSHAN_WRAP_MMAP
Shane Snyder's avatar
Shane Snyder committed
1217
1218
1219
1220
void* DARSHAN_DECL(mmap)(void *addr, size_t length, int prot, int flags,
    int fd, off_t offset)
{
    void* ret;
1221
    struct posix_file_record_ref *rec_ref;
Shane Snyder's avatar
Shane Snyder committed
1222
1223
1224

    MAP_OR_FAIL(mmap);

1225
1226
1227
1228
1229
1230
1231
1232
    if(fd < 0 || (flags & MAP_ANONYMOUS))
    {
        /* mmap is not associated with a backing file; skip all Darshan
         * characterization attempts.
         */
        return(__real_mmap(addr, length, prot, flags, fd, offset));
    }

Shane Snyder's avatar
Shane Snyder committed
1233
1234
1235
1236
    ret = __real_mmap(addr, length, prot, flags, fd, offset);
    if(ret == MAP_FAILED)
        return(ret);

1237
    POSIX_PRE_RECORD();
1238
1239
    rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &fd, sizeof(int));
    if(rec_ref)
Shane Snyder's avatar
Shane Snyder committed
1240
    {
1241
        rec_ref->file_rec->counters[POSIX_MMAPS] += 1;
Shane Snyder's avatar
Shane Snyder committed
1242
    }
1243
    POSIX_POST_RECORD();
Shane Snyder's avatar
Shane Snyder committed
1244
1245
1246

    return(ret);
}
1247
#endif /* DARSHAN_WRAP_MMAP */
Shane Snyder's avatar
Shane Snyder committed
1248

1249
#ifdef DARSHAN_WRAP_MMAP
Shane Snyder's avatar
Shane Snyder committed
1250
1251
1252
1253
void* DARSHAN_DECL(mmap64)(void *addr, size_t length, int prot, int flags,
    int fd, off64_t offset)
{
    void* ret;
1254
    struct posix_file_record_ref *rec_ref;
Shane Snyder's avatar
Shane Snyder committed
1255
1256
1257

    MAP_OR_FAIL(mmap64);

1258
1259
1260
1261
1262
1263
1264
1265
    if(fd < 0 || (flags & MAP_ANONYMOUS))
    {
        /* mmap is not associated with a backing file; skip all Darshan
         * characterization attempts.
         */
        return(__real_mmap64(addr, length, prot, flags, fd, offset));
    }

Shane Snyder's avatar
Shane Snyder committed
1266
1267
1268
1269
    ret = __real_mmap64(addr, length, prot, flags, fd, offset);
    if(ret == MAP_FAILED)
        return(ret);

1270
    POSIX_PRE_RECORD();
1271
1272
    rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &fd, sizeof(int));
    if(rec_ref)
Shane Snyder's avatar
Shane Snyder committed
1273
    {
1274
        rec_ref->file_rec->counters[POSIX_MMAPS] += 1;
Shane Snyder's avatar
Shane Snyder committed
1275
    }
1276
    POSIX_POST_RECORD();
Shane Snyder's avatar
Shane Snyder committed
1277
1278
1279

    return(ret);
}
1280
#endif /* DARSHAN_WRAP_MMAP */
Shane Snyder's avatar
Shane Snyder committed
1281

1282
1283
1284
int DARSHAN_DECL(fsync)(int fd)
{
    int ret;
1285
    struct posix_file_record_ref *rec_ref;
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
    double tm1, tm2;

    MAP_OR_FAIL(fsync);

    tm1 = darshan_core_wtime();
    ret = __real_fsync(fd);
    tm2 = darshan_core_wtime();

    if(ret < 0)
        return(ret);

1297
    POSIX_PRE_RECORD();
1298
1299
    rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &fd, sizeof(int));
    if(rec_ref)
1300
    {
1301
        DARSHAN_TIMER_INC_NO_OVERLAP(