darshan-posix.c 65.1 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

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

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

41

42
43
DARSHAN_FORWARD_DECL(open, int, (const char *path, int flags, ...));
DARSHAN_FORWARD_DECL(open64, int, (const char *path, int flags, ...));
44
DARSHAN_FORWARD_DECL(__open_2, int, (const char *path, int oflag));
45
46
DARSHAN_FORWARD_DECL(creat, int, (const char* path, mode_t mode));
DARSHAN_FORWARD_DECL(creat64, int, (const char* path, mode_t mode));
47
48
49
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));
50
DARSHAN_FORWARD_DECL(fileno, int, (FILE *stream));
51
52
53
54
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));
55
56
57
58
59
60
61
62
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));
63
64
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));
65
66
67
68
69
70
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));
71
#ifdef DARSHAN_WRAP_MMAP
Shane Snyder's avatar
Shane Snyder committed
72
73
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));
74
#endif /* DARSHAN_WRAP_MMAP */
75
76
DARSHAN_FORWARD_DECL(fsync, int, (int fd));
DARSHAN_FORWARD_DECL(fdatasync, int, (int fd));
77
DARSHAN_FORWARD_DECL(close, int, (int fd));
78
79
80
81
82
83
84
85
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));
86
DARSHAN_FORWARD_DECL(rename, int, (const char *oldpath, const char *newpath));
87

88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
/* 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)
106
107
 * 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,
108
109
 * there could be multiple open file descriptors that index it.
 */
110
struct posix_file_record_ref
111
{
112
    struct darshan_posix_file *file_rec;
113
114
115
    int64_t offset;
    int64_t last_byte_read;
    int64_t last_byte_written;
Shane Snyder's avatar
Shane Snyder committed
116
    enum darshan_io_type last_io_type;
117
118
119
    double last_meta_end;
    double last_read_end;
    double last_write_end;
120
    void *access_root;
121
    int access_count;
122
    void *stride_root;
123
    int stride_count;
124
    struct posix_aio_tracker* aio_list;
125
    int fs_type; /* same as darshan_fs_info->fs_type */
126
127
};

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

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

147
148
149
static void posix_runtime_initialize(
    void);
static struct posix_file_record_ref *posix_track_new_file_record(
150
    darshan_record_id rec_id, const char *path);
151
152
153
154
static void posix_aio_tracker_add(
    int fd, void *aiocbp);
static struct posix_aio_tracker* posix_aio_tracker_del(
    int fd, void *aiocbp);
155
156
static void posix_finalize_file_records(
    void *rec_ref_p);
157
158
159
160
161
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);
162
static void posix_cleanup_runtime(
163
    void);
164
165

static void posix_shutdown(
166
    MPI_Comm mod_comm, darshan_record_id *shared_recs,
167
    int shared_rec_count, void **posix_buf, int *posix_buf_sz);
168

169
170
/* extern function def for querying record name from a STDIO stream */
extern char *darshan_stdio_lookup_record_name(FILE *stream);
171

172
173
174
175
176
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;

177
178
179
#define POSIX_LOCK() pthread_mutex_lock(&posix_runtime_mutex)
#define POSIX_UNLOCK() pthread_mutex_unlock(&posix_runtime_mutex)

180
181
#define POSIX_PRE_RECORD() do { \
    POSIX_LOCK(); \
182
    if(!darshan_core_disabled_instrumentation()) { \
183
184
185
        if(!posix_runtime) { \
            posix_runtime_initialize(); \
        } \
186
        if(posix_runtime) break; \
187
    } \
188
189
    POSIX_UNLOCK(); \
    return(ret); \
190
191
192
193
194
} while(0)

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

196
197
198
199
#define POSIX_RECORD_OPEN(__ret, __path, __mode, __tm1, __tm2) do { \
    darshan_record_id __rec_id; \
    struct posix_file_record_ref *__rec_ref; \
    char *__newpath; \
200
    if(__ret < 0) break; \
201
202
203
204
    __newpath = darshan_clean_file_path(__path); \
    if(!__newpath) __newpath = (char *)__path; \
    if(darshan_core_excluded_path(__newpath)) { \
        if(__newpath != __path) free(__newpath); \
205
206
        break; \
    } \
207
208
209
210
211
    __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); \
212
        break; \
213
    } \
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
    _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); \
240
241
} while(0)

242
#define POSIX_RECORD_READ(__ret, __fd, __pread_flag, __pread_offset, __aligned, __tm1, __tm2) do { \
243
    struct posix_file_record_ref* rec_ref; \
