darshan-posix.c 66.5 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-posix-log-format.h"
34
#include "darshan-dynamic.h"
35

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

43
44
/* TODO: more libc, fgetc, etc etc etc. */

45
46
DARSHAN_FORWARD_DECL(open, int, (const char *path, int flags, ...));
DARSHAN_FORWARD_DECL(open64, int, (const char *path, int flags, ...));
47
48
DARSHAN_FORWARD_DECL(creat, int, (const char* path, mode_t mode));
DARSHAN_FORWARD_DECL(creat64, int, (const char* path, mode_t mode));
49
50
DARSHAN_FORWARD_DECL(fopen, FILE*, (const char *path, const char *mode));
DARSHAN_FORWARD_DECL(fopen64, FILE*, (const char *path, const char *mode));
51
52
53
54
DARSHAN_FORWARD_DECL(mkstemp, int, (char *template));
DARSHAN_FORWARD_DECL(mkostemp, int, (char *template, int flags));
DARSHAN_FORWARD_DECL(mkstemps, int, (char *template, int suffixlen));
DARSHAN_FORWARD_DECL(mkostemps, int, (char *template, int suffixlen, int flags));
55
56
57
58
59
60
61
62
DARSHAN_FORWARD_DECL(read, ssize_t, (int fd, void *buf, size_t count));
DARSHAN_FORWARD_DECL(write, ssize_t, (int fd, const void *buf, size_t count));
DARSHAN_FORWARD_DECL(pread, ssize_t, (int fd, void *buf, size_t count, off_t offset));
DARSHAN_FORWARD_DECL(pwrite, ssize_t, (int fd, const void *buf, size_t count, off_t offset));
DARSHAN_FORWARD_DECL(pread64, ssize_t, (int fd, void *buf, size_t count, off64_t offset));
DARSHAN_FORWARD_DECL(pwrite64, ssize_t, (int fd, const void *buf, size_t count, off64_t offset));
DARSHAN_FORWARD_DECL(readv, ssize_t, (int fd, const struct iovec *iov, int iovcnt));
DARSHAN_FORWARD_DECL(writev, ssize_t, (int fd, const struct iovec *iov, int iovcnt));
63
64
65
66
67
DARSHAN_FORWARD_DECL(fread, size_t, (void *ptr, size_t size, size_t nmemb, FILE *stream));
DARSHAN_FORWARD_DECL(fwrite, size_t, (const void *ptr, size_t size, size_t nmemb, FILE *stream));
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));
DARSHAN_FORWARD_DECL(fseek, int, (FILE *stream, long offset, int whence));
68
69
70
71
72
73
DARSHAN_FORWARD_DECL(__xstat, int, (int vers, const char* path, struct stat *buf));
DARSHAN_FORWARD_DECL(__xstat64, int, (int vers, const char* path, struct stat64 *buf));
DARSHAN_FORWARD_DECL(__lxstat, int, (int vers, const char* path, struct stat *buf));
DARSHAN_FORWARD_DECL(__lxstat64, int, (int vers, const char* path, struct stat64 *buf));
DARSHAN_FORWARD_DECL(__fxstat, int, (int vers, int fd, struct stat *buf));
DARSHAN_FORWARD_DECL(__fxstat64, int, (int vers, int fd, struct stat64 *buf));
Shane Snyder's avatar
Shane Snyder committed
74
75
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));
76
77
DARSHAN_FORWARD_DECL(fsync, int, (int fd));
DARSHAN_FORWARD_DECL(fdatasync, int, (int fd));
78
DARSHAN_FORWARD_DECL(close, int, (int fd));
79
DARSHAN_FORWARD_DECL(fclose, int, (FILE *fp));
80
81
82
83
84
85
86
87
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));
88

89
90
91
92
93
94
95
96
/* struct to track information about aio operations in flight */
struct posix_aio_tracker
{
    double tm1;
    void *aiocbp;
    struct posix_aio_tracker* next;
};

97
98
99
100
101
102
/* 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. 
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
 *
 * 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.
119
 */
