darshan-posix.c 61.9 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 "uthash.h"
30
31
#include "utlist.h"

32
#include "darshan.h"
33
#include "darshan-dynamic.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
DARSHAN_FORWARD_DECL(open, int, (const char *path, int flags, ...));
DARSHAN_FORWARD_DECL(open64, int, (const char *path, int flags, ...));
44
45
DARSHAN_FORWARD_DECL(creat, int, (const char* path, mode_t mode));
DARSHAN_FORWARD_DECL(creat64, int, (const char* path, mode_t mode));
46
47
48
49
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));
50
51
52
53
54
55
56
57
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));
58
59
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));
60
61
62
63
64
65
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
66
67
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));
68
69
DARSHAN_FORWARD_DECL(fsync, int, (int fd));
DARSHAN_FORWARD_DECL(fdatasync, int, (int fd));
70
DARSHAN_FORWARD_DECL(close, int, (int fd));
71
72
73
74
75
76
77
78
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));
79

80
81
82
83
84
85
86
87
/* struct to track information about aio operations in flight */
struct posix_aio_tracker
{
    double tm1;
    void *aiocbp;
    struct posix_aio_tracker* next;
};

88
89
90
91
92
93
/* The posix_file_runtime 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_record'. This metadata
 * assists with the instrumenting of specific statistics in the file record.
 * 'hlink' is a hash table link structure used to add/remove this record
 * from the hash table of POSIX file records for this process. 
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 *
 * 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_runtime
 * struct with each darshan_posix_file struct in order to track this information.
  *
 * NOTE: There is a one-to-one mapping of posix_file_runtime structs to
 * darshan_posix_file structs.
 *
 * NOTE: The posix_file_runtime struct contains a pointer to a darshan_posix_file
 * struct (see the *file_record member) rather than simply embedding an entire
 * darshan_posix_file struct.  This is done so that all of the darshan_posix_file
 * structs can be kept contiguous in memory as a single array to simplify
 * reduction, compression, and storage.
110
 */
111
struct posix_file_runtime
112
{
113
    struct darshan_posix_file* file_record;
114
115
116
    int64_t offset;
    int64_t last_byte_read;
    int64_t last_byte_written;
Shane Snyder's avatar
Shane Snyder committed
117
    enum darshan_io_type last_io_type;
118
119
120
    double last_meta_end;
    double last_read_end;
    double last_write_end;
121
122
123
124
    void* access_root;
    int access_count;
    void* stride_root;
    int stride_count;
125
    struct posix_aio_tracker* aio_list;
126
    UT_hash_handle hlink;
127
};
128

129
130
131
132
133
134
135
136
137
138
139
/* The posix_file_runtime_ref structure is used to associate a POSIX
 * file descriptor with an already existing POSIX file record. This is
 * necessary as many POSIX I/O functions take only an input file descriptor,
 * but POSIX file records are indexed by their full file paths (i.e., darshan
 * record identifiers for POSIX files are created by hashing the file path).
 * In other words, this structure is necessary as it allows us to look up a
 * file record either by a pathname (posix_file_runtime) or by POSIX file
 * descriptor (posix_file_runtime_ref), depending on which parameters are
 * available. This structure includes another hash table link, since separate
 * hashes are maintained for posix_file_runtime structures and posix_file_runtime_ref
 * structures.
140
141
142
143
144
145
146
147
148
149
150
 *
 * RATIONALE: In theory the fd information could be included in the
 * posix_file_runtime struct rather than in a separate structure here.  The
 * reason we don't do that is because the same file could be opened multiple
 * times by a given process with different file descriptors and thus
 * simulataneously referenced using different file descriptors.  This practice is
 * not common, but we must support it.
 *
 * NOTE: there are potentially multiple posix_file_runtime_ref structures
 * referring to a single posix_file_runtime structure.  Most of the time there is
 * only one, however.
151
 */
152
struct posix_file_runtime_ref
153
{
154
    struct posix_file_runtime* file;
155
156
157
158
    int fd;
    UT_hash_handle hlink;
};

159
160
161
162
/* The posix_runtime structure maintains necessary state for storing
 * POSIX file records and for coordinating with darshan-core at 
 * shutdown time.
 */
163
164
struct posix_runtime
{
165
    struct posix_file_runtime* file_runtime_array;
166
    struct darshan_posix_file* file_record_array;
167
    int file_array_size;
168
    int file_array_ndx;
169
170
    struct posix_file_runtime* file_hash;
    struct posix_file_runtime_ref* fd_hash;
171
172
};

173
static struct posix_runtime *posix_runtime = NULL;
174
static pthread_mutex_t posix_runtime_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
Shane Snyder's avatar
Shane Snyder committed
175
static int instrumentation_disabled = 0;
176
static int my_rank = -1;
177
static int darshan_mem_alignment = 1;
178

179
180
181
182
183
static void posix_runtime_initialize(void);
static struct posix_file_runtime* posix_file_by_name(const char *name);
static struct posix_file_runtime* posix_file_by_name_setfd(const char* name, int fd);
static struct posix_file_runtime* posix_file_by_fd(int fd);
static void posix_file_close_fd(int fd);
184
185
static void posix_aio_tracker_add(int fd, void *aiocbp);
static struct posix_aio_tracker* posix_aio_tracker_del(int fd, void *aiocbp);
186
static int posix_record_compare(const void* a, const void* b);
187
188
static void posix_record_reduction_op(void* infile_v, void* inoutfile_v,
    int *len, MPI_Datatype *datatype);
