darshan-posix.c 57.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"
32

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

40

41
42
DARSHAN_FORWARD_DECL(open, int, (const char *path, int flags, ...));
DARSHAN_FORWARD_DECL(open64, int, (const char *path, int flags, ...));
43
44
DARSHAN_FORWARD_DECL(creat, int, (const char* path, mode_t mode));
DARSHAN_FORWARD_DECL(creat64, int, (const char* path, mode_t mode));
45
46
47
48
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));
49
50
51
52
53
54
55
56
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));
57
58
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));
59
60
61
62
63
64
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));
Shane Snyder's avatar
Shane Snyder committed
65
66
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));
67
68
DARSHAN_FORWARD_DECL(fsync, int, (int fd));
DARSHAN_FORWARD_DECL(fdatasync, int, (int fd));
69
DARSHAN_FORWARD_DECL(close, int, (int fd));
70
71
72
73
74
75
76
77
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));
78

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

119
120
121
122
/* The posix_runtime structure maintains necessary state for storing
 * POSIX file records and for coordinating with darshan-core at 
 * shutdown time.
 */
123
124
struct posix_runtime
{
125
126
127
    void *rec_id_hash;
    void *fd_hash;
    int file_rec_count;
128
129
};

130
131
132
133
134
/* struct to track information about aio operations in flight */
struct posix_aio_tracker
{
    double tm1;
    void *aiocbp;
135
    struct posix_aio_tracker *next;
136
};
137

138
139
140
static void posix_runtime_initialize(
    void);
static struct posix_file_record_ref *posix_track_new_file_record(
141
    darshan_record_id rec_id, const char *path);
142
143
144
145
static void posix_aio_tracker_add(
    int fd, void *aiocbp);
static struct posix_aio_tracker* posix_aio_tracker_del(
    int fd, void *aiocbp);
146
147
static void posix_finalize_file_records(
    void *rec_ref_p);
148
149
150
151
152
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);
153
static void posix_cleanup_runtime(
154
    void);
155
156

static void posix_shutdown(
157
    MPI_Comm mod_comm, darshan_record_id *shared_recs,
158
    int shared_rec_count, void **posix_buf, int *posix_buf_sz);
159
160
161
162
163
164
165

static struct posix_runtime *posix_runtime = NULL;
static pthread_mutex_t posix_runtime_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
static int instrumentation_disabled = 0;
static int my_rank = -1;
static int darshan_mem_alignment = 1;

166
167
168
#define POSIX_LOCK() pthread_mutex_lock(&posix_runtime_mutex)
#define POSIX_UNLOCK() pthread_mutex_unlock(&posix_runtime_mutex)

169
170
171
172
173
174
175
176
177
178
179
180
#define POSIX_PRE_RECORD() do { \
    POSIX_LOCK(); \
    if(!posix_runtime && !instrumentation_disabled) posix_runtime_initialize(); \
    if(!posix_runtime) { \
        POSIX_UNLOCK(); \
        return(ret); \
    } \
} while(0)

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

Philip Carns's avatar
Philip Carns committed
182
#define POSIX_RECORD_OPEN(__ret, __path, __mode, __tm1, __tm2) do { \
183
    darshan_record_id rec_id; \
184
185
    struct posix_file_record_ref *rec_ref; \
    char *newpath; \
186
    if(__ret < 0) break; \
187
188
189
190
191
192
193
    newpath = darshan_clean_file_path(__path); \
    if(!newpath) newpath = (char *)__path; \
    if(darshan_core_excluded_path(newpath)) { \
        if(newpath != __path) free(newpath); \
        break; \
    } \
    rec_id = darshan_core_gen_record_id(newpath); \
194
    rec_ref = darshan_lookup_record_ref(posix_runtime->rec_id_hash, &rec_id, sizeof(darshan_record_id)); \
195
    if(!rec_ref) rec_ref = posix_track_new_file_record(rec_id, newpath); \
196
    if(!rec_ref) { \
197
198
        if(newpath != __path) free(newpath); \
        break; \
199
    } \
200
    if(__mode) \
201
202
203
204
        rec_ref->file_rec->counters[POSIX_MODE] = __mode; \
    rec_ref->offset = 0; \
    rec_ref->last_byte_written = 0; \
    rec_ref->last_byte_read = 0; \