120
struct posix_file_runtime
121
{
122
    struct darshan_posix_file* file_record;
123
124
125
    int64_t offset;
    int64_t last_byte_read;
    int64_t last_byte_written;
Shane Snyder's avatar
Shane Snyder committed
126
    enum darshan_io_type last_io_type;
127
128
129
    double last_meta_end;
    double last_read_end;
    double last_write_end;
130
131
132
133
    void* access_root;
    int access_count;
    void* stride_root;
    int stride_count;
134
    struct posix_aio_tracker* aio_list;
135
    UT_hash_handle hlink;
136
};
137

138
139
140
141
142
143
144
145
146
147
148
/* 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.
149
150
151
152
153
154
155
156
157
158
159
 *
 * 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.
160
 */
161
struct posix_file_runtime_ref
162
{
163
    struct posix_file_runtime* file;
164
165
166
167
    int fd;
    UT_hash_handle hlink;
};

168
169
170
171
/* The posix_runtime structure maintains necessary state for storing
 * POSIX file records and for coordinating with darshan-core at 
 * shutdown time.
 */
172
173
struct posix_runtime
{
174
    struct posix_file_runtime* file_runtime_array;
175
    struct darshan_posix_file* file_record_array;
176
    int file_array_size;
177
    int file_array_ndx;
178
179
    struct posix_file_runtime* file_hash;
    struct posix_file_runtime_ref* fd_hash;
180
181

    struct posix_file_runtime agg_file_runtime;
182
183
};

184
static struct posix_runtime *posix_runtime = NULL;
185
static pthread_mutex_t posix_runtime_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
Shane Snyder's avatar
Shane Snyder committed
186
static int instrumentation_disabled = 0;
187
static int my_rank = -1;
188
static int darshan_mem_alignment = 1;
189

190
191
192
193
194
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);
195
196
static void posix_aio_tracker_add(int fd, void *aiocbp);
static struct posix_aio_tracker* posix_aio_tracker_del(int fd, void *aiocbp);
197
static int posix_record_compare(const void* a, const void* b);
198
199
static void posix_record_reduction_op(void* infile_v, void* inoutfile_v,
    int *len, MPI_Datatype *datatype);
200
201
202
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);
203
204
205
206

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);
207
208
static void posix_shutdown(void);

209
210
#define POSIX_LOCK() pthread_mutex_lock(&posix_runtime_mutex)
#define POSIX_UNLOCK() pthread_mutex_unlock(&posix_runtime_mutex)
211

212
#define POSIX_RECORD_OPEN(__ret, __path, __mode, __stream_flag, __tm1, __tm2) do { \
213
    struct posix_file_runtime* file; \
214
    if(__ret < 0) break; \
215
    if(darshan_core_excluded_path(__path)) break; \
216
    file = posix_file_by_name_setfd(__path, __ret); \
217
    if(!file) break; \
218
    if(__mode) \
219
        file->file_record->counters[POSIX_MODE] = __mode; \
220
221
222
    file->offset = 0; \
    file->last_byte_written = 0; \
    file->last_byte_read = 0; \
223
    if(__stream_flag)\
224
        file->file_record->counters[POSIX_FOPENS] += 1; \
225
    else \
226
227
228
229
        file->file_record->counters[POSIX_OPENS] += 1; \
    if(file->file_record->fcounters[POSIX_F_OPEN_TIMESTAMP] == 0) \
        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); \
230
231
232
} while(0)

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

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

334
335
#define POSIX_LOOKUP_RECORD_STAT(__path, __statbuf, __tm1, __tm2) do { \
    struct posix_file_runtime* file; \
336
    if(darshan_core_excluded_path(__path)) break; \
337
338
339
340
341
342
343
344
    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 { \
345
346
    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; \
347
348
} while(0)

349
350
351
352
353
354
355
356
357
358
static double psx_wrap_time = 0.0;

#define PSX_PRE_WRAP() \
    double pre_wrap = darshan_core_wtime();

#define PSX_POST_WRAP() \
    double post_wrap = darshan_core_wtime(); \
    psx_wrap_time += (post_wrap-pre_wrap);


359
360
361
362
/**********************************************************
 *      Wrappers for POSIX I/O functions of interest      * 
 **********************************************************/