189
190
191
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);
192
193
194
195

static void posix_begin_shutdown(void);
static void posix_get_output_data(MPI_Comm mod_comm, darshan_record_id *shared_recs,
    int shared_rec_count, void **posix_buf, int *posix_buf_sz);
196
197
static void posix_shutdown(void);

198
199
#define POSIX_LOCK() pthread_mutex_lock(&posix_runtime_mutex)
#define POSIX_UNLOCK() pthread_mutex_unlock(&posix_runtime_mutex)
200

201
#define POSIX_RECORD_OPEN(__ret, __path, __mode, __stream_flag, __tm1, __tm2) do { \
202
    struct posix_file_runtime* file; \
203
204
205
    char* exclude; \
    int tmp_index = 0; \
    if(__ret < 0) break; \
206
    while((exclude = darshan_path_exclusions[tmp_index])) { \
207
208
209
210
211
        if(!(strncmp(exclude, __path, strlen(exclude)))) \
            break; \
        tmp_index++; \
    } \
    if(exclude) break; \
212
    file = posix_file_by_name_setfd(__path, __ret); \
213
    if(!file) break; \
214
    if(__mode) \
215
        file->file_record->counters[POSIX_MODE] = __mode; \
216
217
218
    file->offset = 0; \
    file->last_byte_written = 0; \
    file->last_byte_read = 0; \
219
    if(__stream_flag)\
220
        file->file_record->counters[POSIX_FOPENS] += 1; \
221
    else \
222
        file->file_record->counters[POSIX_OPENS] += 1; \
223
224
    if(file->file_record->fcounters[POSIX_F_OPEN_TIMESTAMP] == 0 || \
     file->file_record->fcounters[POSIX_F_OPEN_TIMESTAMP] > __tm1) \
225
226
        file->file_record->fcounters[POSIX_F_OPEN_TIMESTAMP] = __tm1; \
    DARSHAN_TIMER_INC_NO_OVERLAP(file->file_record->fcounters[POSIX_F_META_TIME], __tm1, __tm2, file->last_meta_end); \
227
228
229
} while(0)

#define POSIX_RECORD_READ(__ret, __fd, __pread_flag, __pread_offset, __aligned, __stream_flag, __tm1, __tm2) do{ \
230
    size_t stride; \
231
    int64_t this_offset; \
232
    struct posix_file_runtime* file; \
233
    int64_t file_alignment; \
234
235
236
237
    double __elapsed = __tm2-__tm1; \
    if(__ret < 0) break; \
    file = posix_file_by_fd(__fd); \
    if(!file) break; \
238
    if(__pread_flag) \
239
240
241
242
        this_offset = __pread_offset; \
    else \
        this_offset = file->offset; \
    if(this_offset > file->last_byte_read) \
243
        file->file_record->counters[POSIX_SEQ_READS] += 1;  \
244
    if(this_offset == (file->last_byte_read + 1)) \
245
        file->file_record->counters[POSIX_CONSEC_READS] += 1;  \
246
    if(this_offset > 0 && this_offset > file->last_byte_read \
247
248
249
        && file->last_byte_read != 0) \
        stride = this_offset - file->last_byte_read - 1; \
    else \
250
        stride = 0; \
251
252
    file->last_byte_read = this_offset + __ret - 1; \
    file->offset = this_offset + __ret; \
253
254
255
256
257
258
259
260
261
262
    if(file->file_record->counters[POSIX_MAX_BYTE_READ] < (this_offset + __ret - 1)) \
        file->file_record->counters[POSIX_MAX_BYTE_READ] = (this_offset + __ret - 1); \
    file->file_record->counters[POSIX_BYTES_READ] += __ret; \
    if(__stream_flag) \
        file->file_record->counters[POSIX_FREADS] += 1; \
    else \
        file->file_record->counters[POSIX_READS] += 1; \
    DARSHAN_BUCKET_INC(&(file->file_record->counters[POSIX_SIZE_READ_0_100]), __ret); \
    darshan_common_val_counter(&file->access_root, &file->access_count, __ret); \
    darshan_common_val_counter(&file->stride_root, &file->stride_count, stride); \
263
    if(!__aligned) \
264
265
        file->file_record->counters[POSIX_MEM_NOT_ALIGNED] += 1; \
    file_alignment = file->file_record->counters[POSIX_FILE_ALIGNMENT]; \
266
    if(file_alignment > 0 && (this_offset % file_alignment) != 0) \
267
        file->file_record->counters[POSIX_FILE_NOT_ALIGNED] += 1; \
Shane Snyder's avatar
Shane Snyder committed
268
    if(file->last_io_type == DARSHAN_IO_WRITE) \
269
        file->file_record->counters[POSIX_RW_SWITCHES] += 1; \
Shane Snyder's avatar
Shane Snyder committed
270
    file->last_io_type = DARSHAN_IO_READ; \
271
272
    if(file->file_record->fcounters[POSIX_F_READ_START_TIMESTAMP] == 0 || \
     file->file_record->fcounters[POSIX_F_READ_START_TIMESTAMP] > __tm1) \