205
    rec_ref->file_rec->counters[POSIX_OPENS] += 1; \
206
207
    if(rec_ref->file_rec->fcounters[POSIX_F_OPEN_TIMESTAMP] == 0 || \
     rec_ref->file_rec->fcounters[POSIX_F_OPEN_TIMESTAMP] > __tm1) \
208
209
210
        rec_ref->file_rec->fcounters[POSIX_F_OPEN_TIMESTAMP] = __tm1; \
    DARSHAN_TIMER_INC_NO_OVERLAP(rec_ref->file_rec->fcounters[POSIX_F_META_TIME], \
        __tm1, __tm2, rec_ref->last_meta_end); \
211
    darshan_add_record_ref(&(posix_runtime->fd_hash), &__ret, sizeof(int), rec_ref); \
212
    darshan_instrument_fs_data(rec_ref->fs_type, newpath, __ret); \
213
    if(newpath != __path) free(newpath); \
214
215
} while(0)

216
#define POSIX_RECORD_READ(__ret, __fd, __pread_flag, __pread_offset, __aligned, __tm1, __tm2) do { \
217
    struct posix_file_record_ref* rec_ref; \
218
    size_t stride; \
219
    int64_t this_offset; \
220
    int64_t file_alignment; \
221
222
    double __elapsed = __tm2-__tm1; \
    if(__ret < 0) break; \
223
224
    rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &(__fd), sizeof(int)); \
    if(!rec_ref) break; \
225
    if(__pread_flag) \
226
227
        this_offset = __pread_offset; \
    else \
228
229
230
231
232
233
234
235
        this_offset = rec_ref->offset; \
    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; \
236
    else \
237
        stride = 0; \
238
239
240
241
242
    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; \
243
    rec_ref->file_rec->counters[POSIX_READS] += 1; \
244
245
246
247
248
249
250
    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])); \
251
    if(!__aligned) \
252
253
        rec_ref->file_rec->counters[POSIX_MEM_NOT_ALIGNED] += 1; \
    file_alignment = rec_ref->file_rec->counters[POSIX_FILE_ALIGNMENT]; \
254
    if(file_alignment > 0 && (this_offset % file_alignment) != 0) \
255
256
257
258
        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; \
259
260
    if(rec_ref->file_rec->fcounters[POSIX_F_READ_START_TIMESTAMP] == 0 || \
     rec_ref->file_rec->fcounters[POSIX_F_READ_START_TIMESTAMP] > __tm1) \
261
262
263
264
265
266
267
        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); \
268
269
} while(0)

270
#define POSIX_RECORD_WRITE(__ret, __fd, __pwrite_flag, __pwrite_offset, __aligned, __tm1, __tm2) do { \
271
    struct posix_file_record_ref* rec_ref; \
272
    size_t stride; \
273
    int64_t this_offset; \
274
    int64_t file_alignment; \
275
276
    double __elapsed = __tm2-__tm1; \
    if(__ret < 0) break; \
277
278
    rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &__fd, sizeof(int)); \
    if(!rec_ref) break; \
279
    if(__pwrite_flag) \
280
281
        this_offset = __pwrite_offset; \
    else \
282
283
284
285
286
287
288
289
        this_offset = rec_ref->offset; \
    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; \
290
    else \
291
        stride = 0; \
292
293
294
295
296
    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; \
297
    rec_ref->file_rec->counters[POSIX_WRITES] += 1; \
298
299
300
301
302
303
304
    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])); \
305
    if(!__aligned) \
306
307
        rec_ref->file_rec->counters[POSIX_MEM_NOT_ALIGNED] += 1; \
    file_alignment = rec_ref->file_rec->counters[POSIX_FILE_ALIGNMENT]; \
308
    if(file_alignment > 0 && (this_offset % file_alignment) != 0) \
309
310
311
312
        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; \
313
314
    if(rec_ref->file_rec->fcounters[POSIX_F_WRITE_START_TIMESTAMP] == 0 || \
     rec_ref->file_rec->fcounters[POSIX_F_WRITE_START_TIMESTAMP] > __tm1) \
315
316
317
318
319
320
321
        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); \
322
} while(0)
323

324
#define POSIX_LOOKUP_RECORD_STAT(__path, __statbuf, __tm1, __tm2) do { \
325
    darshan_record_id rec_id; \