244
    size_t stride; \
245
    int64_t this_offset; \
246
    int64_t file_alignment; \
247
248
    double __elapsed = __tm2-__tm1; \
    if(__ret < 0) break; \
249
250
    rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &(__fd), sizeof(int)); \
    if(!rec_ref) break; \
251
    if(__pread_flag) \
252
253
        this_offset = __pread_offset; \
    else \
254
        this_offset = rec_ref->offset; \
255
    /* DXT to record detailed read tracing information */ \
Shane Snyder's avatar
Shane Snyder committed
256
    dxt_posix_read(rec_ref->file_rec->base_rec.id, this_offset, __ret, __tm1, __tm2); \
257
258
259
260
261
262
263
    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; \
264
    else \
265
        stride = 0; \
266
267
268
269
270
    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; \
271
    rec_ref->file_rec->counters[POSIX_READS] += 1; \
272
273
274
275
276
277
278
    DARSHAN_BUCKET_INC(&(rec_ref->file_rec->counters[POSIX_SIZE_READ_0_100]), __ret); \
    darshan_common_val_counter(&rec_ref->access_root, &rec_ref->access_count, __ret, \
        &(rec_ref->file_rec->counters[POSIX_ACCESS1_ACCESS]), \
        &(rec_ref->file_rec->counters[POSIX_ACCESS1_COUNT])); \
    darshan_common_val_counter(&rec_ref->stride_root, &rec_ref->stride_count, stride, \
        &(rec_ref->file_rec->counters[POSIX_STRIDE1_STRIDE]), \
        &(rec_ref->file_rec->counters[POSIX_STRIDE1_COUNT])); \
279
    if(!__aligned) \
280
281
        rec_ref->file_rec->counters[POSIX_MEM_NOT_ALIGNED] += 1; \
    file_alignment = rec_ref->file_rec->counters[POSIX_FILE_ALIGNMENT]; \
282
    if(file_alignment > 0 && (this_offset % file_alignment) != 0) \
283
284
285
286
        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; \
287
288
    if(rec_ref->file_rec->fcounters[POSIX_F_READ_START_TIMESTAMP] == 0 || \
     rec_ref->file_rec->fcounters[POSIX_F_READ_START_TIMESTAMP] > __tm1) \
289
290
291
292
293
294
295
        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); \
296
297
} while(0)

298
#define POSIX_RECORD_WRITE(__ret, __fd, __pwrite_flag, __pwrite_offset, __aligned, __tm1, __tm2) do { \
299
    struct posix_file_record_ref* rec_ref; \
300
    size_t stride; \
301
    int64_t this_offset; \
302
    int64_t file_alignment; \
303
304
    double __elapsed = __tm2-__tm1; \
    if(__ret < 0) break; \
305
306
    rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &__fd, sizeof(int)); \
    if(!rec_ref) break; \
307
    if(__pwrite_flag) \
308
309
        this_offset = __pwrite_offset; \
    else \
310
        this_offset = rec_ref->offset; \
311
    /* DXT to record detailed write tracing information */ \
Shane Snyder's avatar
Shane Snyder committed
312
    dxt_posix_write(rec_ref->file_rec->base_rec.id, this_offset, __ret, __tm1, __tm2); \
313
314
315
316
317
318
319
    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; \
320
    else \
321
        stride = 0; \
322
323
324
325
326
    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; \
327
    rec_ref->file_rec->counters[POSIX_WRITES] += 1; \
328
329
330
331
332
333
334
    DARSHAN_BUCKET_INC(&(rec_ref->file_rec->counters[POSIX_SIZE_WRITE_0_100]), __ret); \
    darshan_common_val_counter(&rec_ref->access_root, &rec_ref->access_count, __ret, \
        &(rec_ref->file_rec->counters[POSIX_ACCESS1_ACCESS]), \
        &(rec_ref->file_rec->counters[POSIX_ACCESS1_COUNT])); \
    darshan_common_val_counter(&rec_ref->stride_root, &rec_ref->stride_count, stride, \
        &(rec_ref->file_rec->counters[POSIX_STRIDE1_STRIDE]), \
        &(rec_ref->file_rec->counters[POSIX_STRIDE1_COUNT])); \
335
    if(!__aligned) \
336
337
        rec_ref->file_rec->counters[POSIX_MEM_NOT_ALIGNED] += 1; \
    file_alignment = rec_ref->file_rec->counters[POSIX_FILE_ALIGNMENT]; \