273
274
275
276
277
278
        file->file_record->fcounters[POSIX_F_READ_START_TIMESTAMP] = __tm1; \
    file->file_record->fcounters[POSIX_F_READ_END_TIMESTAMP] = __tm2; \
    if(file->file_record->fcounters[POSIX_F_MAX_READ_TIME] < __elapsed) { \
        file->file_record->fcounters[POSIX_F_MAX_READ_TIME] = __elapsed; \
        file->file_record->counters[POSIX_MAX_READ_TIME_SIZE] = __ret; } \
    DARSHAN_TIMER_INC_NO_OVERLAP(file->file_record->fcounters[POSIX_F_READ_TIME], __tm1, __tm2, file->last_read_end); \
279
280
281
} while(0)

#define POSIX_RECORD_WRITE(__ret, __fd, __pwrite_flag, __pwrite_offset, __aligned, __stream_flag, __tm1, __tm2) do{ \
282
    size_t stride; \
283
    int64_t this_offset; \
284
    struct posix_file_runtime* file; \
285
    int64_t file_alignment; \
286
287
288
289
    double __elapsed = __tm2-__tm1; \
    if(__ret < 0) break; \
    file = posix_file_by_fd(__fd); \
    if(!file) break; \
290
    if(__pwrite_flag) \
291
292
293
294
        this_offset = __pwrite_offset; \
    else \
        this_offset = file->offset; \
    if(this_offset > file->last_byte_written) \
295
        file->file_record->counters[POSIX_SEQ_WRITES] += 1; \
296
    if(this_offset == (file->last_byte_written + 1)) \
297
        file->file_record->counters[POSIX_CONSEC_WRITES] += 1; \
298
    if(this_offset > 0 && this_offset > file->last_byte_written \
299
300
        && file->last_byte_written != 0) \
        stride = this_offset - file->last_byte_written - 1; \
301
    else \
302
        stride = 0; \
303
304
    file->last_byte_written = this_offset + __ret - 1; \
    file->offset = this_offset + __ret; \
305
306
307
    if(file->file_record->counters[POSIX_MAX_BYTE_WRITTEN] < (this_offset + __ret - 1)) \
        file->file_record->counters[POSIX_MAX_BYTE_WRITTEN] = (this_offset + __ret - 1); \
    file->file_record->counters[POSIX_BYTES_WRITTEN] += __ret; \
308
    if(__stream_flag) \
309
        file->file_record->counters[POSIX_FWRITES] += 1; \
310
    else \
311
312
313
314
        file->file_record->counters[POSIX_WRITES] += 1; \
    DARSHAN_BUCKET_INC(&(file->file_record->counters[POSIX_SIZE_WRITE_0_100]), __ret); \
    darshan_common_val_counter(&file->access_root, &file->access_count, __ret); \
    darshan_common_val_counter(&file->stride_root, &file->stride_count, stride); \
315
    if(!__aligned) \
316
317
        file->file_record->counters[POSIX_MEM_NOT_ALIGNED] += 1; \
    file_alignment = file->file_record->counters[POSIX_FILE_ALIGNMENT]; \
318
    if(file_alignment > 0 && (this_offset % file_alignment) != 0) \
319
        file->file_record->counters[POSIX_FILE_NOT_ALIGNED] += 1; \
Shane Snyder's avatar
Shane Snyder committed
320
    if(file->last_io_type == DARSHAN_IO_READ) \
321
        file->file_record->counters[POSIX_RW_SWITCHES] += 1; \
Shane Snyder's avatar
Shane Snyder committed
322
    file->last_io_type = DARSHAN_IO_WRITE; \
323
324
    if(file->file_record->fcounters[POSIX_F_WRITE_START_TIMESTAMP] == 0 || \
     file->file_record->fcounters[POSIX_F_WRITE_START_TIMESTAMP] > __tm1) \
325
326
327
328
329
330
        file->file_record->fcounters[POSIX_F_WRITE_START_TIMESTAMP] = __tm1; \
    file->file_record->fcounters[POSIX_F_WRITE_END_TIMESTAMP] = __tm2; \
    if(file->file_record->fcounters[POSIX_F_MAX_WRITE_TIME] < __elapsed) { \
        file->file_record->fcounters[POSIX_F_MAX_WRITE_TIME] = __elapsed; \
        file->file_record->counters[POSIX_MAX_WRITE_TIME_SIZE] = __ret; } \
    DARSHAN_TIMER_INC_NO_OVERLAP(file->file_record->fcounters[POSIX_F_WRITE_TIME], __tm1, __tm2, file->last_write_end); \
331
} while(0)
332

333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
#define POSIX_LOOKUP_RECORD_STAT(__path, __statbuf, __tm1, __tm2) do { \
    char* exclude; \
    int tmp_index = 0; \
    struct posix_file_runtime* file; \
    while((exclude = darshan_path_exclusions[tmp_index])) { \
        if(!(strncmp(exclude, __path, strlen(exclude)))) \
            break; \
        tmp_index++; \
    } \
    if(exclude) break; \
    file = posix_file_by_name(__path); \
    if(file) \
    { \
        POSIX_RECORD_STAT(file, __statbuf, __tm1, __tm2); \
    } \
} while(0)