326
327
328
329
330
331
    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; \
332
    } \
333
334
    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)); \
335
    if(!rec_ref) rec_ref = posix_track_new_file_record(rec_id, newpath); \
336
    if(newpath != __path) free(newpath); \
337
338
    if(rec_ref) { \
        POSIX_RECORD_STAT(rec_ref, __statbuf, __tm1, __tm2); \
339
340
341
    } \
} while(0)

342
343
344
345
#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); \
346
347
} while(0)

348

349
350
351
352
/**********************************************************
 *      Wrappers for POSIX I/O functions of interest      * 
 **********************************************************/

353
int DARSHAN_DECL(open)(const char *path, int flags, ...)
354
355
356
357
358
{
    int mode = 0;
    int ret;
    double tm1, tm2;

359
360
    MAP_OR_FAIL(open);

361
    if(flags & O_CREAT) 
362
363
364
365
366
367
    {
        va_list arg;
        va_start(arg, flags);
        mode = va_arg(arg, int);
        va_end(arg);

368
        tm1 = darshan_core_wtime();
369
        ret = __real_open(path, flags, mode);
370
        tm2 = darshan_core_wtime();
371
372
373
    }
    else
    {
374
        tm1 = darshan_core_wtime();
375
        ret = __real_open(path, flags);
376
        tm2 = darshan_core_wtime();
377
378
    }

379
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
380
    POSIX_RECORD_OPEN(ret, path, mode, tm1, tm2);
381
    POSIX_POST_RECORD();
382
383
384
385

    return(ret);
}

Shane Snyder's avatar
Shane Snyder committed
386
387
388
389
390
391
int DARSHAN_DECL(open64)(const char *path, int flags, ...)
{
    int mode = 0;
    int ret;
    double tm1, tm2;

392
    MAP_OR_FAIL(open64);
Shane Snyder's avatar
Shane Snyder committed
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411

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

412
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
413
    POSIX_RECORD_OPEN(ret, path, mode, tm1, tm2);
414
    POSIX_POST_RECORD();
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429

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

430
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
431
    POSIX_RECORD_OPEN(ret, path, mode, tm1, tm2);
432
    POSIX_POST_RECORD();
433
434
435
436
437
438
439
440
441
442

    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
443

444
445
446
447
    tm1 = darshan_core_wtime();
    ret = __real_creat64(path, mode);
    tm2 = darshan_core_wtime();

448
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
449
    POSIX_RECORD_OPEN(ret, path, mode, tm1, tm2);
450
    POSIX_POST_RECORD();
451
452
453
454

    return(ret);
}

455
456
457
458
459
460
461
462
463
464
465
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();

466
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
467
    POSIX_RECORD_OPEN(ret, template, 0, tm1, tm2);
468
    POSIX_POST_RECORD();
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483

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

484
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
485
    POSIX_RECORD_OPEN(ret, template, 0, tm1, tm2);
486
    POSIX_POST_RECORD();
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501

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

502
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
503
    POSIX_RECORD_OPEN(ret, template, 0, tm1, tm2);
504
    POSIX_POST_RECORD();
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519

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

520
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
521
    POSIX_RECORD_OPEN(ret, template, 0, tm1, tm2);
522
    POSIX_POST_RECORD();
523
524
525
526

    return(ret);
}

527
528
529
530
531
532
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
533
    MAP_OR_FAIL(read);
534

535
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
536
537
538
539
540

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

541
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
542
    POSIX_RECORD_READ(ret, fd, 0, 0, aligned_flag, tm1, tm2);
543
    POSIX_POST_RECORD();
544
545
546
547
548
549
550
551
552
553
554
555

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

556
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
557
558
559
560
561

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

562
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
563
    POSIX_RECORD_WRITE(ret, fd, 0, 0, aligned_flag, tm1, tm2);
564
    POSIX_POST_RECORD();
565
566
567
568
569
570
571
572
573
574
575
576

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

577
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
578
579
580
581
582

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

583
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
584
    POSIX_RECORD_READ(ret, fd, 1, offset, aligned_flag, tm1, tm2);
585
    POSIX_POST_RECORD();
586
587
588
589
590
591
592
593
594
595
596
597

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

