darshan-posix.c 45.8 KB
Newer Older
1
2
3
4
5
/*
 *  (C) 2009 by Argonne National Laboratory.
 *      See COPYRIGHT in top-level directory.
 */

6
#include "darshan-runtime-config.h"
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#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>
21
22
#define __USE_GNU
#include <pthread.h>
23
24
25

#include "darshan.h"

26
#ifndef HAVE_OFF64_T
27
28
29
typedef int64_t off64_t;
#endif

30
31
extern char* __progname_full;

32
#ifdef DARSHAN_PRELOAD
33
34
35
#define __USE_GNU
#include <dlfcn.h>
#include <stdlib.h>
36

37
38
39
40
41
#define DARSHAN_FORWARD_DECL(name,ret,args) \
  ret (*__real_ ## name)args = NULL;

#define DARSHAN_DECL(__name) __name

42
43
44
45
46
47
48
49
50
51
52
53
54
#define DARSHAN_MPI_CALL(func) __real_ ## func

#define MAP_OR_FAIL(func) \
    if (!(__real_ ## func)) \
    { \
        __real_ ## func = dlsym(RTLD_NEXT, #func); \
        if(!(__real_ ## func)) { \
           fprintf(stderr, "Darshan failed to map symbol: %s\n", #func); \
           exit(1); \
       } \
    }


55
extern double (*__real_PMPI_Wtime)(void);
56

57
58
59
60
61
62
63
#else

#define DARSHAN_FORWARD_DECL(name,ret,args) \
  extern ret __real_ ## name args;

#define DARSHAN_DECL(__name) __wrap_ ## __name

64
65
66
67
#define MAP_OR_FAIL(func)

#define DARSHAN_MPI_CALL(func) func

68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
#endif

DARSHAN_FORWARD_DECL(creat, int, (const char* path, mode_t mode));
DARSHAN_FORWARD_DECL(creat64, int, (const char* path, mode_t mode));
DARSHAN_FORWARD_DECL(open, int, (const char *path, int flags, ...));
DARSHAN_FORWARD_DECL(open64, int, (const char *path, int flags, ...));
DARSHAN_FORWARD_DECL(close, int, (int fd));
DARSHAN_FORWARD_DECL(write, ssize_t, (int fd, const void *buf, size_t count));
DARSHAN_FORWARD_DECL(read, ssize_t, (int fd, void *buf, size_t count));
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(pread, ssize_t, (int fd, 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(pwrite, ssize_t, (int fd, const void *buf, size_t count, off_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));
DARSHAN_FORWARD_DECL(__fxstat, int, (int vers, int fd, struct stat *buf));
DARSHAN_FORWARD_DECL(__fxstat64, int, (int vers, int fd, 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(__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(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));
DARSHAN_FORWARD_DECL(fopen, FILE*, (const char *path, const char *mode));
DARSHAN_FORWARD_DECL(fopen64, FILE*, (const char *path, const char *mode));
DARSHAN_FORWARD_DECL(fclose, int, (FILE *fp));
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(fseek, int, (FILE *stream, long offset, int whence));
DARSHAN_FORWARD_DECL(fsync, int, (int fd));
DARSHAN_FORWARD_DECL(fdatasync, int, (int fd));

103
pthread_mutex_t cp_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
104
105
struct darshan_job_runtime* darshan_global_job = NULL;
static int my_rank = -1;
106
static struct stat64 cp_stat_buf;
107
static int darshan_mem_alignment = 1;
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

/* these are paths that we will not trace */
static char* exclusions[] = {
"/etc/",
"/dev/",
"/usr/",
"/bin/",
"/boot/",
"/lib/",
"/opt/",
"/sbin/",
"/sys/",
"/proc/",
NULL
};

124
125
static double posix_wtime(void);

126
127
static void cp_access_counter(struct darshan_file_runtime* file, ssize_t size,     enum cp_counter_type type);

Philip Carns's avatar
Philip Carns committed
128
#define CP_RECORD_WRITE(__ret, __fd, __count, __pwrite_flag, __pwrite_offset, __aligned, __stream_flag, __tm1, __tm2) do{ \
129
    size_t stride; \
Philip Carns's avatar
Philip Carns committed
130
    int64_t this_offset; \
131
132
    int64_t file_alignment; \
    struct darshan_file_runtime* file; \
133
    double __elapsed = __tm2-__tm1; \
134
135
136
    if(__ret < 0) break; \
    file = darshan_file_by_fd(__fd); \
    if(!file) break; \
Philip Carns's avatar
Philip Carns committed
137
138
139
140
    if(__pwrite_flag) \
        this_offset = __pwrite_offset; \
    else \
        this_offset = file->offset; \
141
    file_alignment = CP_VALUE(file, CP_FILE_ALIGNMENT); \
Philip Carns's avatar
Philip Carns committed
142
    if(this_offset > file->last_byte_written) \
143
        CP_INC(file, CP_SEQ_WRITES, 1); \
Philip Carns's avatar
Philip Carns committed
144
    if(this_offset == (file->last_byte_written + 1)) \
145
        CP_INC(file, CP_CONSEC_WRITES, 1); \
Philip Carns's avatar
Philip Carns committed
146
    if(this_offset > 0 && this_offset > file->last_byte_written \
147
        && file->last_byte_written != 0) \
Philip Carns's avatar
Philip Carns committed
148
        stride = this_offset - file->last_byte_written - 1; \
149
150
    else \
        stride = 0; \
Philip Carns's avatar
Philip Carns committed
151
152
153
    file->last_byte_written = this_offset + __ret - 1; \
    file->offset = this_offset + __ret; \
    CP_MAX(file, CP_MAX_BYTE_WRITTEN, (this_offset + __ret -1)); \
154
155
156
157
158
159
160
161
162
    CP_INC(file, CP_BYTES_WRITTEN, __ret); \
    if(__stream_flag) \
        CP_INC(file, CP_POSIX_FWRITES, 1); \
    else \
        CP_INC(file, CP_POSIX_WRITES, 1); \
    CP_BUCKET_INC(file, CP_SIZE_WRITE_0_100, __ret); \
    cp_access_counter(file, stride, CP_COUNTER_STRIDE); \
    if(!__aligned) \
        CP_INC(file, CP_MEM_NOT_ALIGNED, 1); \
Philip Carns's avatar
Philip Carns committed
163
    if(file_alignment && (this_offset % file_alignment) != 0) \
164
165
166
167
168
        CP_INC(file, CP_FILE_NOT_ALIGNED, 1); \
    cp_access_counter(file, __ret, CP_COUNTER_ACCESS); \
    if(file->last_io_type == CP_READ) \
        CP_INC(file, CP_RW_SWITCHES, 1); \
    file->last_io_type = CP_WRITE; \
169
    CP_F_INC(file, CP_F_POSIX_WRITE_TIME, (__elapsed)); \
170
171
172
    if(CP_F_VALUE(file, CP_F_WRITE_START_TIMESTAMP) == 0) \
        CP_F_SET(file, CP_F_WRITE_START_TIMESTAMP, __tm1); \
    CP_F_SET(file, CP_F_WRITE_END_TIMESTAMP, __tm2); \
173
174
175
    if(CP_F_VALUE(file, CP_F_MAX_WRITE_TIME) < __elapsed){ \
        CP_F_SET(file, CP_F_MAX_WRITE_TIME, __elapsed); \
        CP_SET(file, CP_MAX_WRITE_TIME_SIZE, __ret); } \
176
177
} while(0)

178
#define CP_RECORD_READ(__ret, __fd, __count, __pread_flag, __pread_offset, __aligned, __stream_flag, __tm1, __tm2) do{ \
179
    size_t stride; \
180
    int64_t this_offset; \
181
182
    struct darshan_file_runtime* file; \
    int64_t file_alignment; \
183
    double __elapsed = __tm2-__tm1; \
184
185
186
    if(__ret < 0) break; \
    file = darshan_file_by_fd(__fd); \
    if(!file) break; \
187
188
189
190
    if(__pread_flag)\
        this_offset = __pread_offset; \
    else \
        this_offset = file->offset; \
191
    file_alignment = CP_VALUE(file, CP_FILE_ALIGNMENT); \
192
    if(this_offset > file->last_byte_read) \
193
        CP_INC(file, CP_SEQ_READS, 1); \
194
    if(this_offset == (file->last_byte_read + 1)) \
195
        CP_INC(file, CP_CONSEC_READS, 1); \
196
    if(this_offset > 0 && this_offset > file->last_byte_read \
197
        && file->last_byte_read != 0) \
198
        stride = this_offset - file->last_byte_read - 1; \
199
200
    else \
        stride = 0; \
201
202
203
    file->last_byte_read = this_offset + __ret - 1; \
    CP_MAX(file, CP_MAX_BYTE_READ, (this_offset + __ret -1)); \
    file->offset = this_offset + __ret; \
204
205
206
207
208
209
210
211
212
    CP_INC(file, CP_BYTES_READ, __ret); \
    if(__stream_flag)\
        CP_INC(file, CP_POSIX_FREADS, 1); \
    else\
        CP_INC(file, CP_POSIX_READS, 1); \
    CP_BUCKET_INC(file, CP_SIZE_READ_0_100, __ret); \
    cp_access_counter(file, stride, CP_COUNTER_STRIDE); \
    if(!__aligned) \
        CP_INC(file, CP_MEM_NOT_ALIGNED, 1); \
213
    if(file_alignment && (this_offset % file_alignment) != 0) \
214
215
216
217
218
        CP_INC(file, CP_FILE_NOT_ALIGNED, 1); \
    cp_access_counter(file, __ret, CP_COUNTER_ACCESS); \
    if(file->last_io_type == CP_WRITE) \
        CP_INC(file, CP_RW_SWITCHES, 1); \
    file->last_io_type = CP_READ; \
219
    CP_F_INC(file, CP_F_POSIX_READ_TIME, (__elapsed)); \
220
221
222
    if(CP_F_VALUE(file, CP_F_READ_START_TIMESTAMP) == 0) \
        CP_F_SET(file, CP_F_READ_START_TIMESTAMP, __tm1); \
    CP_F_SET(file, CP_F_READ_END_TIMESTAMP, __tm2); \
223
224
225
    if(CP_F_VALUE(file, CP_F_MAX_READ_TIME) < __elapsed){ \
        CP_F_SET(file, CP_F_MAX_READ_TIME, __elapsed); \
        CP_SET(file, CP_MAX_READ_TIME_SIZE, __ret); } \
226
227
} while(0)

228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
#define CP_LOOKUP_RECORD_STAT(__path, __statbuf, __tm1, __tm2) do { \
    char* exclude; \
    int tmp_index = 0; \
    struct darshan_file_runtime* file; \
    while((exclude = exclusions[tmp_index])) { \
        if(!(strncmp(exclude, __path, strlen(exclude)))) \
            break; \
        tmp_index++; \
    } \
    if(exclude) break; \
    file = darshan_file_by_name(__path); \
    if (file) \
    { \
        CP_RECORD_STAT(file, __statbuf, __tm1, __tm2); \
    } \
} while(0)

    
246
247
248
249
250
251
252
253
254
255
256
#define CP_RECORD_STAT(__file, __statbuf, __tm1, __tm2) do { \
    if(!CP_VALUE((__file), CP_FILE_ALIGNMENT)){ \
        CP_SET((__file), CP_DEVICE, (__statbuf)->st_dev); \
        CP_SET((__file), CP_FILE_ALIGNMENT, (__statbuf)->st_blksize); \
        CP_SET((__file), CP_SIZE_AT_OPEN, (__statbuf)->st_size); \
    }\
    (__file)->log_file->rank = my_rank; \
    CP_F_INC(__file, CP_F_POSIX_META_TIME, (__tm2-__tm1)); \
    CP_INC(__file, CP_POSIX_STATS, 1); \
} while(0)

257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
#define CP_RECORD_OPEN(__ret, __path, __mode, __stream_flag, __tm1, __tm2) do { \
    struct darshan_file_runtime* file; \
    char* exclude; \
    int tmp_index = 0; \
    int hash_index; \
    if(__ret < 0) break; \
    while((exclude = exclusions[tmp_index])) { \
        if(!(strncmp(exclude, __path, strlen(exclude)))) \
            break; \
        tmp_index++; \
    } \
    if(exclude) break; \
    file = darshan_file_by_name(__path); \
    if(!file) break; \
    if(file->fd != -1) break; /* TODO: handle multiple concurrent opens */ \
    file->fd = __ret; \
    if(!CP_VALUE(file, CP_FILE_ALIGNMENT)){ \
274
        if(fstat64(file->fd, &cp_stat_buf) == 0) {\
275
            CP_SET(file, CP_DEVICE, cp_stat_buf.st_dev); \
276
            CP_SET(file, CP_FILE_ALIGNMENT, cp_stat_buf.st_blksize); \
277
            CP_SET(file, CP_SIZE_AT_OPEN, cp_stat_buf.st_size); \
278
        }\
279
280
281
282
283
284
285
286
287
288
289
290
    }\
    file->log_file->rank = my_rank; \
    if(__mode) \
        CP_SET(file, CP_MODE, __mode); \
    file->offset = 0; \
    file->last_byte_written = 0; \
    file->last_byte_read = 0; \
    if(__stream_flag)\
        CP_INC(file, CP_POSIX_FOPENS, 1); \
    else \
        CP_INC(file, CP_POSIX_OPENS, 1); \
    if(CP_F_VALUE(file, CP_F_OPEN_TIMESTAMP) == 0) \
291
        CP_F_SET(file, CP_F_OPEN_TIMESTAMP, posix_wtime()); \
292
293
294
295
296
297
298
299
300
    CP_F_INC(file, CP_F_POSIX_META_TIME, (__tm2-__tm1)); \
    hash_index = file->fd & CP_HASH_MASK; \
    file->fd_prev = NULL; \
    file->fd_next = darshan_global_job->fd_table[hash_index]; \
    if(file->fd_next) \
        file->fd_next->fd_prev = file; \
    darshan_global_job->fd_table[hash_index] = file; \
} while (0)

301
int DARSHAN_DECL(close)(int fd)
302
303
304
305
306
307
308
{
    struct darshan_file_runtime* file;
    int hash_index;
    int tmp_fd = fd;
    double tm1, tm2;
    int ret;

309
310
    MAP_OR_FAIL(close);

311
312
313
314
315
316
317
318
319
320
321
    tm1 = darshan_wtime();
    ret = __real_close(fd);
    tm2 = darshan_wtime();

    CP_LOCK();
    file = darshan_file_by_fd(tmp_fd);
    if(file)
    {
        file->fd = -1;
        file->last_byte_written = 0;
        file->last_byte_read = 0;
322
        CP_F_SET(file, CP_F_CLOSE_TIMESTAMP, posix_wtime());
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
        CP_F_INC(file, CP_F_POSIX_META_TIME, (tm2-tm1));
        if(file->fd_prev == NULL)
        {
            /* head of fd hash table list */
            hash_index = tmp_fd & CP_HASH_MASK;
            darshan_global_job->fd_table[hash_index] = file->fd_next;
            if(file->fd_next)
                file->fd_next->fd_prev = NULL;
        }
        else
        {
            if(file->fd_prev)
                file->fd_prev->fd_next = file->fd_next;
            if(file->fd_next)
                file->fd_next->fd_prev = file->fd_prev;
        }
        file->fd_prev = NULL;
        file->fd_next = NULL;
        darshan_global_job->darshan_mru_file = file; /* in case we open it again */
    }
    CP_UNLOCK();

    return(ret);
}

348
int DARSHAN_DECL(fclose)(FILE *fp)
349
350
351
352
353
354
355
{
    struct darshan_file_runtime* file;
    int hash_index;
    int tmp_fd = fileno(fp);
    double tm1, tm2;
    int ret;

356
357
    MAP_OR_FAIL(fclose);

358
359
360
361
362
363
364
365
366
367
368
    tm1 = darshan_wtime();
    ret = __real_fclose(fp);
    tm2 = darshan_wtime();
    
    CP_LOCK();
    file = darshan_file_by_fd(tmp_fd);
    if(file)
    {
        file->fd = -1;
        file->last_byte_written = 0;
        file->last_byte_read = 0;
369
        CP_F_SET(file, CP_F_CLOSE_TIMESTAMP, posix_wtime());
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
        CP_F_INC(file, CP_F_POSIX_META_TIME, (tm2-tm1));
        if(file->fd_prev == NULL)
        {
            /* head of fd hash table list */
            hash_index = tmp_fd & CP_HASH_MASK;
            darshan_global_job->fd_table[hash_index] = file->fd_next;
            if(file->fd_next)
                file->fd_next->fd_prev = NULL;
        }
        else
        {
            if(file->fd_prev)
                file->fd_prev->fd_next = file->fd_next;
            if(file->fd_next)
                file->fd_next->fd_prev = file->fd_prev;
        }
        file->fd_prev = NULL;
        file->fd_next = NULL;
        darshan_global_job->darshan_mru_file = file; /* in case we open it again */
    }
    CP_UNLOCK();

    return(ret);
}


396
int DARSHAN_DECL(fsync)(int fd)
397
398
399
400
401
{
    int ret;
    struct darshan_file_runtime* file;
    double tm1, tm2;

402
403
    MAP_OR_FAIL(fsync);

404
405
406
407
408
409
410
411
412
413
414
    tm1 = darshan_wtime();
    ret = __real_fsync(fd);
    tm2 = darshan_wtime();

    if(ret < 0)
        return(ret);

    CP_LOCK();
    file = darshan_file_by_fd(fd);
    if(file)
    {
415
        CP_F_INC(file, CP_F_POSIX_WRITE_TIME, (tm2-tm1));
416
417
418
419
420
421
422
        CP_INC(file, CP_POSIX_FSYNCS, 1);
    }
    CP_UNLOCK();

    return(ret);
}

423
int DARSHAN_DECL(fdatasync)(int fd)
424
425
426
427
428
{
    int ret;
    struct darshan_file_runtime* file;
    double tm1, tm2;

429
430
    MAP_OR_FAIL(fdatasync);

431
432
433
434
435
436
437
438
439
440
    tm1 = darshan_wtime();
    ret = __real_fdatasync(fd);
    tm2 = darshan_wtime();
    if(ret < 0)
        return(ret);

    CP_LOCK();
    file = darshan_file_by_fd(fd);
    if(file)
    {
441
        CP_F_INC(file, CP_F_POSIX_WRITE_TIME, (tm2-tm1));
442
443
444
445
446
447
448
449
        CP_INC(file, CP_POSIX_FDSYNCS, 1);
    }
    CP_UNLOCK();

    return(ret);
}


450
void* DARSHAN_DECL(mmap64)(void *addr, size_t length, int prot, int flags,
451
452
453
454
455
    int fd, off64_t offset)
{
    void* ret;
    struct darshan_file_runtime* file;

456
457
    MAP_OR_FAIL(mmap64);

458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
    ret = __real_mmap64(addr, length, prot, flags, fd, offset);
    if(ret == MAP_FAILED)
        return(ret);

    CP_LOCK();
    file = darshan_file_by_fd(fd);
    if(file)
    {
        CP_INC(file, CP_POSIX_MMAPS, 1);
    }
    CP_UNLOCK();

    return(ret);
}


474
void* DARSHAN_DECL(mmap)(void *addr, size_t length, int prot, int flags,
475
476
477
478
479
    int fd, off_t offset)
{
    void* ret;
    struct darshan_file_runtime* file;

480
481
    MAP_OR_FAIL(mmap);

482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
    ret = __real_mmap(addr, length, prot, flags, fd, offset);
    if(ret == MAP_FAILED)
        return(ret);

    CP_LOCK();
    file = darshan_file_by_fd(fd);
    if(file)
    {
        CP_INC(file, CP_POSIX_MMAPS, 1);
    }
    CP_UNLOCK();

    return(ret);
}

497
int DARSHAN_DECL(creat)(const char* path, mode_t mode)
498
499
500
501
{
    int ret;
    double tm1, tm2;

502
503
    MAP_OR_FAIL(creat);

504
505
506
507
508
509
510
511
512
513
514
    tm1 = darshan_wtime();
    ret = __real_creat(path, mode);
    tm2 = darshan_wtime();

    CP_LOCK();
    CP_RECORD_OPEN(ret, path, mode, 0, tm1, tm2);
    CP_UNLOCK();

    return(ret);
}

515
int DARSHAN_DECL(creat64)(const char* path, mode_t mode)
516
517
518
519
{
    int ret;
    double tm1, tm2;

520
521
    MAP_OR_FAIL(creat64);

522
523
524
525
526
527
528
529
530
531
532
    tm1 = darshan_wtime();
    ret = __real_creat64(path, mode);
    tm2 = darshan_wtime();

    CP_LOCK();
    CP_RECORD_OPEN(ret, path, mode, 0, tm1, tm2);
    CP_UNLOCK();

    return(ret);
}

533
int DARSHAN_DECL(open64)(const char* path, int flags, ...)
534
535
536
537
538
{
    int mode = 0;
    int ret;
    double tm1, tm2;

539
540
    MAP_OR_FAIL(open64);

541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
    if (flags & O_CREAT) 
    {
        va_list arg;
        va_start(arg, flags);
        mode = va_arg(arg, int);
        va_end(arg);

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

    CP_LOCK();
    CP_RECORD_OPEN(ret, path, mode, 0, tm1, tm2);
    CP_UNLOCK();

    return(ret);
}

566
int DARSHAN_DECL(open)(const char *path, int flags, ...)
567
568
569
570
571
{
    int mode = 0;
    int ret;
    double tm1, tm2;

572
573
    MAP_OR_FAIL(open);

574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
    if (flags & O_CREAT) 
    {
        va_list arg;
        va_start(arg, flags);
        mode = va_arg(arg, int);
        va_end(arg);

        tm1 = darshan_wtime();
        ret = __real_open(path, flags, mode);
        tm2 = darshan_wtime();
    }
    else
    {
        tm1 = darshan_wtime();
        ret = __real_open(path, flags);
        tm2 = darshan_wtime();
    }

    CP_LOCK();
    CP_RECORD_OPEN(ret, path, mode, 0, tm1, tm2);
    CP_UNLOCK();

    return(ret);
}

599
FILE* DARSHAN_DECL(fopen64)(const char *path, const char *mode)
600
601
602
603
604
{
    FILE* ret;
    int fd;
    double tm1, tm2;

605
606
    MAP_OR_FAIL(fopen64);

607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
    tm1 = darshan_wtime();
    ret = __real_fopen64(path, mode);
    tm2 = darshan_wtime();
    if(ret == 0)
        fd = -1;
    else
        fd = fileno(ret);

    CP_LOCK();
    CP_RECORD_OPEN(fd, path, 0, 1, tm1, tm2);
    CP_UNLOCK();

    return(ret);
}

622
FILE* DARSHAN_DECL(fopen)(const char *path, const char *mode)
623
624
625
626
627
{
    FILE* ret;
    int fd;
    double tm1, tm2;

628
629
    MAP_OR_FAIL(fopen);

630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
    tm1 = darshan_wtime();
    ret = __real_fopen(path, mode);
    tm2 = darshan_wtime();
    if(ret == 0)
        fd = -1;
    else
        fd = fileno(ret);

    CP_LOCK();
    CP_RECORD_OPEN(fd, path, 0, 1, tm1, tm2);
    CP_UNLOCK();

    return(ret);
}

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

650
651
    MAP_OR_FAIL(__xstat64);

652
653
654
655
656
657
658
    tm1 = darshan_wtime();
    ret = __real___xstat64(vers, path, buf);
    tm2 = darshan_wtime();
    if(ret < 0 || !S_ISREG(buf->st_mode))
        return(ret);

    CP_LOCK();
659
    CP_LOOKUP_RECORD_STAT(path, buf, tm1, tm2);
660
661
662
663
664
    CP_UNLOCK();

    return(ret);
}

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

670
671
    MAP_OR_FAIL(__lxstat64);

672
673
674
675
676
677
678
    tm1 = darshan_wtime();
    ret = __real___lxstat64(vers, path, buf);
    tm2 = darshan_wtime();
    if(ret < 0 || !S_ISREG(buf->st_mode))
        return(ret);

    CP_LOCK();
679
    CP_LOOKUP_RECORD_STAT(path, buf, tm1, tm2);
680
681
682
683
684
    CP_UNLOCK();

    return(ret);
}

685
int DARSHAN_DECL(__fxstat64)(int vers, int fd, struct stat64 *buf)
686
687
688
689
690
{
    int ret;
    struct darshan_file_runtime* file;
    double tm1, tm2;

691
692
    MAP_OR_FAIL(__fxstat64);

693
694
695
696
697
698
699
700
701
702
703
704
705
706
    tm1 = darshan_wtime();
    ret = __real___fxstat64(vers, fd, buf);
    tm2 = darshan_wtime();
    if(ret < 0 || !S_ISREG(buf->st_mode))
        return(ret);

    /* skip logging if this was triggered internally */
    if(buf == &cp_stat_buf)
        return(ret);

    CP_LOCK();
    file = darshan_file_by_fd(fd);
    if(file)
    {
707
        CP_RECORD_STAT(file, buf, tm1, tm2);
708
709
710
711
712
713
714
    }
    CP_UNLOCK();

    return(ret);
}


715
int DARSHAN_DECL(__xstat)(int vers, const char *path, struct stat *buf)
716
717
718
719
{
    int ret;
    double tm1, tm2;

720
721
    MAP_OR_FAIL(__xstat);

722
723
724
725
726
727
728
    tm1 = darshan_wtime();
    ret = __real___xstat(vers, path, buf);
    tm2 = darshan_wtime();
    if(ret < 0 || !S_ISREG(buf->st_mode))
        return(ret);

    CP_LOCK();
729
    CP_LOOKUP_RECORD_STAT(path, buf, tm1, tm2);
730
731
732
733
734
    CP_UNLOCK();

    return(ret);
}

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

740
741
    MAP_OR_FAIL(__lxstat);

742
743
744
745
746
747
748
    tm1 = darshan_wtime();
    ret = __real___lxstat(vers, path, buf);
    tm2 = darshan_wtime();
    if(ret < 0 || !S_ISREG(buf->st_mode))
        return(ret);

    CP_LOCK();
749
    CP_LOOKUP_RECORD_STAT(path, buf, tm1, tm2);
750
751
752
753
754
    CP_UNLOCK();

    return(ret);
}

755
int DARSHAN_DECL(__fxstat)(int vers, int fd, struct stat *buf)
756
757
758
759
760
{
    int ret;
    struct darshan_file_runtime* file;
    double tm1, tm2;

761
762
    MAP_OR_FAIL(__fxstat);

763
764
765
766
767
768
769
    tm1 = darshan_wtime();
    ret = __real___fxstat(vers, fd, buf);
    tm2 = darshan_wtime();
    if(ret < 0 || !S_ISREG(buf->st_mode))
        return(ret);

    /* skip logging if this was triggered internally */
770
    if((void*)buf == (void*)&cp_stat_buf)
771
772
773
774
775
776
        return(ret);

    CP_LOCK();
    file = darshan_file_by_fd(fd);
    if(file)
    {
777
        CP_RECORD_STAT(file, buf, tm1, tm2);
778
779
780
781
782
783
    }
    CP_UNLOCK();

    return(ret);
}

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

790
791
    MAP_OR_FAIL(pread64);

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

    tm1 = darshan_wtime();
    ret = __real_pread64(fd, buf, count, offset);
    tm2 = darshan_wtime();
    CP_LOCK();
799
    CP_RECORD_READ(ret, fd, count, 1, offset, aligned_flag, 0, tm1, tm2);
800
801
802
803
    CP_UNLOCK();
    return(ret);
}

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

810
811
    MAP_OR_FAIL(pread);

812
    if((unsigned long)buf % darshan_mem_alignment == 0)
813
814
815
816
817
818
        aligned_flag = 1;

    tm1 = darshan_wtime();
    ret = __real_pread(fd, buf, count, offset);
    tm2 = darshan_wtime();
    CP_LOCK();
819
    CP_RECORD_READ(ret, fd, count, 1, offset, aligned_flag, 0, tm1, tm2);
820
821
822
823
824
    CP_UNLOCK();
    return(ret);
}


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