#define POSIX_RECORD_STAT(__file, __statbuf, __tm1, __tm2) do { \
351
352
    DARSHAN_TIMER_INC_NO_OVERLAP((__file)->file_record->fcounters[POSIX_F_META_TIME], __tm1, __tm2, (__file)->last_meta_end); \
    (__file)->file_record->counters[POSIX_STATS] += 1; \
353
354
} while(0)

355
356
357
358
/**********************************************************
 *      Wrappers for POSIX I/O functions of interest      * 
 **********************************************************/

359
int DARSHAN_DECL(open)(const char *path, int flags, ...)
360
361
362
363
364
{
    int mode = 0;
    int ret;
    double tm1, tm2;

365
366
    MAP_OR_FAIL(open);

367
    if(flags & O_CREAT) 
368
369
370
371
372
373
    {
        va_list arg;
        va_start(arg, flags);
        mode = va_arg(arg, int);
        va_end(arg);

374
        tm1 = darshan_core_wtime();
375
        ret = __real_open(path, flags, mode);
376
        tm2 = darshan_core_wtime();
377
378
379
    }
    else
    {
380
        tm1 = darshan_core_wtime();
381
        ret = __real_open(path, flags);
382
        tm2 = darshan_core_wtime();
383
384
    }

385
386
    POSIX_LOCK();
    posix_runtime_initialize();
387
    POSIX_RECORD_OPEN(ret, path, mode, 0, tm1, tm2);
388
    POSIX_UNLOCK();
389
390
391
392

    return(ret);
}

Shane Snyder's avatar
Shane Snyder committed
393
394
395
396
397
398
int DARSHAN_DECL(open64)(const char *path, int flags, ...)
{
    int mode = 0;
    int ret;
    double tm1, tm2;

399
    MAP_OR_FAIL(open64);
Shane Snyder's avatar
Shane Snyder committed
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420

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

    POSIX_LOCK();
    posix_runtime_initialize();
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
    POSIX_RECORD_OPEN(ret, path, mode, 0, tm1, tm2);
    POSIX_UNLOCK();

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

    POSIX_LOCK();
    posix_runtime_initialize();
    POSIX_RECORD_OPEN(ret, path, mode, 0, tm1, tm2);
    POSIX_UNLOCK();

    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
452

453
454
455
456
457
458
    tm1 = darshan_core_wtime();
    ret = __real_creat64(path, mode);
    tm2 = darshan_core_wtime();

    POSIX_LOCK();
    posix_runtime_initialize();
Shane Snyder's avatar
Shane Snyder committed
459
460
461
462
463
464
    POSIX_RECORD_OPEN(ret, path, mode, 0, tm1, tm2);
    POSIX_UNLOCK();

    return(ret);
}

465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
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
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();

    POSIX_LOCK();
    posix_runtime_initialize();
    POSIX_RECORD_OPEN(ret, template, 0, 0, tm1, tm2);
    POSIX_UNLOCK();

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

    POSIX_LOCK();
    posix_runtime_initialize();
    POSIX_RECORD_OPEN(ret, template, 0, 0, tm1, tm2);
    POSIX_UNLOCK();

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

    POSIX_LOCK();
    posix_runtime_initialize();
    POSIX_RECORD_OPEN(ret, template, 0, 0, tm1, tm2);
    POSIX_UNLOCK();

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

    POSIX_LOCK();
    posix_runtime_initialize();
    POSIX_RECORD_OPEN(ret, template, 0, 0, tm1, tm2);
    POSIX_UNLOCK();

    return(ret);
}

541
542
543
544
545
546
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
547
    MAP_OR_FAIL(read);
548

549
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570

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

    POSIX_LOCK();
    posix_runtime_initialize();
    POSIX_RECORD_READ(ret, fd, 0, 0, aligned_flag, 0, tm1, tm2);
    POSIX_UNLOCK();

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

571
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592

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

    POSIX_LOCK();
    posix_runtime_initialize();
    POSIX_RECORD_WRITE(ret, fd, 0, 0, aligned_flag, 0, tm1, tm2);
    POSIX_UNLOCK();

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

593
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614

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

    POSIX_LOCK();
    posix_runtime_initialize();
    POSIX_RECORD_READ(ret, fd, 1, offset, aligned_flag, 0, tm1, tm2);
    POSIX_UNLOCK();

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

615
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636

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

    POSIX_LOCK();
    posix_runtime_initialize();
    POSIX_RECORD_WRITE(ret, fd, 1, offset, aligned_flag, 0, tm1, tm2);
    POSIX_UNLOCK();

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

637
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658

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

    POSIX_LOCK();
    posix_runtime_initialize();
    POSIX_RECORD_READ(ret, fd, 1, offset, aligned_flag, 0, tm1, tm2);
    POSIX_UNLOCK();

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

659
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675

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

    POSIX_LOCK();
    posix_runtime_initialize();
    POSIX_RECORD_WRITE(ret, fd, 1, offset, aligned_flag, 0, tm1, tm2);
    POSIX_UNLOCK();

    return(ret);
}