598
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
599
600
601
602
603

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

604
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
605
    POSIX_RECORD_WRITE(ret, fd, 1, offset, aligned_flag, tm1, tm2);
606
    POSIX_POST_RECORD();
607
608
609
610
611
612
613
614
615
616
617
618

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

619
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
620
621
622
623
624

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

625
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
626
    POSIX_RECORD_READ(ret, fd, 1, offset, aligned_flag, tm1, tm2);
627
    POSIX_POST_RECORD();
628
629
630
631
632
633
634
635
636
637
638
639

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

640
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
641
642
643
644
645

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

646
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
647
    POSIX_RECORD_WRITE(ret, fd, 1, offset, aligned_flag, tm1, tm2);
648
    POSIX_POST_RECORD();
649
650
651
652
653
654
655

    return(ret);
}

ssize_t DARSHAN_DECL(readv)(int fd, const struct iovec *iov, int iovcnt)
{
    ssize_t ret;
656
    int aligned_flag = 1;
657
658
659
660
    int i;
    double tm1, tm2;

    MAP_OR_FAIL(readv);
661

662
663
664
665
    for(i=0; i<iovcnt; i++)
    {
        if(((unsigned long)iov[i].iov_base % darshan_mem_alignment) != 0)
            aligned_flag = 0;
666
    }
667
668
669
670
671

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

672
    POSIX_PRE_RECORD();
Philip Carns's avatar
Philip Carns committed
673
    POSIX_RECORD_READ(ret, fd, 0, 0, aligned_flag, tm1, tm2);
674
    POSIX_POST_RECORD();
675
676
677
678
679
680
681

    return(ret);
}

ssize_t DARSHAN_DECL(writev)(int fd, const struct iovec *iov, int iovcnt)
{
    ssize_t ret;
682
    int aligned_flag = 1;
683
684
685
686
    int i;
    double tm1, tm2;

    MAP_OR_FAIL(writev);
687

688
689
690
691
    for(i=0; i<iovcnt; i++)
    {
        if(((unsigned long)iov[i].iov_base % darshan_mem_alignment) != 0)
            aligned_flag = 0;
692
    }
693
694
695
696
697

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

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

    return(ret);
}

off_t DARSHAN_DECL(lseek)(int fd, off_t offset, int whence)
{
    off_t ret;
708
    struct posix_file_record_ref *rec_ref;
709
710
711
712
713
714
715
716
717
718
    double tm1, tm2;

    MAP_OR_FAIL(lseek);

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

    if(ret >= 0)
    {
719
        POSIX_PRE_RECORD();
720
721
        rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &fd, sizeof(int));
        if(rec_ref)
722
        {
723
            rec_ref->offset = ret;
724
            DARSHAN_TIMER_INC_NO_OVERLAP(
725
726
727
                rec_ref->file_rec->fcounters[POSIX_F_META_TIME],
                tm1, tm2, rec_ref->last_meta_end);
            rec_ref->file_rec->counters[POSIX_SEEKS] += 1;
728
        }
729
        POSIX_POST_RECORD();
730
731
732
733
734
735
736
737
    }

    return(ret);
}

off_t DARSHAN_DECL(lseek64)(int fd, off_t offset, int whence)
{
    off_t ret;
738
    struct posix_file_record_ref *rec_ref;
739
740
741
742
743
744
745
746
747
748
    double tm1, tm2;

    MAP_OR_FAIL(lseek64);

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

    if(ret >= 0)
    {
749
        POSIX_PRE_RECORD();
750
751
        rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &fd, sizeof(int));
        if(rec_ref)
752
        {
753
            rec_ref->offset = ret;
754
            DARSHAN_TIMER_INC_NO_OVERLAP(
755
756
757
                rec_ref->file_rec->fcounters[POSIX_F_META_TIME],
                tm1, tm2, rec_ref->last_meta_end);
            rec_ref->file_rec->counters[POSIX_SEEKS] += 1;
758
        }
759
        POSIX_POST_RECORD();
760
761
762
763
764
    }

    return(ret);
}

765
766
767
768
769
770
771
772
773
774
775
776
777
778
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);

779
    POSIX_PRE_RECORD();
780
    POSIX_LOOKUP_RECORD_STAT(path, buf, tm1, tm2);