338
    if(file_alignment > 0 && (this_offset % file_alignment) != 0) \
339
340
341
342
        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; \
343
344
    if(rec_ref->file_rec->fcounters[POSIX_F_WRITE_START_TIMESTAMP] == 0 || \
     rec_ref->file_rec->fcounters[POSIX_F_WRITE_START_TIMESTAMP] > __tm1) \
345
346
347
348
349
350
351
        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); \
352
} while(0)
353

354
#define POSIX_LOOKUP_RECORD_STAT(__path, __statbuf, __tm1, __tm2) do { \
355
    darshan_record_id rec_id; \
356
357
358
359
360
361
    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; \
362
    } \
363
364
    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)); \
365
    if(!rec_ref) rec_ref = posix_track_new_file_record(rec_id, newpath); \
366
    if(newpath != __path) free(newpath); \
367
368
    if(rec_ref) { \
        POSIX_RECORD_STAT(rec_ref, __statbuf, __tm1, __tm2); \
369
370
371
    } \
} while(0)

372
373
374
375
#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); \
376
377
} while(0)

378

379
380
381
382
/**********************************************************
 *      Wrappers for POSIX I/O functions of interest      * 
 **********************************************************/

383
int DARSHAN_DECL(open)(const char *path, int flags, ...)
384
385
386
387
388
{
    int mode = 0;
    int ret;
    double tm1, tm2;

389
390
    MAP_OR_FAIL(open);

391
    if(flags & O_CREAT) 
392
393
394
395
396
397
    {
        va_list arg;
        va_start(arg, flags);
        mode = va_arg(arg, int);
        va_end(arg);

398
        tm1 = darshan_core_wtime();
399
        ret = __real_open(path, flags, mode);
400
        tm2 = darshan_core_wtime();
401
402
403
    }
    else
    {
404
        tm1 = darshan_core_wtime();
405
        ret = __real_open(path, flags);
406
        tm2 = darshan_core_wtime();
407
408
    }

409
    POSIX_PRE_RECORD();
410
    POSIX_RECORD_OPEN(ret, path, mode, tm1, tm2);
411
    POSIX_POST_RECORD();
412
413
414
415

    return(ret);
}

416
417
418
419
420
421
422
423
424
425
426
427
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();
428
    POSIX_RECORD_OPEN(ret, path, 0, tm1, tm2);
429
430
431
432
433
    POSIX_POST_RECORD();

    return(ret);
}

Shane Snyder's avatar
Shane Snyder committed
434
435
436
437
438
439
int DARSHAN_DECL(open64)(const char *path, int flags, ...)
{
    int mode = 0;
    int ret;
    double tm1, tm2;

440
    MAP_OR_FAIL(open64);
Shane Snyder's avatar
Shane Snyder committed
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459

    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();
    }

460
    POSIX_PRE_RECORD();
461
    POSIX_RECORD_OPEN(ret, path, mode, tm1, tm2);
462
    POSIX_POST_RECORD();
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477

    return(ret);
}

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();

478
    POSIX_PRE_RECORD();
479
    POSIX_RECORD_OPEN(ret, path, mode, tm1, tm2);
480
    POSIX_POST_RECORD();
481
482
483
484
485
486
487
488
489
490

    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
491

492
493
494
495
    tm1 = darshan_core_wtime();
    ret = __real_creat64(path, mode);
    tm2 = darshan_core_wtime();

496
    POSIX_PRE_RECORD();
497
    POSIX_RECORD_OPEN(ret, path, mode, tm1, tm2);
498
    POSIX_POST_RECORD();
499
500
501
502

    return(ret);
}

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
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);
}

575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
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);
594
595

            POSIX_PRE_RECORD();
596
597
598
599
600
601
602
603
604
605
606
607
            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);
}

608
609
610
611
612
613
614
615
616
617
618
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();

619
    POSIX_PRE_RECORD();
620
    POSIX_RECORD_OPEN(ret, template, 0, tm1, tm2);
621
    POSIX_POST_RECORD();
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636

    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();

637
    POSIX_PRE_RECORD();
638
    POSIX_RECORD_OPEN(ret, template, 0, tm1, tm2);
639
    POSIX_POST_RECORD();
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654

    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();

655
    POSIX_PRE_RECORD();
656
    POSIX_RECORD_OPEN(ret, template, 0, tm1, tm2);
657
    POSIX_POST_RECORD();
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672

    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();

673
    POSIX_PRE_RECORD();
674
    POSIX_RECORD_OPEN(ret, template, 0, tm1, tm2);