ssize_t DARSHAN_DECL(readv)(int fd, const struct iovec *iov, int iovcnt)
{
    ssize_t ret;
676
    int aligned_flag = 1;
677
678
679
680
    int i;
    double tm1, tm2;

    MAP_OR_FAIL(readv);
681

682
683
684
685
    for(i=0; i<iovcnt; i++)
    {
        if(((unsigned long)iov[i].iov_base % darshan_mem_alignment) != 0)
            aligned_flag = 0;
686
    }
687
688
689
690
691
692

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

    POSIX_LOCK();
693
    posix_runtime_initialize();
694
695
696
697
698
699
700
701
702
    POSIX_RECORD_READ(ret, fd, 0, 0, aligned_flag, 0, tm1, tm2);
    POSIX_UNLOCK();

    return(ret);
}

ssize_t DARSHAN_DECL(writev)(int fd, const struct iovec *iov, int iovcnt)
{
    ssize_t ret;
703
    int aligned_flag = 1;
704
705
706
707
    int i;
    double tm1, tm2;

    MAP_OR_FAIL(writev);
708

709
710
711
712
    for(i=0; i<iovcnt; i++)
    {
        if(((unsigned long)iov[i].iov_base % darshan_mem_alignment) != 0)
            aligned_flag = 0;
713
    }
714
715
716
717
718
719

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

    POSIX_LOCK();
720
    posix_runtime_initialize();
721
722
723
724
725
726
    POSIX_RECORD_WRITE(ret, fd, 0, 0, aligned_flag, 0, tm1, tm2);
    POSIX_UNLOCK();

    return(ret);
}

727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
off_t DARSHAN_DECL(lseek)(int fd, off_t offset, int whence)
{
    off_t ret;
    struct posix_file_runtime* file;
    double tm1, tm2;

    MAP_OR_FAIL(lseek);

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

    if(ret >= 0)
    {
        POSIX_LOCK();
        posix_runtime_initialize();
        file = posix_file_by_fd(fd);
        if(file)
        {
            file->offset = ret;
747
748
749
750
            DARSHAN_TIMER_INC_NO_OVERLAP(
                file->file_record->fcounters[POSIX_F_META_TIME],
                tm1, tm2, file->last_meta_end);
            file->file_record->counters[POSIX_SEEKS] += 1;
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
        }
        POSIX_UNLOCK();
    }

    return(ret);
}

off_t DARSHAN_DECL(lseek64)(int fd, off_t offset, int whence)
{
    off_t ret;
    struct posix_file_runtime* file;
    double tm1, tm2;

    MAP_OR_FAIL(lseek64);

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

    if(ret >= 0)
    {
        POSIX_LOCK();
        posix_runtime_initialize();
        file = posix_file_by_fd(fd);
        if(file)
        {
            file->offset = ret;
778
779
780
781
            DARSHAN_TIMER_INC_NO_OVERLAP(
                file->file_record->fcounters[POSIX_F_META_TIME],
                tm1, tm2, file->last_meta_end);
            file->file_record->counters[POSIX_SEEKS] += 1;
782
783
784
785
786
787
788
        }
        POSIX_UNLOCK();
    }

    return(ret);
}

789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
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);

    POSIX_LOCK();
    posix_runtime_initialize();
    POSIX_LOOKUP_RECORD_STAT(path, buf, tm1, tm2);
    POSIX_UNLOCK();

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

    POSIX_LOCK();
    posix_runtime_initialize();
    POSIX_LOOKUP_RECORD_STAT(path, buf, tm1, tm2);
    POSIX_UNLOCK();

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

    POSIX_LOCK();
    posix_runtime_initialize();
    POSIX_LOOKUP_RECORD_STAT(path, buf, tm1, tm2);
    POSIX_UNLOCK();

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

    POSIX_LOCK();
    posix_runtime_initialize();
    POSIX_LOOKUP_RECORD_STAT(path, buf, tm1, tm2);
    POSIX_UNLOCK();

    return(ret);
}

int DARSHAN_DECL(__fxstat)(int vers, int fd, struct stat *buf)
{
    int ret;
    struct posix_file_runtime* file;
    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);

    POSIX_LOCK();
    posix_runtime_initialize();
    file = posix_file_by_fd(fd);
    if(file)
    {
        POSIX_RECORD_STAT(file, buf, tm1, tm2);
    }
    POSIX_UNLOCK();

    return(ret);
}

int DARSHAN_DECL(__fxstat64)(int vers, int fd, struct stat64 *buf)
{
    int ret;
    struct posix_file_runtime* file;
    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);

    POSIX_LOCK();
    posix_runtime_initialize();
    file = posix_file_by_fd(fd);
    if(file)
    {
        POSIX_RECORD_STAT(file, buf, tm1, tm2);
    }
    POSIX_UNLOCK();

    return(ret);
}

Shane Snyder's avatar
Shane Snyder committed
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
void* DARSHAN_DECL(mmap)(void *addr, size_t length, int prot, int flags,
    int fd, off_t offset)
{
    void* ret;
    struct posix_file_runtime* file;

    MAP_OR_FAIL(mmap);

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

    POSIX_LOCK();
    posix_runtime_initialize();
    file = posix_file_by_fd(fd);
    if(file)
    {
948
        file->file_record->counters[POSIX_MMAPS] += 1;
Shane Snyder's avatar
Shane Snyder committed
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
    }
    POSIX_UNLOCK();

    return(ret);
}