363
int DARSHAN_DECL(open)(const char *path, int flags, ...)
364
365
366
367
368
{
    int mode = 0;
    int ret;
    double tm1, tm2;

369
370
    PSX_PRE_WRAP();

371
372
    MAP_OR_FAIL(open);

373
    if(flags & O_CREAT) 
374
375
376
377
378
379
    {
        va_list arg;
        va_start(arg, flags);
        mode = va_arg(arg, int);
        va_end(arg);

380
        tm1 = darshan_core_wtime();
381
        ret = __real_open(path, flags, mode);
382
        tm2 = darshan_core_wtime();
383
384
385
    }
    else
    {
386
        tm1 = darshan_core_wtime();
387
        ret = __real_open(path, flags);
388
        tm2 = darshan_core_wtime();
389
390
    }

391
392
    POSIX_LOCK();
    posix_runtime_initialize();
393
    POSIX_RECORD_OPEN(ret, path, mode, 0, tm1, tm2);
394
    POSIX_UNLOCK();
395

396
397
    PSX_POST_WRAP();

398
399
400
    return(ret);
}

Shane Snyder's avatar
Shane Snyder committed
401
402
403
404
405
406
int DARSHAN_DECL(open64)(const char *path, int flags, ...)
{
    int mode = 0;
    int ret;
    double tm1, tm2;

407
408
    PSX_PRE_WRAP();

409
    MAP_OR_FAIL(open64);
Shane Snyder's avatar
Shane Snyder committed
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430

    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();
431
432
433
    POSIX_RECORD_OPEN(ret, path, mode, 0, tm1, tm2);
    POSIX_UNLOCK();

434
435
    PSX_POST_WRAP();

436
437
438
439
440
441
442
443
    return(ret);
}

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

444
445
    PSX_PRE_WRAP();

446
447
448
449
450
451
452
453
454
455
456
    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();

457
458
    PSX_POST_WRAP();

459
460
461
462
463
464
465
466
    return(ret);
}

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

467
468
    PSX_PRE_WRAP();

469
    MAP_OR_FAIL(creat64);
Shane Snyder's avatar
Shane Snyder committed
470

471
472
473
474
475
476
    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
477
478
479
    POSIX_RECORD_OPEN(ret, path, mode, 0, tm1, tm2);
    POSIX_UNLOCK();

480
481
    PSX_POST_WRAP();

Shane Snyder's avatar
Shane Snyder committed
482
483
484
    return(ret);
}

485
486
487
488
489
490
FILE* DARSHAN_DECL(fopen)(const char *path, const char *mode)
{
    FILE* ret;
    int fd;
    double tm1, tm2;

491
492
    PSX_PRE_WRAP();

493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
    MAP_OR_FAIL(fopen);

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

    if(ret == NULL)
        fd = -1;
    else
        fd = fileno(ret);

    POSIX_LOCK();
    posix_runtime_initialize();
    POSIX_RECORD_OPEN(fd, path, 0, 1, tm1, tm2);
    POSIX_UNLOCK();

509
510
    PSX_POST_WRAP();

511
512
513
514
515
516
517
518
519
    return(ret);
}

FILE* DARSHAN_DECL(fopen64)(const char *path, const char *mode)
{
    FILE* ret;
    int fd;
    double tm1, tm2;

520
521
    PSX_PRE_WRAP();

522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
    MAP_OR_FAIL(fopen64);

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

    if(ret == NULL)
        fd = -1;
    else
        fd = fileno(ret);

    POSIX_LOCK();
    posix_runtime_initialize();
    POSIX_RECORD_OPEN(fd, path, 0, 1, tm1, tm2);
    POSIX_UNLOCK();

538
539
    PSX_POST_WRAP();

540
541
542
    return(ret);
}

543
544
545
546
547
int DARSHAN_DECL(mkstemp)(char* template)
{
    int ret;
    double tm1, tm2;

548
549
    PSX_PRE_WRAP();

550
551
552
553
554
555
556
557
558
559
560
    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();

561
562
    PSX_POST_WRAP();

563
564
565
566
567
568
569
570
    return(ret);
}

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

571
572
    PSX_PRE_WRAP();

573
574
575
576
577
578
579
580
581
582
583
    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();

584
585
    PSX_POST_WRAP();

586
587
588
589
590
591
592
593
    return(ret);
}

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

594
595
    PSX_PRE_WRAP();

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

607
608
    PSX_POST_WRAP();

609
610
611
612
613
614
615
616
    return(ret);
}

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