781
    POSIX_POST_RECORD();
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799

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

800
    POSIX_PRE_RECORD();
801
    POSIX_LOOKUP_RECORD_STAT(path, buf, tm1, tm2);
802
    POSIX_POST_RECORD();
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820

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

821
    POSIX_PRE_RECORD();
822
    POSIX_LOOKUP_RECORD_STAT(path, buf, tm1, tm2);
823
    POSIX_POST_RECORD();
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841

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

842
    POSIX_PRE_RECORD();
843
    POSIX_LOOKUP_RECORD_STAT(path, buf, tm1, tm2);
844
    POSIX_POST_RECORD();
845
846
847
848
849
850
851

    return(ret);
}

int DARSHAN_DECL(__fxstat)(int vers, int fd, struct stat *buf)
{
    int ret;
852
    struct posix_file_record_ref *rec_ref;
853
854
855
856
857
858
859
860
861
862
863
    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);

864
    POSIX_PRE_RECORD();
865
866
    rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &fd, sizeof(int));
    if(rec_ref)
867
    {
868
        POSIX_RECORD_STAT(rec_ref, buf, tm1, tm2);
869
    }
870
    POSIX_POST_RECORD();
871
872
873
874
875
876
877

    return(ret);
}

int DARSHAN_DECL(__fxstat64)(int vers, int fd, struct stat64 *buf)
{
    int ret;
878
    struct posix_file_record_ref *rec_ref;
879
880
881
882
883
884
885
886
887
888
889
    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);

890
    POSIX_PRE_RECORD();
891
892
    rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &fd, sizeof(int));
    if(rec_ref)
893
    {
894
        POSIX_RECORD_STAT(rec_ref, buf, tm1, tm2);
895
    }
896
    POSIX_POST_RECORD();
897
898
899
900

    return(ret);
}

Shane Snyder's avatar
Shane Snyder committed
901
902
903
904
void* DARSHAN_DECL(mmap)(void *addr, size_t length, int prot, int flags,
    int fd, off_t offset)
{
    void* ret;
905
    struct posix_file_record_ref *rec_ref;
Shane Snyder's avatar
Shane Snyder committed
906
907
908
909
910
911
912

    MAP_OR_FAIL(mmap);

    ret = __real_mmap(addr, length, prot, flags, fd, offset);
    if(ret == MAP_FAILED)
        return(ret);

913
    POSIX_PRE_RECORD();
914
915
    rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &fd, sizeof(int));
    if(rec_ref)
Shane Snyder's avatar
Shane Snyder committed
916
    {
917
        rec_ref->file_rec->counters[POSIX_MMAPS] += 1;
Shane Snyder's avatar
Shane Snyder committed
918
    }
919
    POSIX_POST_RECORD();
Shane Snyder's avatar
Shane Snyder committed
920
921
922
923
924
925
926
927

    return(ret);
}

void* DARSHAN_DECL(mmap64)(void *addr, size_t length, int prot, int flags,
    int fd, off64_t offset)
{
    void* ret;
928
    struct posix_file_record_ref *rec_ref;
Shane Snyder's avatar
Shane Snyder committed
929
930
931
932
933
934
935

    MAP_OR_FAIL(mmap64);

    ret = __real_mmap64(addr, length, prot, flags, fd, offset);
    if(ret == MAP_FAILED)
        return(ret);

936
    POSIX_PRE_RECORD();
937
938
    rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &fd, sizeof(int));
    if(rec_ref)
Shane Snyder's avatar
Shane Snyder committed
939
    {
940
        rec_ref->file_rec->counters[POSIX_MMAPS] += 1;
Shane Snyder's avatar
Shane Snyder committed
941
    }
942
    POSIX_POST_RECORD();
Shane Snyder's avatar
Shane Snyder committed
943
944
945
946

    return(ret);
}

947
948
949
int DARSHAN_DECL(fsync)(int fd)
{
    int ret;
950
    struct posix_file_record_ref *rec_ref;
951
952
953
954
955
956
957
958
959
960
961
    double tm1, tm2;

    MAP_OR_FAIL(fsync);

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

    if(ret < 0)
        return(ret);

962
    POSIX_PRE_RECORD();
963
964
    rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &fd, sizeof(int));
    if(rec_ref)