void* DARSHAN_DECL(mmap64)(void *addr, size_t length, int prot, int flags,
    int fd, off64_t offset)
{
    void* ret;
    struct posix_file_runtime* file;

    MAP_OR_FAIL(mmap64);

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

    POSIX_LOCK();
    posix_runtime_initialize();
    file = posix_file_by_fd(fd);
    if(file)
    {
972
        file->file_record->counters[POSIX_MMAPS] += 1;
Shane Snyder's avatar
Shane Snyder committed
973
974
975
976
977
978
    }
    POSIX_UNLOCK();

    return(ret);
}

979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
int DARSHAN_DECL(fsync)(int fd)
{
    int ret;
    struct posix_file_runtime* file;
    double tm1, tm2;

    MAP_OR_FAIL(fsync);

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

    if(ret < 0)
        return(ret);

    POSIX_LOCK();
    posix_runtime_initialize();
    file = posix_file_by_fd(fd);
    if(file)
    {
999
1000
1001
1002
        DARSHAN_TIMER_INC_NO_OVERLAP(
            file->file_record->fcounters[POSIX_F_WRITE_TIME],
            tm1, tm2, file->last_write_end);
        file->file_record->counters[POSIX_FSYNCS] += 1;
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
    }
    POSIX_UNLOCK();

    return(ret);
}

int DARSHAN_DECL(fdatasync)(int fd)
{
    int ret;
    struct posix_file_runtime* file;
    double tm1, tm2;

    MAP_OR_FAIL(fdatasync);

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

    if(ret < 0)
        return(ret);

    POSIX_LOCK();
    posix_runtime_initialize();
    file = posix_file_by_fd(fd);
    if(file)
    {
1029
1030
1031
1032
        DARSHAN_TIMER_INC_NO_OVERLAP(
            file->file_record->fcounters[POSIX_F_WRITE_TIME],
            tm1, tm2, file->last_write_end);
        file->file_record->counters[POSIX_FDSYNCS] += 1;
1033
1034
1035
1036
1037
1038
    }
    POSIX_UNLOCK();

    return(ret);
}

1039
1040
int DARSHAN_DECL(close)(int fd)
{
1041
    struct posix_file_runtime* file;
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
    double tm1, tm2;
    int ret;

    MAP_OR_FAIL(close);

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

    POSIX_LOCK();
    posix_runtime_initialize();
Shane Snyder's avatar
Shane Snyder committed
1053
1054
1055
    file = posix_file_by_fd(fd);
    if(file)
    {
1056
1057
        file->last_byte_written = 0;
        file->last_byte_read = 0;
1058
1059
1060
1061
1062
        file->file_record->fcounters[POSIX_F_CLOSE_TIMESTAMP] =
            darshan_core_wtime();
        DARSHAN_TIMER_INC_NO_OVERLAP(
            file->file_record->fcounters[POSIX_F_META_TIME],
            tm1, tm2, file->last_meta_end);
Shane Snyder's avatar
Shane Snyder committed
1063
1064
        posix_file_close_fd(fd);
    }
1065
1066
1067
1068
1069
    POSIX_UNLOCK();    

    return(ret);
}

1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
int DARSHAN_DECL(aio_read)(struct aiocb *aiocbp)
{
    int ret;

    MAP_OR_FAIL(aio_read);

    ret = __real_aio_read(aiocbp);
    if(ret == 0)
    {
        POSIX_LOCK();
        posix_runtime_initialize();
        posix_aio_tracker_add(aiocbp->aio_fildes, aiocbp);
        POSIX_UNLOCK();
    }

    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)
    {
        POSIX_LOCK();
        posix_runtime_initialize();
        posix_aio_tracker_add(aiocbp->aio_fildes, aiocbp);
        POSIX_UNLOCK();
    }

    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)
    {
        POSIX_LOCK();
        posix_runtime_initialize();
        posix_aio_tracker_add(aiocbp->aio_fildes, aiocbp);
        POSIX_UNLOCK();
    }

    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)
    {
        POSIX_LOCK();
        posix_runtime_initialize();
        posix_aio_tracker_add(aiocbp->aio_fildes, aiocbp);
        POSIX_UNLOCK();
    }

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

    POSIX_LOCK();
    posix_runtime_initialize();
    tmp = posix_aio_tracker_del(aiocbp->aio_fildes, aiocbp);
    if (tmp)
    {
        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,
                1, aiocbp->aio_offset, aligned_flag, 0,
                tmp->tm1, tm2);
        }
        else if(aiocbp->aio_lio_opcode == LIO_READ)
        {
            POSIX_RECORD_READ(ret, aiocbp->aio_fildes,
                1, aiocbp->aio_offset, aligned_flag, 0,
                tmp->tm1, tm2);
        }
        free(tmp);
    }
    POSIX_UNLOCK();

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

    POSIX_LOCK();
    posix_runtime_initialize();
    tmp = posix_aio_tracker_del(aiocbp->aio_fildes, aiocbp);
    if (tmp)
    {
        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,
                1, aiocbp->aio_offset, aligned_flag, 0,
                tmp->tm1, tm2);
        }
        else if(aiocbp->aio_lio_opcode == LIO_READ)
        {
            POSIX_RECORD_READ(ret, aiocbp->aio_fildes,
                1, aiocbp->aio_offset, aligned_flag, 0,
                tmp->tm1, tm2);
        }
        free(tmp);
    }
    POSIX_UNLOCK();

    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)
    {
        POSIX_LOCK();
        posix_runtime_initialize();
        for(i = 0; i < nitems; i++)
        {
            posix_aio_tracker_add(aiocb_list[i]->aio_fildes, aiocb_list[i]);
        }
        POSIX_UNLOCK();
    }

    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)
    {
        POSIX_LOCK();
        posix_runtime_initialize();
        for(i = 0; i < nitems; i++)
        {
            posix_aio_tracker_add(aiocb_list[i]->aio_fildes, aiocb_list[i]);
        }
        POSIX_UNLOCK();
    }

    return(ret);
}