617
618
    PSX_PRE_WRAP();

619
620
621
622
623
624
625
626
627
628
629
    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();

630
631
    PSX_POST_WRAP();

632
633
634
    return(ret);
}

635
636
637
638
639
640
ssize_t DARSHAN_DECL(read)(int fd, void *buf, size_t count)
{
    ssize_t ret;
    int aligned_flag = 0;
    double tm1, tm2;

641
642
    PSX_PRE_WRAP();

Shane Snyder's avatar
Shane Snyder committed
643
    MAP_OR_FAIL(read);
644

645
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
646
647
648
649
650
651
652
653
654
655

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

656
657
    PSX_POST_WRAP();

658
659
660
661
662
663
664
665
666
    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;

667
668
    PSX_PRE_WRAP();

669
670
    MAP_OR_FAIL(write);

671
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
672
673
674
675
676
677
678
679
680
681

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

682
683
    PSX_POST_WRAP();

684
685
686
687
688
689
690
691
692
    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;

693
694
    PSX_PRE_WRAP();

695
696
    MAP_OR_FAIL(pread);

697
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
698
699
700
701
702
703
704
705
706
707

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

708
709
    PSX_POST_WRAP();

710
711
712
713
714
715
716
717
718
    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;

719
720
    PSX_PRE_WRAP();

721
722
    MAP_OR_FAIL(pwrite);

723
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
724
725
726
727
728
729
730
731
732
733

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

734
735
    PSX_POST_WRAP();

736
737
738
739
740
741
742
743
744
    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;

745
746
    PSX_PRE_WRAP();

747
748
    MAP_OR_FAIL(pread64);

749
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
750
751
752
753
754
755
756
757
758
759

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

760
761
    PSX_POST_WRAP();

762
763
764
765
766
767
768
769
770
    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;

771
772
    PSX_PRE_WRAP();

773
774
    MAP_OR_FAIL(pwrite64);

775
    if((unsigned long)buf % darshan_mem_alignment == 0) aligned_flag = 1;
776
777
778
779
780
781
782
783
784
785

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

786
787
    PSX_POST_WRAP();

788
789
790
791
792
793
    return(ret);
}

ssize_t DARSHAN_DECL(readv)(int fd, const struct iovec *iov, int iovcnt)
{
    ssize_t ret;
794
    int aligned_flag = 1;
795
796
797
    int i;
    double tm1, tm2;

798
799
    PSX_PRE_WRAP();

800
    MAP_OR_FAIL(readv);
801

802
803
804
805
    for(i=0; i<iovcnt; i++)
    {
        if(((unsigned long)iov[i].iov_base % darshan_mem_alignment) != 0)
            aligned_flag = 0;
806
    }
807
808
809
810
811
812

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

    POSIX_LOCK();
813
    posix_runtime_initialize();
814
815
816
    POSIX_RECORD_READ(ret, fd, 0, 0, aligned_flag, 0, tm1, tm2);
    POSIX_UNLOCK();

817
818
    PSX_POST_WRAP();

819
820
821
822
823
824
    return(ret);
}

ssize_t DARSHAN_DECL(writev)(int fd, const struct iovec *iov, int iovcnt)
{
    ssize_t ret;
825
    int aligned_flag = 1;
826
827
828
    int i;
    double tm1, tm2;

829
830
    PSX_PRE_WRAP();

831
    MAP_OR_FAIL(writev);
832

833
834
835
836
    for(i=0; i<iovcnt; i++)
    {
        if(((unsigned long)iov[i].iov_base % darshan_mem_alignment) != 0)
            aligned_flag = 0;
837
    }
838
839
840
841
842
843

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

    POSIX_LOCK();
844
    posix_runtime_initialize();
845
846
847
    POSIX_RECORD_WRITE(ret, fd, 0, 0, aligned_flag, 0, tm1, tm2);
    POSIX_UNLOCK();

848
849
    PSX_POST_WRAP();

850
851
852
    return(ret);
}