675
    POSIX_POST_RECORD();
676
677
678
679

    return(ret);
}

680
681
682
683
684
685
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
686
    MAP_OR_FAIL(read);
687

688
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
689
690
691
692
693

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

694
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
695
    POSIX_RECORD_READ(ret, fd, 0, 0, aligned_flag, tm1, tm2);
696
    POSIX_POST_RECORD();
697
698
699
700
701
702
703
704
705
706
707
708

    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);

709
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
710
711
712
713
714

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

715
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
716
    POSIX_RECORD_WRITE(ret, fd, 0, 0, aligned_flag, tm1, tm2);
717
    POSIX_POST_RECORD();
718
719
720
721
722
723
724
725
726
727
728
729

    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);

730
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
731
732
733
734
735

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

736
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
737
    POSIX_RECORD_READ(ret, fd, 1, offset, aligned_flag, tm1, tm2);
738
    POSIX_POST_RECORD();
739
740
741
742
743
744
745
746
747
748
749
750

    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);

751
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
752
753
754
755
756

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

757
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
758
    POSIX_RECORD_WRITE(ret, fd, 1, offset, aligned_flag, tm1, tm2);
759
    POSIX_POST_RECORD();
760
761
762
763
764
765
766
767
768
769
770
771

    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);

772
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
773
774
775
776
777

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

778
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
779
    POSIX_RECORD_READ(ret, fd, 1, offset, aligned_flag, tm1, tm2);
780
    POSIX_POST_RECORD();
781
782
783
784
785
786
787
788
789
790
791
792

    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);

793
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
794
795
796
797
798

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

799
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
800
    POSIX_RECORD_WRITE(ret, fd, 1, offset, aligned_flag, tm1, tm2);
801
    POSIX_POST_RECORD();
802
803
804
805
806
807
808

    return(ret);
}

ssize_t DARSHAN_DECL(readv)(int fd, const struct iovec *iov, int iovcnt)
{
    ssize_t ret;
809
    int aligned_flag = 1;
810
811
812
813
    int i;
    double tm1, tm2;

    MAP_OR_FAIL(readv);
814

815
816
817
818
    for(i=0; i<iovcnt; i++)
    {
        if(((unsigned long)iov[i].iov_base % darshan_mem_alignment) != 0)
            aligned_flag = 0;
819
    }
820
821
822
823
824

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

825
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
826
    POSIX_RECORD_READ(ret, fd, 0, 0, aligned_flag, tm1, tm2);
827
    POSIX_POST_RECORD();
828
829
830
831
832
833
834

    return(ret);
}

ssize_t DARSHAN_DECL(writev)(int fd, const struct iovec *iov, int iovcnt)
{
    ssize_t ret;
835
    int aligned_flag = 1;
836
837
838
839
    int i;
    double tm1, tm2;

    MAP_OR_FAIL(writev);
840

841
842
843
844
    for(i=0; i<iovcnt; i++)
    {
        if(((unsigned long)iov[i].iov_base % darshan_mem_alignment) != 0)
            aligned_flag = 0;
845
    }
846
847
848
849
850

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

851
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
852
    POSIX_RECORD_WRITE(ret, fd, 0, 0, aligned_flag, tm1, tm2);
853
    POSIX_POST_RECORD();
854
855
856
857
858
859
860

    return(ret);
}

off_t DARSHAN_DECL(lseek)(int fd, off_t offset, int whence)
{
    off_t ret;
861
    struct posix_file_record_ref *rec_ref;
862
863
864
865
866
867
868
869
870
871
    double tm1, tm2;

    MAP_OR_FAIL(lseek);

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

    if(ret >= 0)
    {
872
        POSIX_PRE_RECORD();
873
874
        rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &fd, sizeof(int));
        if(rec_ref)
875
        {
876
            rec_ref->offset = ret;
877
            DARSHAN_TIMER_INC_NO_OVERLAP(
878
879
880
                rec_ref->file_rec->fcounters[POSIX_F_META_TIME],
                tm1, tm2, rec_ref->last_meta_end);
            rec_ref->file_rec->counters[POSIX_SEEKS] += 1;
881
        }
882
        POSIX_POST_RECORD();
883
884
885
886
887
    }

    return(ret);
}