1264
1265
1266
/**********************************************************
 * Internal functions for manipulating POSIX module state *
 **********************************************************/
1267

1268
/* initialize internal POSIX module data structures and register with darshan-core */
1269
static void posix_runtime_initialize()
1270
{
1271
1272
1273
    int mem_limit;
    struct darshan_module_funcs posix_mod_fns =
    {
1274
        .begin_shutdown = &posix_begin_shutdown,
1275
        .get_output_data = &posix_get_output_data,
1276
        .shutdown = &posix_shutdown
1277
    };
1278

Shane Snyder's avatar
Shane Snyder committed
1279
1280
    /* don't do anything if already initialized or instrumenation is disabled */
    if(posix_runtime || instrumentation_disabled)
1281
        return;
1282

1283
1284
    /* register the posix module with darshan core */
    darshan_core_register_module(
1285
        DARSHAN_POSIX_MOD,
1286
        &posix_mod_fns,
1287
        &my_rank,
1288
1289
        &mem_limit,
        &darshan_mem_alignment);
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301

    /* return if no memory assigned by darshan core */
    if(mem_limit == 0)
        return;

    posix_runtime = malloc(sizeof(*posix_runtime));
    if(!posix_runtime)
        return;
    memset(posix_runtime, 0, sizeof(*posix_runtime));

    /* set maximum number of file records according to max memory limit */
    /* NOTE: maximum number of records is based on the size of a posix file record */
1302
    /* TODO: should we base memory usage off file record or total runtime structure sizes? */
1303
    posix_runtime->file_array_size = mem_limit / sizeof(struct darshan_posix_file);
1304
    posix_runtime->file_array_ndx = 0;
1305
1306

    /* allocate array of runtime file records */
1307
    posix_runtime->file_runtime_array = malloc(posix_runtime->file_array_size *
1308
                                               sizeof(struct posix_file_runtime));
1309
1310
1311
    posix_runtime->file_record_array = malloc(posix_runtime->file_array_size *
                                              sizeof(struct darshan_posix_file));
    if(!posix_runtime->file_runtime_array || !posix_runtime->file_record_array)
1312
1313
1314
1315
    {
        posix_runtime->file_array_size = 0;
        return;
    }
1316
    memset(posix_runtime->file_runtime_array, 0, posix_runtime->file_array_size *
1317
           sizeof(struct posix_file_runtime));
1318
1319
    memset(posix_runtime->file_record_array, 0, posix_runtime->file_array_size *
           sizeof(struct darshan_posix_file));
1320
1321
1322

    return;
}
1323

1324
/* get a POSIX file record for the given file path */
1325
static struct posix_file_runtime* posix_file_by_name(const char *name)
1326
{
1327
    struct posix_file_runtime *file = NULL;
1328
    char *newname = NULL;
1329
    darshan_record_id file_id;
1330
    int file_alignment;
1331
    int limit_flag;
1332

Shane Snyder's avatar
Shane Snyder committed
1333
    if(!posix_runtime || instrumentation_disabled)
1334
        return(NULL);
1335

1336
    newname = darshan_clean_file_path(name);
1337
    if(!newname)
1338
        newname = (char*)name;
1339

1340
1341
    limit_flag = (posix_runtime->file_array_ndx >= posix_runtime->file_array_size);

1342
    /* get a unique id for this file from darshan core */
Shane Snyder's avatar
Shane Snyder committed
1343
    darshan_core_register_record(
1344
1345
        (void*)newname,
        strlen(newname),
1346
        DARSHAN_POSIX_MOD,
1347
1348
        1,
        limit_flag,
1349
1350
        &file_id,
        &file_alignment);
1351

1352
1353
    /* the file record id is set to 0 if no memory is available for tracking
     * new records -- just fall through and ignore this record
1354
1355
1356
1357
1358
1359
1360
1361
     */
    if(file_id == 0)
    {
        if(newname != name)
            free(newname);
        return(NULL);
    }

1362
    /* search the hash table for this file record, and return if found */
1363
    HASH_FIND(hlink, posix_runtime->file_hash, &file_id, sizeof(darshan_record_id), file);
1364
    if(file)
1365
    {
1366
        if(newname != name)
1367
            free(newname);
1368
        return(file);
1369
1370
    }

1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
    /* no existing record, assign a new file record from the global array */
    file = &(posix_runtime->file_runtime_array[posix_runtime->file_array_ndx]);
    file->file_record = &(posix_runtime->file_record_array[posix_runtime->file_array_ndx]);
    file->file_record->f_id = file_id;
    file->file_record->rank = my_rank;
    file->file_record->counters[POSIX_MEM_ALIGNMENT] = darshan_mem_alignment;
    file->file_record->counters[POSIX_FILE_ALIGNMENT] = file_alignment;

    /* add new record to file hash table */
    HASH_ADD(hlink, posix_runtime->file_hash, file_record->f_id, sizeof(darshan_record_id), file);
    posix_runtime->file_array_ndx++;
1382
1383

    if(newname != name)
1384
        free(newname);
1385
1386
1387
    return(file);
}