831
832
    MAP_OR_FAIL(pwrite);

833
    if((unsigned long)buf % darshan_mem_alignment == 0)
834
835
836
837
838
839
        aligned_flag = 1;

    tm1 = darshan_wtime();
    ret = __real_pwrite(fd, buf, count, offset);
    tm2 = darshan_wtime();
    CP_LOCK();
Philip Carns's avatar
Philip Carns committed
840
    CP_RECORD_WRITE(ret, fd, count, 1, offset, aligned_flag, 0, tm1, tm2);
841
842
843
844
    CP_UNLOCK();
    return(ret);
}

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

851
852
    MAP_OR_FAIL(pwrite64);

853
    if((unsigned long)buf % darshan_mem_alignment == 0)
854
855
856
857
858
859
        aligned_flag = 1;

    tm1 = darshan_wtime();
    ret = __real_pwrite64(fd, buf, count, offset);
    tm2 = darshan_wtime();
    CP_LOCK();
Philip Carns's avatar
Philip Carns committed
860
    CP_RECORD_WRITE(ret, fd, count, 1, offset, aligned_flag, 0, tm1, tm2);
861
862
863
864
    CP_UNLOCK();
    return(ret);
}

865
ssize_t DARSHAN_DECL(readv)(int fd, const struct iovec *iov, int iovcnt)
866
867
868
869
870
871
{
    ssize_t ret;
    int aligned_flag = 1;
    int i;
    double tm1, tm2;

872
873
    MAP_OR_FAIL(readv);

874
875
    for(i=0; i<iovcnt; i++)
    {
876
        if(((unsigned long)iov[i].iov_base % darshan_mem_alignment) != 0)
877
878
879
880
881
882
883
            aligned_flag = 0;
    }

    tm1 = darshan_wtime();
    ret = __real_readv(fd, iov, iovcnt);
    tm2 = darshan_wtime();
    CP_LOCK();
884
    CP_RECORD_READ(ret, fd, count, 0, 0, aligned_flag, 0, tm1, tm2);
885
886
887
888
    CP_UNLOCK();
    return(ret);
}