888
off64_t DARSHAN_DECL(lseek64)(int fd, off64_t offset, int whence)
889
890
{
    off_t ret;
891
    struct posix_file_record_ref *rec_ref;
892
893
894
895
896
897
898
899
900
901
    double tm1, tm2;

    MAP_OR_FAIL(lseek64);

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

    if(ret >= 0)
    {
902
        POSIX_PRE_RECORD();
903
904
        rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &fd, sizeof(int));
        if(rec_ref)
905
        {
906
            rec_ref->offset = ret;
907
            DARSHAN_TIMER_INC_NO_OVERLAP(
908
909
910
                rec_ref->file_rec->fcounters[POSIX_F_META_TIME],
                tm1, tm2, rec_ref->last_meta_end);
            rec_ref->file_rec->counters[POSIX_SEEKS] += 1;
911
        }
912
        POSIX_POST_RECORD();
913
914
915
916
917
    }

    return(ret);
}

918
919
920
921
922
923
924
925
926
927
928
929
930
931
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);

932
    POSIX_PRE_RECORD();
933
    POSIX_LOOKUP_RECORD_STAT(path, buf, tm1, tm2);
934
    POSIX_POST_RECORD();
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952

    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);

953
    POSIX_PRE_RECORD();
954
    POSIX_LOOKUP_RECORD_STAT(path, buf, tm1, tm2);
955
    POSIX_POST_RECORD();
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973

    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);

974
    POSIX_PRE_RECORD();
975
    POSIX_LOOKUP_RECORD_STAT(path, buf, tm1, tm2);
976
    POSIX_POST_RECORD();
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994

    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);

995
    POSIX_PRE_RECORD();
996
    POSIX_LOOKUP_RECORD_STAT(path, buf, tm1, tm2);
997
    POSIX_POST_RECORD();
998
999
1000
1001
1002
1003
1004

    return(ret);
}

int DARSHAN_DECL(__fxstat)(int vers, int fd, struct stat *buf)
{
    int ret;
1005
    struct posix_file_record_ref *rec_ref;
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
    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);

1017
    POSIX_PRE_RECORD();
1018
1019
    rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &fd, sizeof(int));
    if(rec_ref)
1020
    {
1021
        POSIX_RECORD_STAT(rec_ref, buf, tm1, tm2);
1022
    }
1023
    POSIX_POST_RECORD();
1024
1025
1026
1027
1028
1029
1030

    return(ret);
}

int DARSHAN_DECL(__fxstat64)(int vers, int fd, struct stat64 *buf)
{
    int ret;
1031
    struct posix_file_record_ref *rec_ref;
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
    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);

1043
    POSIX_PRE_RECORD();
1044
1045
    rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &fd, sizeof(int));
    if(rec_ref)
1046
    {
1047
        POSIX_RECORD_STAT(rec_ref, buf, tm1, tm2);
1048
    }
1049
    POSIX_POST_RECORD();
1050
1051
1052
1053

    return(ret);
}

1054
#ifdef DARSHAN_WRAP_MMAP
Shane Snyder's avatar
Shane Snyder committed
1055
1056
1057
1058
void* DARSHAN_DECL(mmap)(void *addr, size_t length, int prot, int flags,
    int fd, off_t offset)
{
    void* ret;
1059
    struct posix_file_record_ref *rec_ref;
Shane Snyder's avatar
Shane Snyder committed
1060
1061
1062

    MAP_OR_FAIL(mmap);

1063
1064
1065
1066
1067
1068
1069
1070
    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
1071
1072
1073
1074
    ret = __real_mmap(addr, length, prot, flags, fd, offset);
    if(ret == MAP_FAILED)
        return(ret);

1075
    POSIX_PRE_RECORD();
1076
1077
    rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &fd, sizeof(int));
    if(rec_ref)
Shane Snyder's avatar
Shane Snyder committed
1078
    {
1079
        rec_ref->file_rec->counters[POSIX_MMAPS] += 1;
Shane Snyder's avatar
Shane Snyder committed
1080
    }
1081
    POSIX_POST_RECORD();
Shane Snyder's avatar
Shane Snyder committed
1082
1083
1084

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

1087
#ifdef DARSHAN_WRAP_MMAP
Shane Snyder's avatar
Shane Snyder committed
1088
1089
1090
1091
void* DARSHAN_DECL(mmap64)(void *addr, size_t length, int prot, int flags,
    int fd, off64_t offset)
{
    void* ret;
1092
    struct posix_file_record_ref *rec_ref;
Shane Snyder's avatar
Shane Snyder committed
1093
1094
1095

    MAP_OR_FAIL(mmap64);

1096
1097
1098
1099
1100
1101
1102
1103
    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
1104
1105
1106
1107
    ret = __real_mmap64(addr, length, prot, flags, fd, offset);
    if(ret == MAP_FAILED)
        return(ret);

1108
    POSIX_PRE_RECORD();
1109
1110
    rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &fd, sizeof(int));
    if(rec_ref)