1388
1389
1390
/* get a POSIX file record for the given file path, and also create a
 * reference structure using the returned file descriptor
 */
1391
static struct posix_file_runtime* posix_file_by_name_setfd(const char* name, int fd)
1392
{
1393
1394
    struct posix_file_runtime* file;
    struct posix_file_runtime_ref* ref;
1395

Shane Snyder's avatar
Shane Snyder committed
1396
    if(!posix_runtime || instrumentation_disabled)
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
        return(NULL);

    /* find file record by name first */
    file = posix_file_by_name(name);

    if(!file)
        return(NULL);

    /* search hash table for existing file ref for this fd */
    HASH_FIND(hlink, posix_runtime->fd_hash, &fd, sizeof(int), ref);
    if(ref)
    {
        /* we have a reference.  Make sure it points to the correct file
         * and return it
         */
        ref->file = file;
        return(file);
    }

    /* if we hit this point, then we don't have a reference for this fd
     * in the table yet.  Add it.
     */
    ref = malloc(sizeof(*ref));
    if(!ref)
        return(NULL);
    memset(ref, 0, sizeof(*ref));
Shane Snyder's avatar
Shane Snyder committed
1423

1424
1425
1426
1427
1428
1429
1430
    ref->file = file;
    ref->fd = fd;    
    HASH_ADD(hlink, posix_runtime->fd_hash, fd, sizeof(int), ref);

    return(file);
}

1431
/* get a POSIX file record for the given file descriptor */
1432
static struct posix_file_runtime* posix_file_by_fd(int fd)
Shane Snyder's avatar
Shane Snyder committed
1433
{
1434
    struct posix_file_runtime_ref* ref;
Shane Snyder's avatar
Shane Snyder committed
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446

    if(!posix_runtime || instrumentation_disabled)
        return(NULL);

    /* search hash table for existing file ref for this fd */
    HASH_FIND(hlink, posix_runtime->fd_hash, &fd, sizeof(int), ref);
    if(ref)
        return(ref->file);

    return(NULL);
}

1447
/* free up reference data structures for the given file descriptor */
1448
1449
static void posix_file_close_fd(int fd)
{
1450
    struct posix_file_runtime_ref* ref;
1451

Shane Snyder's avatar
Shane Snyder committed
1452
    if(!posix_runtime || instrumentation_disabled)
1453
1454
1455
1456
        return;

    /* search hash table for this fd */
    HASH_FIND(hlink, posix_runtime->fd_hash, &fd, sizeof(int), ref);
1457
    if(ref)
1458
1459
1460
1461
1462
1463
1464
    {
        /* we have a reference, delete it */
        HASH_DELETE(hlink, posix_runtime->fd_hash, ref);
        free(ref);
    }

    return;
1465
1466
}

1467
/* compare function for sorting file records by descending rank */
1468
static int posix_record_compare(const void* a_p, const void* b_p)
1469
{
1470
1471
    const struct darshan_posix_file* a = a_p;
    const struct darshan_posix_file* b = b_p;
1472

1473
    if(a->rank < b->rank)
1474
        return 1;
1475
    if(a->rank > b->rank)
1476
1477
1478
1479
1480
        return -1;

    return 0;
}

1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
/* finds the tracker structure for a given aio operation, removes it from
 * the linked list for the darshan_file structure, and returns a pointer.  
 *
 * returns NULL if aio operation not found
 */
static struct posix_aio_tracker* posix_aio_tracker_del(int fd, void *aiocbp)
{
    struct posix_aio_tracker *tracker = NULL, *iter, *tmp;
    struct posix_file_runtime* file;

    file = posix_file_by_fd(fd);
    if (file)
    {
        LL_FOREACH_SAFE(file->aio_list, iter, tmp)
        {
            if (iter->aiocbp == aiocbp)
            {
                LL_DELETE(file->aio_list, iter);
                tracker = iter;
                break;
            }
        }
    }

    return(tracker);
}

1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
/* adds a tracker for the given aio operation */
static void posix_aio_tracker_add(int fd, void *aiocbp)
{
    struct posix_aio_tracker* tracker;
    struct posix_file_runtime* file;

    file = posix_file_by_fd(fd);
    if (file)
    {
        tracker = malloc(sizeof(*tracker));
        if (tracker)
        {
            tracker->tm1 = darshan_core_wtime();
            tracker->aiocbp = aiocbp;
            LL_PREPEND(file->aio_list, tracker);
        }
    }

    return;
}

static void posix_record_reduction_op(void* infile_v, void* inoutfile_v,
    int *len, MPI_Datatype *datatype)
Shane Snyder's avatar