965
    {
966
        DARSHAN_TIMER_INC_NO_OVERLAP(
967
968
969
            rec_ref->file_rec->fcounters[POSIX_F_WRITE_TIME],
            tm1, tm2, rec_ref->last_write_end);
        rec_ref->file_rec->counters[POSIX_FSYNCS] += 1;
970
    }
971
    POSIX_POST_RECORD();
972
973
974
975
976
977
978

    return(ret);
}

int DARSHAN_DECL(fdatasync)(int fd)
{
    int ret;
979
    struct posix_file_record_ref *rec_ref;
980
981
982
983
984
985
986
987
988
989
990
    double tm1, tm2;

    MAP_OR_FAIL(fdatasync);

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

    if(ret < 0)
        return(ret);

991
    POSIX_PRE_RECORD();
992
993
    rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &fd, sizeof(int));
    if(rec_ref)
994
    {
995
        DARSHAN_TIMER_INC_NO_OVERLAP(
996
997
998
            rec_ref->file_rec->fcounters[POSIX_F_WRITE_TIME],
            tm1, tm2, rec_ref->last_write_end);
        rec_ref->file_rec->counters[POSIX_FDSYNCS] += 1;
999
    }
1000
    POSIX_POST_RECORD();
1001
1002
1003
1004

    return(ret);
}