889
ssize_t DARSHAN_DECL(writev)(int fd, const struct iovec *iov, int iovcnt)
890
891
892
893
894
895
{
    ssize_t ret;
    int aligned_flag = 1;
    int i;
    double tm1, tm2;

896
897
    MAP_OR_FAIL(writev);

898
899
    for(i=0; i<iovcnt; i++)
    {
900
        if(!((unsigned long)iov[i].iov_base % darshan_mem_alignment == 0))
901
902
903
904
905
906
907
            aligned_flag = 0;
    }

    tm1 = darshan_wtime();
    ret = __real_writev(fd, iov, iovcnt);
    tm2 = darshan_wtime();
    CP_LOCK();
Philip Carns's avatar
Philip Carns committed
908
    CP_RECORD_WRITE(ret, fd, count, 0, 0, aligned_flag, 0, tm1, tm2);
909
910
911
912
    CP_UNLOCK();
    return(ret);
}

913
size_t DARSHAN_DECL(fread)(void *ptr, size_t size, size_t nmemb, FILE *stream)
914
915
916
917
918
{
    size_t ret;
    int aligned_flag = 0;
    double tm1, tm2;

919
920
    MAP_OR_FAIL(fread);

921
    if((unsigned long)ptr % darshan_mem_alignment == 0)
922
923
924
925
926
927
928
        aligned_flag = 1;

    tm1 = darshan_wtime();
    ret = __real_fread(ptr, size, nmemb, stream);
    tm2 = darshan_wtime();
    CP_LOCK();
    if(ret > 0)
929
        CP_RECORD_READ(size*ret, fileno(stream), (size*nmemb), 0, 0, aligned_flag, 1, tm1, tm2);
930
    else
931
        CP_RECORD_READ(ret, fileno(stream), (size*nmemb), 0, 0, aligned_flag, 1, tm1, tm2);
932
933
934
935
    CP_UNLOCK();
    return(ret);
}