Shane Snyder's avatar
Shane Snyder committed
1111
    {
1112
        rec_ref->file_rec->counters[POSIX_MMAPS] += 1;
Shane Snyder's avatar
Shane Snyder committed
1113
    }
1114
    POSIX_POST_RECORD();
Shane Snyder's avatar
Shane Snyder committed
1115
1116
1117

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

1120
1121
1122
int DARSHAN_DECL(fsync)(int fd)
{
    int ret;
1123
    struct posix_file_record_ref *rec_ref;
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
    double tm1, tm2;

    MAP_OR_FAIL(fsync);

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

    if(ret < 0)
        return(ret);

1135
    POSIX_PRE_RECORD();
1136
1137
    rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &fd, sizeof(int));
    if(rec_ref)
1138
    {
1139
        DARSHAN_TIMER_INC_NO_OVERLAP(
1140
1141
1142
            rec_ref->file_rec->fcounters[POSIX_F_WRITE_TIME],
            tm1, tm2, rec_ref->last_write_end);
        rec_ref->file_rec->counters[POSIX_FSYNCS] += 1;
1143
    }
1144
    POSIX_POST_RECORD();
1145
1146
1147
1148
1149
1150
1151

    return(ret);
}

int DARSHAN_DECL(fdatasync)(int fd)
{
    int ret;
1152
    struct posix_file_record_ref *rec_ref;
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
    double tm1, tm2;

    MAP_OR_FAIL(fdatasync);

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

    if(ret < 0)
        return(ret);

1164
    POSIX_PRE_RECORD();
1165
1166
    rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &fd, sizeof(int));
    if(rec_ref)
1167
    {
1168
        DARSHAN_TIMER_INC_NO_OVERLAP(
1169
1170
1171
            rec_ref->file_rec->fcounters[POSIX_F_WRITE_TIME],
            tm1, tm2, rec_ref->last_write_end);
        rec_ref->file_rec->counters[POSIX_FDSYNCS] += 1;
1172
    }
1173
    POSIX_POST_RECORD();
1174
1175
1176
1177

    return(ret);
}

1178
1179
1180
int DARSHAN_DECL(close)(int fd)
{
    int ret;
1181
1182
    struct posix_file_record_ref *rec_ref;
    double tm1, tm2;
1183
1184
1185
1186
1187
1188
1189

    MAP_OR_FAIL(close);

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

1190
    POSIX_PRE_RECORD();
1191
1192
    rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &fd, sizeof(int));
    if(rec_ref)
Shane Snyder's avatar
Shane Snyder committed
1193
    {
1194
1195
        rec_ref->last_byte_written = 0;
        rec_ref->last_byte_read = 0;
1196
1197
1198
1199
        if(rec_ref->file_rec->fcounters[POSIX_F_CLOSE_START_TIMESTAMP] == 0 ||
         rec_ref->file_rec->fcounters[POSIX_F_CLOSE_START_TIMESTAMP] > tm1)
           rec_ref->file_rec->fcounters[POSIX_F_CLOSE_START_TIMESTAMP] = tm1;
        rec_ref->file_rec->fcounters[POSIX_F_CLOSE_END_TIMESTAMP] = tm2;
1200
        DARSHAN_TIMER_INC_NO_OVERLAP(
1201
1202
1203
            rec_ref->file_rec->fcounters[POSIX_F_META_TIME],
            tm1, tm2, rec_ref->last_meta_end);
        darshan_delete_record_ref(&(posix_runtime->fd_hash), &fd, sizeof(int));
Shane Snyder's avatar
Shane Snyder committed
1204
    }
1205
    POSIX_POST_RECORD();
1206
1207
1208
1209

    return(ret);
}

1210
1211
1212
1213
1214
1215
1216
1217
1218
int DARSHAN_DECL(aio_read)(struct aiocb *aiocbp)
{
    int ret;

    MAP_OR_FAIL(aio_read);

    ret = __real_aio_read(aiocbp);
    if(ret == 0)
    {
1219
        POSIX_PRE_RECORD();
1220
        posix_aio_tracker_add(aiocbp->aio_fildes, aiocbp);
1221
        POSIX_POST_RECORD();
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
    }

    return(ret);
}

int DARSHAN_DECL(aio_write)(struct aiocb *aiocbp)