853
854
855
856
857
858
size_t DARSHAN_DECL(fread)(void *ptr, size_t size, size_t nmemb, FILE *stream)
{
    size_t ret;
    int aligned_flag = 0;
    double tm1, tm2;

859
860
    PSX_PRE_WRAP();

861
862
    MAP_OR_FAIL(fread);

863
    if((unsigned long)ptr % darshan_mem_alignment == 0) aligned_flag = 1;
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882

    tm1 = darshan_core_wtime();
    ret = __real_fread(ptr, size, nmemb, stream);
    tm2 = darshan_core_wtime();

    POSIX_LOCK();
    posix_runtime_initialize();
    if(ret > 0)
    {
        POSIX_RECORD_READ(size*ret, fileno(stream), 0, 0,
            aligned_flag, 1, tm1, tm2);
    }
    else
    {
        POSIX_RECORD_READ(ret, fileno(stream), 0, 0,
            aligned_flag, 1, tm1, tm2);
    }
    POSIX_UNLOCK();

883
884
    PSX_POST_WRAP();

885
886
887
888
889
890
891
892
893
    return(ret);
}

size_t DARSHAN_DECL(fwrite)(const void *ptr, size_t size, size_t nmemb, FILE *stream)
{
    size_t ret;
    int aligned_flag = 0;
    double tm1, tm2;

894
895
    PSX_PRE_WRAP();

896
897
    MAP_OR_FAIL(fwrite);

898
    if((unsigned long)ptr % darshan_mem_alignment == 0) aligned_flag = 1;
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917

    tm1 = darshan_core_wtime();
    ret = __real_fwrite(ptr, size, nmemb, stream);
    tm2 = darshan_core_wtime();

    POSIX_LOCK();
    posix_runtime_initialize();
    if(ret > 0)
    {
        POSIX_RECORD_WRITE(size*ret, fileno(stream), 0, 0,
            aligned_flag, 1, tm1, tm2);
    }
    else
    {
        POSIX_RECORD_WRITE(ret, fileno(stream), 0, 0,
            aligned_flag, 1, tm1, tm2);
    }
    POSIX_UNLOCK();

918
919
    PSX_POST_WRAP();

920
921
922
923
924
925
926
927
928
    return(ret);
}

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

929
930
    PSX_PRE_WRAP();

931
932
933
934
935
936
937
938
939
940
941
942
943
944
    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;
945
946
947
948
            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;
949
950
951
952
        }
        POSIX_UNLOCK();
    }

953
954
    PSX_POST_WRAP();

955
956
957
958
959
960
961
962
963
    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;

964
965
    PSX_PRE_WRAP();

966
967
968
969
970
971
972
973
974
975
976
977
978
979
    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;
980
981
982
983
            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;
984
985
986
987
        }
        POSIX_UNLOCK();
    }

988
989
    PSX_POST_WRAP();

990
991
992
993
994
995
996
997
998
    return(ret);
}

int DARSHAN_DECL(fseek)(FILE *stream, long offset, int whence)
{
    int ret;
    struct posix_file_runtime* file;
    double tm1, tm2;

999
1000
    PSX_PRE_WRAP();

1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
    MAP_OR_FAIL(fseek);

    tm1 = darshan_core_wtime();
    ret = __real_fseek(stream, offset, whence);
    tm2 = darshan_core_wtime();

    if(ret >= 0)
    {
        POSIX_LOCK();
        posix_runtime_initialize();
        file = posix_file_by_fd(fileno(stream));
        if(file)
        {
1014
            file->offset = ftell(stream);
1015
1016
1017
1018
            DARSHAN_TIMER_INC_NO_OVERLAP(
                file->file_record->fcounters[POSIX_F_META_TIME],
                tm1, tm2, file->last_meta_end);
            file->file_record->counters[POSIX_FSEEKS] += 1;
1019
1020
1021
1022
        }
        POSIX_UNLOCK();
    }

1023
1024
    PSX_POST_WRAP();

1025
1026
1027
    return(ret);
}

1028
1029
1030
1031
1032
int DARSHAN_DECL(__xstat)(int vers, const char *path, struct stat *buf)
{
    int ret;
    double tm1, tm2;

1033
1034
    PSX_PRE_WRAP();

1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
    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();

1049
1050
    PSX_POST_WRAP();

1051
1052
1053
1054
1055
1056
1057
1058
    return(ret);
}

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

1059
1060
    PSX_PRE_WRAP();

1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
    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();

1075
1076
    PSX_POST_WRAP();