936
ssize_t DARSHAN_DECL(read)(int fd, void *buf, size_t count)
937
938
939
940
941
{
    ssize_t ret;
    int aligned_flag = 0;
    double tm1, tm2;

942
943
    MAP_OR_FAIL(read);

944
    if((unsigned long)buf % darshan_mem_alignment == 0)
945
946
947
948
949
950
        aligned_flag = 1;

    tm1 = darshan_wtime();
    ret = __real_read(fd, buf, count);
    tm2 = darshan_wtime();
    CP_LOCK();
951
    CP_RECORD_READ(ret, fd, count, 0, 0, aligned_flag, 0, tm1, tm2);
952
953
954
955
    CP_UNLOCK();
    return(ret);
}

956
ssize_t DARSHAN_DECL(write)(int fd, const void *buf, size_t count)
957
958
959
960
961
{
    ssize_t ret;
    int aligned_flag = 0;
    double tm1, tm2;

962
963
    MAP_OR_FAIL(write);

964
    if((unsigned long)buf % darshan_mem_alignment == 0)
965
966
967
968
969
970
        aligned_flag = 1;

    tm1 = darshan_wtime();
    ret = __real_write(fd, buf, count);
    tm2 = darshan_wtime();
    CP_LOCK();
Philip Carns's avatar
Philip Carns committed
971
    CP_RECORD_WRITE(ret, fd, count, 0, 0, aligned_flag, 0, tm1, tm2);
972
973
974
975
    CP_UNLOCK();
    return(ret);
}

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

982
983
    MAP_OR_FAIL(fwrite);

984
    if((unsigned long)ptr % darshan_mem_alignment == 0)
985
986
987
988
989
990
991
        aligned_flag = 1;

    tm1 = darshan_wtime();
    ret = __real_fwrite(ptr, size, nmemb, stream);
    tm2 = darshan_wtime();
    CP_LOCK();
    if(ret > 0)
Philip Carns's avatar
Philip Carns committed
992
        CP_RECORD_WRITE(size*ret, fileno(stream), (size*nmemb), 0, 0, aligned_flag, 1, tm1, tm2);
993
    else
Philip Carns's avatar
Philip Carns committed
994
        CP_RECORD_WRITE(ret, fileno(stream), 0, 0, 0, aligned_flag, 1, tm1, tm2);
995
996
997
998
    CP_UNLOCK();
    return(ret);
}

999
off64_t DARSHAN_DECL(lseek64)(int fd, off64_t offset, int whence)
1000
{
For faster browsing, not all history is shown. View entire blame