1005
1006
1007
int DARSHAN_DECL(close)(int fd)
{
    int ret;
1008
1009
    struct posix_file_record_ref *rec_ref;
    double tm1, tm2;
1010
1011
1012
1013
1014
1015
1016

    MAP_OR_FAIL(close);

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

1017
    POSIX_PRE_RECORD();
1018
1019
    rec_ref = darshan_lookup_record_ref(posix_runtime->fd_hash, &fd, sizeof(int));
    if(rec_ref)
Shane Snyder's avatar
Shane Snyder committed
1020
    {
1021
1022
1023
        rec_ref->last_byte_written = 0;
        rec_ref->last_byte_read = 0;
        rec_ref->file_rec->fcounters[POSIX_F_CLOSE_TIMESTAMP] =
1024
1025
            darshan_core_wtime();
        DARSHAN_TIMER_INC_NO_OVERLAP(
1026
1027
1028
            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
1029
    }
1030
    POSIX_POST_RECORD();
1031
1032
1033
1034

    return(ret);
}

1035
1036
1037
1038
1039
1040
1041
1042
1043
int DARSHAN_DECL(aio_read)(struct aiocb *aiocbp)
{
    int ret;

    MAP_OR_FAIL(aio_read);

    ret = __real_aio_read(aiocbp);
    if(ret == 0)
    {
1044
        POSIX_PRE_RECORD();
1045
        posix_aio_tracker_add(aiocbp->aio_fildes, aiocbp);
1046
        POSIX_POST_RECORD();
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
    }

    return(ret);
}

int DARSHAN_DECL(aio_write)(struct aiocb *aiocbp)
{
    int ret;

    MAP_OR_FAIL(aio_write);

    ret = __real_aio_write(aiocbp);
    if(ret == 0)
    {
1061
        POSIX_PRE_RECORD();
1062
        posix_aio_tracker_add(aiocbp->aio_fildes, aiocbp);
1063
        POSIX_POST_RECORD();
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
    }

    return(ret);
}

int DARSHAN_DECL(aio_read64)(struct aiocb64 *aiocbp)
{
    int ret;

    MAP_OR_FAIL(aio_read64);

    ret = __real_aio_read64(aiocbp);
    if(ret == 0)
    {
1078
        POSIX_PRE_RECORD();
1079
        posix_aio_tracker_add(aiocbp->aio_fildes, aiocbp);
1080
        POSIX_POST_RECORD();
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
    }

    return(ret);
}

int DARSHAN_DECL(aio_write64)(struct aiocb64 *aiocbp)
{
    int ret;

    MAP_OR_FAIL(aio_write64);

    ret = __real_aio_write64(aiocbp);
    if(ret == 0)
    {
1095
        POSIX_PRE_RECORD();
1096
        posix_aio_tracker_add(aiocbp->aio_fildes, aiocbp);
1097
        POSIX_POST_RECORD();
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
    }

    return(ret);
}

ssize_t DARSHAN_DECL(aio_return)(struct aiocb *aiocbp)
{
    int ret;
    double tm2;
    struct posix_aio_tracker *tmp;
    int aligned_flag = 0;

    MAP_OR_FAIL(aio_return);

    ret = __real_aio_return(aiocbp);
    tm2 = darshan_core_wtime();

1115
    POSIX_PRE_RECORD();
1116
    tmp = posix_aio_tracker_del(aiocbp->aio_fildes, aiocbp);
1117
    if(tmp)
1118
1119
1120
1121
1122
1123
    {
        if((unsigned long)aiocbp->aio_buf % darshan_mem_alignment == 0)
            aligned_flag = 1;
        if(aiocbp->aio_lio_opcode == LIO_WRITE)
        {
            POSIX_RECORD_WRITE(ret, aiocbp->aio_fildes,
Philip Carns's avatar
Philip Carns committed
1124
                1, aiocbp->aio_offset, aligned_flag,
1125
1126
1127
1128
1129
                tmp->tm1, tm2);
        }
        else if(aiocbp->aio_lio_opcode == LIO_READ)
        {
            POSIX_RECORD_READ(ret, aiocbp->aio_fildes,
Philip Carns's avatar
Philip Carns committed
1130
                1, aiocbp->aio_offset, aligned_flag,
1131
1132
1133
1134
                tmp->tm1, tm2);
        }
        free(tmp);
    }
1135
    POSIX_POST_RECORD();
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151

    return(ret);
}

ssize_t DARSHAN_DECL(aio_return64)(struct aiocb64 *aiocbp)
{
    int ret;
    double tm2;
    struct posix_aio_tracker *tmp;
    int aligned_flag = 0;

    MAP_OR_FAIL(aio_return64);

    ret = __real_aio_return64(aiocbp);
    tm2 = darshan_core_wtime();

1152
    POSIX_PRE_RECORD();
1153
    tmp = posix_aio_tracker_del(aiocbp->aio_fildes, aiocbp);
1154
    if(tmp)
1155
1156
1157
1158
1159
1160
    {
        if((unsigned long)aiocbp->aio_buf % darshan_mem_alignment == 0)
            aligned_flag = 1;
        if(aiocbp->aio_lio_opcode == LIO_WRITE)
        {
            POSIX_RECORD_WRITE(ret, aiocbp->aio_fildes,
Philip Carns's avatar
Philip Carns committed
1161
                1, aiocbp->aio_offset, aligned_flag,
1162
1163
1164
1165
1166
                tmp->tm1, tm2);
        }
        else if(aiocbp->aio_lio_opcode == LIO_READ)
        {
            POSIX_RECORD_READ(ret, aiocbp->aio_fildes,
Philip Carns's avatar
Philip Carns committed
1167
                1, aiocbp->aio_offset, aligned_flag,
1168
1169
1170
1171
                tmp->tm1, tm2);
        }
        free(tmp);
    }
1172
    POSIX_POST_RECORD();
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187

    return(ret);
}

int DARSHAN_DECL(lio_listio)(int mode, struct aiocb *const aiocb_list[],
    int nitems, struct sigevent *sevp)
{
    int ret;
    int i;

    MAP_OR_FAIL(lio_listio);

    ret = __real_lio_listio(mode, aiocb_list, nitems, sevp);
    if(ret == 0)
    {
1188
        POSIX_PRE_RECORD();
1189
1190
1191
1192
        for(i = 0; i < nitems; i++)
        {
            posix_aio_tracker_add(aiocb_list[i]->aio_fildes, aiocb_list[i]);
        }
1193
        POSIX_POST_RECORD();
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
    }

    return(ret);
}

int DARSHAN_DECL(lio_listio64)(int mode, struct aiocb64 *const aiocb_list[],
    int nitems, struct sigevent *sevp)
{
    int ret;
    int i;

    MAP_OR_FAIL(lio_listio64);

    ret = __real_lio_listio64(mode, aiocb_list, nitems, sevp);
    if(ret == 0)
    {
1210
        POSIX_PRE_RECORD();
1211
1212
1213
1214
        for(i = 0; i < nitems; i++)
        {
            posix_aio_tracker_add(aiocb_list[i]->aio_fildes, aiocb_list[i]);
        }
Shane Snyder's avatar