1077
1078
1079
1080
1081
1082
1083
1084
    return(ret);
}

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

1085
1086
    PSX_PRE_WRAP();

1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
    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();

1101
1102
    PSX_POST_WRAP();

1103
1104
1105
1106
1107
1108
1109
1110
    return(ret);
}

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

1111
1112
    PSX_PRE_WRAP();

1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
    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();

1127
1128
    PSX_POST_WRAP();

1129
1130
1131
1132
1133
1134
1135
1136
1137
    return(ret);
}

int DARSHAN_DECL(__fxstat)(int vers, int fd, struct stat *buf)
{
    int ret;
    struct posix_file_runtime* file;
    double tm1, tm2;

1138
1139
    PSX_PRE_WRAP();

1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
    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();

1158
1159
    PSX_POST_WRAP();

1160
1161
1162
1163
1164
1165
1166
1167
1168
    return(ret);
}

int DARSHAN_DECL(__fxstat64)(int vers, int fd, struct stat64 *buf)
{
    int ret;
    struct posix_file_runtime* file;
    double tm1, tm2;

1169
1170
    PSX_PRE_WRAP();

1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
    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();

1189
1190
    PSX_POST_WRAP();

1191
1192
1193
    return(ret);
}

Shane Snyder's avatar
Shane Snyder committed
1194
1195
1196
1197
1198
1199
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;

1200
1201
    PSX_PRE_WRAP();

Shane Snyder's avatar
Shane Snyder committed
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
    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)
    {
1213
        file->file_record->counters[POSIX_MMAPS] += 1;
Shane Snyder's avatar
Shane Snyder committed
1214
1215
1216
    }
    POSIX_UNLOCK();

1217
1218
    PSX_POST_WRAP();

Shane Snyder's avatar
Shane Snyder committed
1219
1220
1221
1222
1223
1224
1225
1226
1227
    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;

1228
1229
    PSX_PRE_WRAP();

Shane Snyder's avatar
Shane Snyder committed
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
    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)
    {
1241
        file->file_record->counters[POSIX_MMAPS] += 1;
Shane Snyder's avatar
Shane Snyder committed
1242
1243
1244
    }
    POSIX_UNLOCK();

1245
1246
    PSX_POST_WRAP();

Shane Snyder's avatar
Shane Snyder committed
1247
1248
1249
    return(ret);
}

1250
1251
1252
1253
1254
1255
int DARSHAN_DECL(fsync)(int fd)
{
    int ret;
    struct posix_file_runtime* file;
    double tm1, tm2;

1256
1257
    PSX_PRE_WRAP();

1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
    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)
    {
1272
1273
1274
1275
        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;
1276
1277
1278
    }
    POSIX_UNLOCK();

1279
1280
    PSX_POST_WRAP();

1281
1282
1283
1284
1285
1286
1287
1288
1289
    return(ret);
}

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

1290
1291
    PSX_PRE_WRAP();

1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
    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)
    {
1306
1307
1308
1309
        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;
1310
1311
1312
    }
    POSIX_UNLOCK();

1313
1314
    PSX_POST_WRAP();

1315
1316
1317
    return(ret);
}

1318
1319
int DARSHAN_DECL(close)(int fd)
{
1320
    struct posix_file_runtime* file;
1321
1322
1323
    double tm1, tm2;
    int ret;

1324
1325
    PSX_PRE_WRAP();

1326
1327
1328
1329
1330
1331
1332
1333
    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
1334
1335
1336
    file = posix_file_by_fd(fd);
    if(file)
    {
1337
1338
        file->last_byte_written = 0;
        file->last_byte_read = 0;
1339
1340
1341
1342
1343
        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
1344
1345
        posix_file_close_fd(fd);
    }
1346
1347
    POSIX_UNLOCK();    

1348
1349
    PSX_POST_WRAP();

1350
1351
1352
    return(ret);
}

1353
1354
1355
1356
1357
1358
1359
int DARSHAN_DECL(fclose)(FILE *fp)
{
    struct posix_file_runtime* file;
    int fd = fileno(fp);
    double tm1, tm2;
    int ret;

1360
1361
    PSX_PRE_WRAP();

1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
    MAP_OR_FAIL(fclose);

    tm1 = darshan_core_wtime();
    ret = __real_fclose(fp);