SIONlib  1.6.2
Scalable I/O library for parallel access to task-local files
sion_file.c
Go to the documentation of this file.
1 /****************************************************************************
2 ** SIONLIB http://www.fz-juelich.de/jsc/sionlib **
3 *****************************************************************************
4 ** Copyright (c) 2008-2016 **
5 ** Forschungszentrum Juelich, Juelich Supercomputing Centre **
6 ** **
7 ** See the file COPYRIGHT in the package base directory for details **
8 ****************************************************************************/
9 
14 #include <stdlib.h>
15 #include <stdio.h>
16 #include <string.h>
17 #include <time.h>
18 #include <assert.h>
19 
20 #include <sys/types.h>
21 #include <sys/stat.h>
22 #include <fcntl.h>
23 #include <unistd.h>
24 
25 #include "sion.h"
26 #include "sion_debug.h"
27 #include "sion_internal.h"
28 #include "sion_file.h"
29 
30 
31 
40 _sion_fileptr *_sion_file_open(const char *fname, unsigned int flags, unsigned int addflags) {
41 
42  _sion_fileptr *sion_fileptr;
43 
44  /* allocate file pointer structure */
45  sion_fileptr = _sion_file_alloc_and_init_sion_fileptr();
46 
47  if(flags & SION_FILE_FLAG_ANSI) {
48  sion_fileptr->flags |= SION_FILE_FLAG_ANSI;
49  if(flags & SION_FILE_FLAG_WRITE) {
50  sion_fileptr->flags |= SION_FILE_FLAG_WRITE;
51 
52  if(flags & SION_FILE_FLAG_CREATE) {
53  sion_fileptr->flags |= SION_FILE_FLAG_CREATE;
54  sion_fileptr->fileptr=_sion_file_open_ansi_write_create(fname,addflags);
55  } else {
56  sion_fileptr->fileptr=_sion_file_open_ansi_write_existing(fname,addflags);
57  }
58  } else {
59  sion_fileptr->flags |= SION_FILE_FLAG_READ;
60  sion_fileptr->fileptr=_sion_file_open_ansi_read(fname,addflags);
61  }
62  } else {
63  if (flags & SION_FILE_FLAG_POSIX) {
64  sion_fileptr->flags |= SION_FILE_FLAG_POSIX;
65 
66  if(flags & SION_FILE_FLAG_WRITE) {
67  sion_fileptr->flags |= SION_FILE_FLAG_WRITE;
68  if(flags & SION_FILE_FLAG_CREATE) {
69  sion_fileptr->flags |= SION_FILE_FLAG_CREATE;
70  sion_fileptr->fd=_sion_file_open_posix_write_create(fname,addflags);
71  } else {
72  sion_fileptr->fd=_sion_file_open_posix_write_existing(fname,addflags);
73  }
74  } else {
75  sion_fileptr->flags |= SION_FILE_FLAG_READ;
76  sion_fileptr->fd=_sion_file_open_posix_read(fname,addflags);
77  }
78  }
79  }
80 
81  /* could not open ANSI file */
82  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI ) {
83  if(!sion_fileptr->fileptr) {
84  free(sion_fileptr);
85  _sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"error: could not open file (ANSI), %s %d %d, aborting ...\n", fname, flags, addflags);
86  return(NULL);
87  }
88  }
89 
90  /* could not open POSIX file */
91  if(sion_fileptr->flags & SION_FILE_FLAG_POSIX ) {
92  if(sion_fileptr->fd<0) {
93  free(sion_fileptr);
94  _sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"error: could not open file (POSIX), %s %d %d, aborting ...\n", fname, flags, addflags);
95  return(NULL);
96  }
97  }
98 
99  /* unknown mode? */
100  if(sion_fileptr->flags == 0) {
101  free(sion_fileptr);
102  _sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"internal error: unknown open type, %s %d %d, aborting ...\n", fname, flags, addflags);
103  return(NULL);
104  }
105 
106  return(sion_fileptr);
107 }
108 
109 
110 #define DFUNCTION "_sion_file_close"
111 
117 int _sion_file_close( _sion_fileptr *sion_fileptr ) {
118  int rc = SION_SUCCESS;
119  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI) {
120  if(sion_fileptr->flags & SION_FILE_FLAG_SCNDANSI) {
121  _sion_file_close_ansi(sion_fileptr->second_fileptr);
122  sion_fileptr->second_fileptr=NULL;
123  }
124  rc=_sion_file_close_ansi(sion_fileptr->fileptr);
125  sion_fileptr->fileptr=NULL;
126  }
127  if(sion_fileptr->flags & SION_FILE_FLAG_POSIX) {
128  rc=_sion_file_close_posix(sion_fileptr->fd);
129  }
130 
131  DPRINTFP((32, DFUNCTION, -1, "free now fileptr=%x %d rc=%d\n",sion_fileptr,sion_fileptr->flags,rc));
132 
133  free(sion_fileptr);
134 
135  return (rc);
136 }
137 #undef DFUNCTION
138 
147 sion_int64 _sion_file_write(const void *data, sion_int64 bytes, _sion_fileptr *sion_fileptr ) {
148  sion_int64 bytes_written=0;
149  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI) {
150  if(sion_fileptr->flags & SION_FILE_FLAG_SCNDANSI) bytes_written=_sion_file_write_ansi(data,bytes,sion_fileptr->second_fileptr);
151  else bytes_written=_sion_file_write_ansi(data,bytes,sion_fileptr->fileptr);
152  } else if(sion_fileptr->flags & SION_FILE_FLAG_POSIX) {
153  bytes_written=_sion_file_write_posix(data,bytes,sion_fileptr->fd);
154  } else {
155  return(_sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"_sion_file_write: cannot find valid file flag (flags=%d)\n",sion_fileptr->flags));
156  }
157  return(bytes_written);
158 }
159 
168 sion_int64 _sion_file_read(void *data, sion_int64 bytes, _sion_fileptr *sion_fileptr ) {
169 
170  sion_int64 bytes_read=0;
171  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI) {
172  if(sion_fileptr->flags & SION_FILE_FLAG_SCNDANSI) bytes_read=_sion_file_read_ansi(data,bytes,sion_fileptr->second_fileptr);
173  else bytes_read=_sion_file_read_ansi(data,bytes,sion_fileptr->fileptr);
174  } else if(sion_fileptr->flags & SION_FILE_FLAG_POSIX) {
175  bytes_read=_sion_file_read_posix(data,bytes,sion_fileptr->fd);
176  } else {
177  return(_sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"_sion_file_read: cannot find valid file flag (flags=%d)\n",sion_fileptr->flags));
178  }
179  return (bytes_read);
180 }
181 
182 
189 long _sion_file_get_opt_blksize( _sion_fileptr *sion_fileptr ) {
190  long opt_size=SION_SIZE_NOT_VALID;
191 
192  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI) {
193  opt_size=_sion_file_get_opt_blksize_ansi(sion_fileptr->fileptr);
194  }
195 
196  if(sion_fileptr->flags & SION_FILE_FLAG_POSIX) {
197  opt_size=_sion_file_get_opt_blksize_posix(sion_fileptr->fd);
198  }
199 
200  return (opt_size);
201 }
202 
209 int _sion_file_stat_file(const char *fname) {
210  struct stat sbuf;
211  int file_exists=0;
212 
213 #if defined(_SION_LINUX)
214  if (stat(fname, &sbuf) == 0) file_exists=1;
215 #elif defined(_SION_DARWIN)
216  if (stat(fname, &sbuf) == 0) file_exists=1;
217 #elif defined(_SION_AIX)
218  if (stat(fname, &sbuf) == 0) file_exists=1;
219 #elif defined(_SION_BGL)
220  if (stat(fname, &sbuf) == 0) file_exists=1;
221 #elif defined(_SION_BGP)
222  if (stat(fname, &sbuf) == 0) file_exists=1;
223 #elif defined(_SION_BGQ)
224  if (stat(fname, &sbuf) == 0) file_exists=1;
225 #elif defined(_SION_XT)
226  if (stat(fname, &sbuf) == 0) file_exists=1;
227 #endif
228  return (file_exists);
229 }
230 
238 sion_int64 _sion_file_set_position( _sion_fileptr *sion_fileptr, sion_int64 startpointer ) {
239  sion_int64 posinfile=SION_SIZE_NOT_VALID;
240 
241  /* needed to flush data written before set fp to new position */
242 #ifdef FLUSH_BEFORE_SETPOS
243  _sion_flush_file_fp(sion_fileptr);
244 #endif
245 
246  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI) {
247  if(sion_fileptr->flags & SION_FILE_FLAG_SCNDANSI) {
248  posinfile=_sion_file_set_position_ansi(sion_fileptr->second_fileptr, startpointer);
249  } else {
250  posinfile=_sion_file_set_position_ansi(sion_fileptr->fileptr, startpointer);
251  }
252  }
253 
254  if(sion_fileptr->flags & SION_FILE_FLAG_POSIX) {
255  posinfile=_sion_file_set_position_posix(sion_fileptr->fd, startpointer);
256  }
257 
258  return (posinfile);
259 }
260 
261 
268 sion_int64 _sion_file_get_position( _sion_fileptr *sion_fileptr ) {
269  sion_int64 posinfile=SION_SIZE_NOT_VALID;
270 
271  /* needed to flush data written before set fp to new position */
272 #ifdef FLUSH_BEFORE_SETPOS
273  _sion_flush_file(sion_fileptr);
274 #endif
275 
276  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI) {
277  if(sion_fileptr->flags & SION_FILE_FLAG_SCNDANSI) {
278  posinfile=_sion_file_get_position_ansi(sion_fileptr->second_fileptr);
279  } else {
280  posinfile=_sion_file_get_position_ansi(sion_fileptr->fileptr);
281  }
282  }
283 
284  if(sion_fileptr->flags & SION_FILE_FLAG_POSIX) {
285  posinfile=_sion_file_get_position_posix(sion_fileptr->fd);
286  }
287 
288  return (posinfile);
289 }
290 
291 
298 int _sion_file_flush( _sion_fileptr *sion_fileptr ) {
299  int rc=SION_SUCCESS;
300 
301  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI) {
302  if(sion_fileptr->flags & SION_FILE_FLAG_SCNDANSI) {
303  rc=_sion_file_flush_ansi(sion_fileptr->second_fileptr);
304  } else {
305  rc=_sion_file_flush_ansi(sion_fileptr->fileptr);
306  }
307  }
308 
309  if(sion_fileptr->flags & SION_FILE_FLAG_POSIX) {
310  rc=_sion_file_flush_posix(sion_fileptr->fd);
311  }
312 
313  return (rc);
314 }
315 
322 int _sion_file_purge( _sion_fileptr *sion_fileptr ) {
323  int rc=SION_SUCCESS;
324 
325  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI) {
326  if(sion_fileptr->flags & SION_FILE_FLAG_SCNDANSI) {
327  rc=_sion_file_purge_ansi(sion_fileptr->second_fileptr);
328  } else {
329  rc=_sion_file_purge_ansi(sion_fileptr->fileptr);
330  }
331  }
332 
333  if(sion_fileptr->flags & SION_FILE_FLAG_POSIX) {
334  rc=_sion_file_purge_posix(sion_fileptr->fd);
335  }
336 
337  return (rc);
338 }
339 
348 int _sion_file_set_buffer(_sion_fileptr *sion_fileptr, char *buffer, sion_int32 buffer_size) {
349 
350  int rc=SION_SUCCESS;
351 
352  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI) {
353  if(sion_fileptr->flags & SION_FILE_FLAG_SCNDANSI) {
354  rc=_sion_file_set_buffer_ansi(sion_fileptr->second_fileptr, buffer, buffer_size);
355  } else {
356  rc=_sion_file_set_buffer_ansi(sion_fileptr->fileptr, buffer, buffer_size);
357  }
358  }
359 
360  if(sion_fileptr->flags & SION_FILE_FLAG_POSIX) {
361  rc=_sion_file_set_buffer_posix(sion_fileptr->fd, buffer, buffer_size);
362  }
363 
364  return (rc);
365 
366 }
367 
375 int _sion_file_set_second_fileptr( _sion_fileptr *sion_fileptr, FILE* fileptr) {
376  int rc=SION_SUCCESS;
377  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI) {
378  if(sion_fileptr->flags & SION_FILE_FLAG_SCNDANSI) {
379  return(_sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"internal error: second fileptr already set, aborting ...\n"));
380  }
381  sion_fileptr->flags |= SION_FILE_FLAG_SCNDANSI;
382  sion_fileptr->second_fileptr=fileptr;
383  } else {
384  return(_sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"internal error: second fileptr could not be set for POSIX file, aborting ...\n"));
385  }
386  return (rc);
387 }
388 
395 int _sion_file_unset_second_fileptr( _sion_fileptr *sion_fileptr) {
396  int rc=SION_SUCCESS;
397  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI) {
398  if(sion_fileptr->flags & SION_FILE_FLAG_SCNDANSI) {
399  sion_fileptr->flags &= ~SION_FILE_FLAG_SCNDANSI;
400  sion_fileptr->second_fileptr=NULL;
401  } else {
402  return(_sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"internal error: second fileptr was not set, aborting ...\n"));
403  }
404  } else {
405  return(_sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"internal error: second fileptr could not be unset for POSIX file, aborting ...\n"));
406  }
407  return (rc);
408 }
409 
416 int _sion_file_get_fd( _sion_fileptr *sion_fileptr) {
417  int fd=SION_ID_UNDEF;
418  if(sion_fileptr->flags & SION_FILE_FLAG_POSIX) {
419  fd=sion_fileptr->fd;
420  }
421  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI) {
422  if(sion_fileptr->flags & SION_FILE_FLAG_SCNDANSI) {
423  fd=fileno(sion_fileptr->second_fileptr);
424  } else {
425  fd=fileno(sion_fileptr->fileptr);
426  }
427  }
428 
429  return (fd);
430 }
431 
432 
433 
434 /* ********************************************************************************************** */
435 /* *** INTERFACE Functions */
436 /* ********************************************************************************************** */
437 
445 FILE *_sion_file_open_ansi_write_create(const char *fname, unsigned int addflags) {
446  FILE *fileptr=NULL;
447 #if defined(_SION_LINUX)
448  fileptr = fopen(fname, "w");
449 #elif defined(_SION_DARWIN)
450  fileptr = fopen(fname, "w");
451 #elif defined(_SION_AIX)
452  {
453  int fd_oflag = 0;
454  int fd;
455 
456  fd_oflag |= O_CREAT | O_RDWR;
457  fd = open64(fname, fd_oflag, 0664);
458 
459  fileptr = fdopen(fd, "w");
460 
461  }
462 #elif defined(_SION_BGL)
463  fileptr = fopen(fname, "w");
464 #elif defined(_SION_BGP)
465  {
466  int fd_oflag = 0;
467  int fd;
468 
469  fd_oflag |= O_CREAT | O_RDWR;
470  fd = open64(fname, fd_oflag, 0664);
471 
472  fileptr = fdopen(fd, "w");
473 
474  }
475 #elif defined(_SION_BGQ)
476  {
477  int fd_oflag = 0;
478  int fd;
479 
480  fd_oflag |= O_CREAT | O_RDWR;
481  fd = open64(fname, fd_oflag, 0664);
482 
483  fileptr = fdopen(fd, "w");
484 
485  }
486 #elif defined(_SION_XT)
487  fileptr = fopen(fname, "w");
488 #endif
489  return (fileptr);
490 }
491 
499 FILE *_sion_file_open_ansi_write_existing(const char *fname, unsigned int addflags) {
500  FILE *fileptr=NULL;
501 #if defined(_SION_LINUX)
502  /* changed from w to r+ to prevent time truncation of empty existing file */
503  fileptr = fopen(fname, "r+");
504 #elif defined(_SION_DARWIN)
505  fileptr = fopen(fname, "r+");
506 #elif defined(_SION_AIX)
507  {
508  int fd_oflag = 0;
509  int fd;
510 
511  fd_oflag |= O_CREAT | O_RDWR;
512  fd = open64(fname, fd_oflag, 0664);
513 
514  fileptr = fdopen(fd, "r+");
515 
516  }
517 #elif defined(_SION_BGL)
518  fileptr = fopen(fname, "r+");
519 #elif defined(_SION_BGP)
520  {
521  int fd_oflag = 0;
522  int fd;
523 
524  fd_oflag |= O_RDWR;
525  fd = open64(fname, fd_oflag, 0664);
526 
527  fileptr = fdopen(fd, "r+");
528 
529  }
530 #elif defined(_SION_BGQ)
531  {
532  int fd_oflag = 0;
533  int fd;
534 
535  fd_oflag |= O_RDWR;
536  fd = open64(fname, fd_oflag, 0664);
537 
538  fileptr = fdopen(fd, "r+");
539 
540  }
541 #elif defined(_SION_XT)
542  fileptr = fopen(fname, "r+");
543 #endif
544  return (fileptr);
545 }
546 
547 
555 FILE *_sion_file_open_ansi_read(const char *fname, unsigned int addflags) {
556  FILE *fileptr=NULL;
557 #if defined(_SION_LINUX)
558  fileptr = fopen(fname, "r");
559 #elif defined(_SION_DARWIN)
560  fileptr = fopen(fname, "r");
561 #elif defined(_SION_AIX)
562  {
563  int fd_oflag = 0;
564  int fd;
565 
566  fd_oflag |= O_RDONLY;
567  fd = open64(fname, fd_oflag, 0664);
568 
569  fileptr = fdopen(fd, "r");
570 
571  }
572 #elif defined(_SION_BGL)
573  fileptr = fopen(fname, "r");
574 #elif defined(_SION_BGP)
575  {
576  int fd_oflag = 0;
577  int fd;
578 
579  fd_oflag |= O_RDONLY;
580  fd = open64(fname, fd_oflag, 0664);
581 
582  fileptr = fdopen(fd, "r");
583 
584  }
585 #elif defined(_SION_BGQ)
586  {
587  int fd_oflag = 0;
588  int fd;
589 
590  fd_oflag |= O_RDONLY;
591  fd = open64(fname, fd_oflag, 0664);
592 
593  fileptr = fdopen(fd, "r");
594 
595  }
596 #elif defined(_SION_XT)
597  fileptr = fopen(fname, "r");
598 #endif
599  return (fileptr);
600 }
601  int _sion_file_close_ansi(FILE *fileptr) {
608  int rc=SION_SUCCESS;
609  int frc;
610 #if defined(_SION_LINUX)
611  frc= fclose(fileptr);
612 #elif defined(_SION_DARWIN)
613  frc= fclose(fileptr);
614 #elif defined(_SION_AIX)
615  frc= fclose(fileptr);
616 #elif defined(_SION_BGL)
617  frc= fclose(fileptr);
618 #elif defined(_SION_BGP)
619  frc= fclose(fileptr);
620 #elif defined(_SION_BGQ)
621  frc= fclose(fileptr);
622 #elif defined(_SION_XT)
623  frc= fclose(fileptr);
624 #endif
625  if(frc) rc=SION_NOT_SUCCESS;
626  return(rc);
627 }
628 
635 long _sion_file_get_opt_blksize_ansi( FILE *fileptr ) {
636  struct stat sbuf;
637  int fd;
638  long opt_size=SION_SIZE_NOT_VALID;
639 
640  fd = fileno(fileptr);
641 
642 #if defined(_SION_LINUX)
643  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
644 #elif defined(_SION_DARWIN)
645  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
646 #elif defined(_SION_AIX)
647  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
648 #elif defined(_SION_BGL)
649  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
650 #elif defined(_SION_BGP)
651  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
652 #elif defined(_SION_BGQ)
653  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
654 #elif defined(_SION_XT)
655  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
656 #endif
657  return (opt_size);
658 }
659 
667 sion_int64 _sion_file_set_position_ansi(FILE *fileptr, sion_int64 startpointer) {
668 
669  sion_int64 newpos = SION_SIZE_NOT_VALID;
670 
671  DPRINTFP((32, "_sion_set_position_ansi", -1, "enter (to %lld) (to %ld)\n", (long long) startpointer, (long) startpointer));
672 
673 #if defined(_SION_LINUX)
674  {
675  off_t offset = (off_t) startpointer;
676  off_t result;
677  int fd;
678  fd = fileno(fileptr);
679  if (offset != startpointer) {
680  DPRINTFP((32, "_sion_set_position_ansi", -1, "_sion_set_position_ansi: cannot set position to %ld (%lu),%lld (%lu) offset conversion error\n",
681  offset, (unsigned long) sizeof(offset), startpointer, (unsigned long) sizeof(startpointer)));
682  return(_sion_errorprint(SION_SIZE_NOT_VALID,_SION_ERROR_RETURN,"_sion_set_position_ansi: cannot set position to %ld (%lu),%lld (%lu) offset conversion error\n",
683  offset, (unsigned long) sizeof(offset), startpointer, (unsigned long) sizeof(startpointer)));
684  }
685  newpos = result = lseek(fd, offset, SEEK_SET);
686  DPRINTFP((1024, "_sion_set_position_ansi", -1, "set position=%lld (LINUX)\n", (long long) result));
687  }
688 #elif defined(_SION_DARWIN)
689  {
690  off_t offset = (off_t) startpointer;
691  off_t result;
692  if (offset != startpointer) {
693  return(_sion_errorprint(SION_SIZE_NOT_VALID,_SION_ERROR_RETURN,"_sion_set_position_ansi: cannot set position to %ld (%lu),%lld (%lu) offset conversion error\n",
694  offset, (unsigned long) sizeof(offset), startpointer, (unsigned long) sizeof(startpointer)));
695  }
696  newpos = result = fseek(fileptr, offset, SEEK_SET);
697  DPRINTFP((1024, "_sion_set_position_ansi", -1, "set position=%lld (LINUX)\n", (long long) result));
698  }
699 #elif defined(_SION_AIX)
700  off64_t offset = (off_t) startpointer;
701  off64_t result;
702  if (offset != startpointer) {
703  return(_sion_errorprint(SION_SIZE_NOT_VALID,_SION_ERROR_RETURN,"_sion_set_position_ansi: cannot set position to %ld (%lu),%lld (%lu) offset conversion error\n",
704  offset, (unsigned long) sizeof(offset), startpointer, (unsigned long) sizeof(startpointer)));
705  }
706  result = fseeko64(fileptr, offset, SEEK_SET);
707  newpos = result = ftello64(fileptr);
708 #elif defined(_SION_BGL)
709  off_t offset = (off_t) startpointer;
710  off_t result;
711  int fd;
712  if (offset != startpointer) {
713  return(_sion_errorprint(SION_SIZE_NOT_VALID,_SION_ERROR_RETURN,"_sion_set_position_ansi: cannot set position to %ld (%lu),%lld (%lu) offset conversion error\n",
714  offset, (unsigned long) sizeof(offset), startpointer, (unsigned long) sizeof(startpointer)));
715  }
716  fd = fileno(fileptr);
717  newpos = result = lseek(fd, offset, SEEK_SET);
718 #elif defined(_SION_BGP)
719  off_t offset = (off_t) startpointer;
720  off_t result;
721  int fd;
722  if (offset != startpointer) {
723  return(_sion_errorprint(SION_SIZE_NOT_VALID,_SION_ERROR_RETURN,"_sion_set_position_ansi: cannot set position to %ld (%lu),%lld (%lu) offset conversion error\n",
724  offset, (unsigned long) sizeof(offset), startpointer, (unsigned long) sizeof(startpointer)));
725  }
726  fd = fileno(fileptr);
727  newpos = result = lseek(fd, offset, SEEK_SET);
728 #elif defined(_SION_BGQ)
729  off_t offset = (off_t) startpointer;
730  off_t result;
731  int fd;
732  if (offset != startpointer) {
733  return(_sion_errorprint(SION_SIZE_NOT_VALID,_SION_ERROR_RETURN,"_sion_set_position_ansi: cannot set position to %ld (%lu),%lld (%lu) offset conversion error\n",
734  offset, (unsigned long) sizeof(offset), startpointer, (unsigned long) sizeof(startpointer)));
735  }
736  fd = fileno(fileptr);
737  newpos = result = lseek(fd, offset, SEEK_SET);
738 #elif defined(_SION_XT)
739  {
740  off_t offset = (off_t) startpointer;
741  off_t result;
742  int fd;
743  if (offset != startpointer) {
744  return(_sion_errorprint(SION_SIZE_NOT_VALID,_SION_ERROR_RETURN,"_sion_set_position_ansi: cannot set position to %ld (%lu),%lld (%lu) offset conversion error\n",
745  offset, (unsigned long) sizeof(offset), startpointer, (unsigned long) sizeof(startpointer)));
746  }
747  fd = fileno(fileptr);
748  newpos = result = lseek(fd, offset, SEEK_SET);
749  }
750 #endif
751  DPRINTFP((32, "_sion_set_position_ansi", -1, "leave (to %lld)\n",(long long) startpointer));
752 
753  return (newpos);
754 }
755 
756 
763 sion_int64 _sion_file_get_position_ansi(FILE *fileptr) {
764 
765  sion_int64 result;
766 #if defined(_SION_LINUX)
767  {
768  off_t resulto;
769  int fd = fileno(fileptr);
770  resulto = lseek(fd,0,SEEK_CUR);
771  result = (sion_int64) resulto;
772  DPRINTFP((4096, "_sion_get_position", -1, "get position=%ld (LINUX)\n", (long) result));
773  }
774 #elif defined(_SION_DARWIN)
775  {
776  off_t resulto;
777  resulto = ftello(fileptr);
778  result = (sion_int64) resulto;
779  DPRINTFP((4096, "_sion_get_position", -1, "get position=%ld (DARWIN)\n", (long) result));
780  }
781 #elif defined(_SION_AIX)
782  {
783  result = ftell(fileptr);
784  DPRINTFP((4096, "_sion_get_position", -1, "got position=%lld (AIX)\n", result));
785  }
786 #elif defined(_SION_BGL)
787  {
788  off_t resulto;
789  int fd = fileno(fileptr);
790  resulto = lseek(fd, 0, SEEK_CUR);
791  result = (sion_int64) resulto;
792  DPRINTFP((4096, "_sion_get_position", -1, "got position=%lld (BGL)\n", result));
793  }
794 #elif defined(_SION_BGP)
795  {
796  off_t resulto;
797  int fd = fileno(fileptr);
798  resulto = lseek(fd, 0, SEEK_CUR);
799  result = (sion_int64) resulto;
800  DPRINTFP((4096, "_sion_get_position", -1, "got position=%lld (BGP)\n", result));
801  }
802 #elif defined(_SION_BGQ)
803  {
804  off_t resulto;
805  int fd = fileno(fileptr);
806  resulto = lseek(fd, 0, SEEK_CUR);
807  result = (sion_int64) resulto;
808  DPRINTFP((4096, "_sion_get_position", -1, "got position=%lld (BGQ)\n", result));
809  }
810 #elif defined(_SION_XT)
811  {
812  off_t resulto;
813  int fd = fileno(fileptr);
814  resulto = lseek(fd, 0, SEEK_CUR);
815  result = (sion_int64) resulto;
816  DPRINTFP((4096, "_sion_get_position", -1, "got position=%lld (XT)\n", result));
817  }
818 #endif
819 
820  return (result);
821 }
822 
823 
830 int _sion_file_flush_ansi(FILE *fileptr) {
831 
832  int rc = SION_SUCCESS;
833  int frc;
834 
835 #if defined(_SION_BGP)
836  frc=fflush(fileptr);
837 #elif defined(_SION_BGQ)
838  frc=fflush(fileptr);
839 #else
840  frc=fflush(fileptr);
841 #endif
842  if(frc) rc=SION_NOT_SUCCESS;
843  return (rc);
844 }
845 
846 
853 int _sion_file_purge_ansi(FILE *fileptr) {
854 
855  int rc = SION_SUCCESS;
856  int frc;
857 
858 #if defined(_SION_BGP)
859  /* 1: int fd = fileno(fileptr); */
860  /* fsync(fd); */
861  /* 2: __fpurge(fileptr); */
862  /* restored to fflush due to a not working fpurge in scalasca */
863  frc=fflush(fileptr);
864 #elif defined(_SION_BGQ)
865  /* 1: int fd = fileno(fileptr); */
866  /* fsync(fd); */
867  /* 2: __fpurge(fileptr); */
868  /* restored to fflush due to a not working fpurge in scalasca */
869  frc=fflush(fileptr);
870 #else
871  frc=fflush(fileptr);
872 #endif
873 
874  if(frc) rc=SION_NOT_SUCCESS;
875  return (rc);
876 }
877 
878 
879 
880 
889 int _sion_file_set_buffer_ansi(FILE *fileptr, char *buffer, sion_int32 buffer_size) {
890 
891  int rc = SION_SUCCESS;
892  int frc;
893 
894  DPRINTFP((32, "_sion_file_set_buffer", -1, "set buffer of fileptr\n"));
895 #if defined(_SION_BGP)
896  frc=setvbuf(fileptr, buffer, _IOFBF, (size_t) buffer_size);
897 #elif defined(_SION_BGQ)
898  frc=setvbuf(fileptr, buffer, _IOFBF, (size_t) buffer_size);
899 #elif defined(_SION_AIX)
900  frc=setvbuf(fileptr, buffer, _IOFBF, (size_t) buffer_size);
901 #else
902  frc=setvbuf(fileptr, buffer, _IOFBF, (size_t) buffer_size);
903 #endif
904 
905  if(frc) rc=SION_NOT_SUCCESS;
906  return (rc);
907 }
908 
909 
918 sion_int64 _sion_file_write_ansi(const void *data, sion_int64 bytes, FILE *fileptr ) {
919  sion_int64 left,bsumwrote;
920  size_t bwrite, bwrote;
921  char *dataptr;
922 
923  left = bytes;
924  bsumwrote = 0;
925  dataptr = (char*) data;
926 
927  while (left > 0) {
928  bwrite = left;
929  bwrote = fwrite(dataptr, 1, bwrite, fileptr);
930  left -= bwrote;
931  dataptr += bwrote;
932  bsumwrote += bwrote;
933  }
934  return (bsumwrote);
935 }
936 
945 sion_int64 _sion_file_read_ansi(void *data, sion_int64 bytes, FILE *fileptr ) {
946 
947  sion_int64 left,bsumread;
948  size_t btoread, bread;
949  char *dataptr;
950 
951  left = bytes;
952  bsumread = 0;
953  dataptr = (char*) data;
954  bread = 0;
955 
956  while ((left > 0) && (!feof(fileptr))) {
957  btoread = left;
958  bread = fread(dataptr, 1, btoread, fileptr);
959  left -= bread;
960  dataptr += bread;
961  bsumread += bread;
962  }
963  return (bsumread);
964 }
965 
966 
967 
968 
976 int _sion_file_open_posix_write_create(const char *fname, unsigned int addflags) {
977 
978  int fd;
979  int fd_oflag = 0;
980 
981 #if defined(_SION_LINUX)
982  fd_oflag |= O_CREAT | O_RDWR;
983  fd = open(fname, fd_oflag, 0664);
984 #elif defined(_SION_DARWIN)
985  fd_oflag |= O_CREAT | O_RDWR;
986  fd = open(fname, fd_oflag, 0664);
987 #elif defined(_SION_AIX)
988  fd_oflag |= O_CREAT | O_RDWR;
989  fd = open64(fname, fd_oflag, 0664);
990 #elif defined(_SION_BGL)
991  fd_oflag |= O_CREAT | O_RDWR;
992  fd = open64(fname, fd_oflag, 0664);
993 #elif defined(_SION_BGP)
994  fd_oflag |= O_CREAT | O_RDWR;
995  fd = open64(fname, fd_oflag, 0664);
996 #elif defined(_SION_BGQ)
997  fd_oflag |= O_CREAT | O_RDWR;
998  fd = open64(fname, fd_oflag, 0664);
999 #elif defined(_SION_XT)
1000  fd_oflag |= O_CREAT | O_RDWR;
1001  fd = open64(fname, fd_oflag, 0664);
1002 #endif
1003  return (fd);
1004 }
1005 
1013 int _sion_file_open_posix_write_existing(const char *fname, unsigned int addflags) {
1014 
1015  int fd;
1016  int fd_oflag = 0;
1017 
1018 #if defined(_SION_LINUX)
1019  fd_oflag |= O_RDWR;
1020  fd = open(fname, fd_oflag, 0664);
1021 #elif defined(_SION_DARWIN)
1022  fd_oflag |= O_RDWR;
1023  fd = open(fname, fd_oflag, 0664);
1024 #elif defined(_SION_AIX)
1025  fd_oflag |= O_RDWR;
1026  fd = open64(fname, fd_oflag, 0664);
1027 #elif defined(_SION_BGL)
1028  fd_oflag |= O_RDWR;
1029  fd = open64(fname, fd_oflag, 0664);
1030 #elif defined(_SION_BGP)
1031  fd_oflag |= O_RDWR;
1032  fd = open64(fname, fd_oflag, 0664);
1033 #elif defined(_SION_BGQ)
1034  fd_oflag |= O_RDWR;
1035  fd = open64(fname, fd_oflag, 0664);
1036 #elif defined(_SION_XT)
1037  fd_oflag |= O_RDWR|O_NOATIME;
1038  fd = open64(fname, fd_oflag, 0664);
1039 #endif
1040  return (fd);
1041 }
1042 
1050 int _sion_file_open_posix_read(const char *fname, unsigned int addflags) {
1051  int fd;
1052  int fd_oflag = 0;
1053 
1054 #if defined(_SION_LINUX)
1055  fd_oflag |= O_RDONLY;
1056  fd = open(fname, fd_oflag, 0664);
1057 #elif defined(_SION_DARWIN)
1058  fd_oflag |= O_RDONLY;
1059  fd = open(fname, fd_oflag, 0664);
1060 #elif defined(_SION_AIX)
1061  fd_oflag |= O_RDONLY;
1062  fd = open64(fname, fd_oflag, 0664);
1063 #elif defined(_SION_BGL)
1064  fd_oflag |= O_RDONLY;
1065  fd = open64(fname, fd_oflag, 0664);
1066 #elif defined(_SION_BGP)
1067  fd_oflag |= O_RDONLY;
1068  fd = open64(fname, fd_oflag, 0664);
1069 #elif defined(_SION_BGQ)
1070  fd_oflag |= O_RDONLY;
1071  fd = open64(fname, fd_oflag, 0664);
1072 #elif defined(_SION_XT)
1073  fd_oflag |= O_RDONLY|O_NOATIME;
1074  fd = open(fname, fd_oflag, 0664);
1075 #endif
1076  return (fd);
1077 }
1078 
1079 
1080 
1087 int _sion_file_close_posix(int fd) {
1088  int rc=SION_SUCCESS;
1089  int frc;
1090 
1091 #if defined(_SION_LINUX)
1092  frc= close(fd);
1093 #elif defined(_SION_DARWIN)
1094  frc= close(fd);
1095 #elif defined(_SION_AIX)
1096  frc= close(fd);
1097 #elif defined(_SION_BGL)
1098  frc= close(fd);
1099 #elif defined(_SION_BGP)
1100  frc= close(fd);
1101 #elif defined(_SION_BGQ)
1102  frc= close(fd);
1103 #elif defined(_SION_XT)
1104  frc= close(fd);
1105 #endif
1106 
1107  if(frc) rc=SION_NOT_SUCCESS;
1108  return(rc);
1109 }
1110 
1117 long _sion_file_get_opt_blksize_posix( int fd ) {
1118  struct stat sbuf;
1119  long opt_size=SION_SIZE_NOT_VALID;
1120 
1121 #if defined(_SION_LINUX)
1122  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
1123 #elif defined(_SION_DARWIN)
1124  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
1125 #elif defined(_SION_AIX)
1126  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
1127 #elif defined(_SION_BGL)
1128  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
1129 #elif defined(_SION_BGP)
1130  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
1131 #elif defined(_SION_BGQ)
1132  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
1133 #elif defined(_SION_XT)
1134  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
1135 #endif
1136  return (opt_size);
1137 }
1138 
1139 
1140 
1148 sion_int64 _sion_file_set_position_posix(int fd, sion_int64 startpointer) {
1149  sion_int64 newpos = SION_SIZE_NOT_VALID;
1150 
1151  DPRINTFP((32, "_sion_set_position_posix", -1, "enter (to %lld)\n", (long long) startpointer));
1152 
1153 #if defined(_SION_LINUX)
1154  {
1155  off_t offset = (off_t) startpointer;
1156  off_t result;
1157  if (offset != startpointer) {
1158  return(_sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"_sion_set_position_posix: cannot set position to %ld (%lu),%lld (%lu) offset conversion error\n",
1159  offset, (unsigned long) sizeof(offset), startpointer, (unsigned long) sizeof(startpointer)));
1160  }
1161  newpos = result = lseek(fd, offset, SEEK_SET);
1162  DPRINTFP((4096, "_sion_set_position_posix", -1, "set position=%lld (LINUX)\n", (long long) result));
1163  }
1164 #elif defined(_SION_DARWIN)
1165  {
1166  off_t offset = (off_t) startpointer;
1167  off_t result;
1168  if (offset != startpointer) {
1169  return(_sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"_sion_set_position_posix: cannot set position to %ld (%lu),%lld (%lu) offset conversion error\n",
1170  offset, (unsigned long) sizeof(offset), startpointer, (unsigned long) sizeof(startpointer)));
1171  }
1172  newpos = result = lseek(fd, offset, SEEK_SET);
1173  DPRINTFP((4096, "_sion_set_position_posix", -1, "set position=%lld (LINUX)\n", (long long) result));
1174  }
1175 #elif defined(_SION_AIX)
1176  off64_t offset = (off_t) startpointer;
1177  off64_t result;
1178  if (offset != startpointer) {
1179  return(_sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"_sion_set_position_posix: cannot set position to %ld (%lu),%lld (%lu) offset conversion error\n",
1180  offset, (unsigned long) sizeof(offset), startpointer, (unsigned long) sizeof(startpointer)));
1181  }
1182  newpos = result = lseek(fd, offset, SEEK_SET);
1183 #elif defined(_SION_BGL)
1184  off_t offset = (off_t) startpointer;
1185  off_t result;
1186  if (offset != startpointer) {
1187  return(_sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"_sion_set_position_posix: cannot set position to %ld (%lu),%lld (%lu) offset conversion error\n",
1188  offset, (unsigned long) sizeof(offset), startpointer, (unsigned long) sizeof(startpointer)));
1189  }
1190  newpos = result = lseek(fd, offset, SEEK_SET);
1191 #elif defined(_SION_BGP)
1192  off_t offset = (off_t) startpointer;
1193  off_t result;
1194  if (offset != startpointer) {
1195  return(_sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"_sion_set_position_posix: cannot set position to %ld (%lu),%lld (%lu) offset conversion error\n",
1196  offset, (unsigned long) sizeof(offset), startpointer, (unsigned long) sizeof(startpointer)));
1197  }
1198  newpos = result = lseek(fd, offset, SEEK_SET);
1199 #elif defined(_SION_BGQ)
1200  off_t offset = (off_t) startpointer;
1201  off_t result;
1202  if (offset != startpointer) {
1203  return(_sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"_sion_set_position_posix: cannot set position to %ld (%lu),%lld (%lu) offset conversion error\n",
1204  offset, (unsigned long) sizeof(offset), startpointer, (unsigned long) sizeof(startpointer)));
1205  }
1206  newpos = result = lseek(fd, offset, SEEK_SET);
1207 #elif defined(_SION_XT)
1208  {
1209  off_t offset = (off_t) startpointer;
1210  off_t result;
1211  if (offset != startpointer) {
1212  return(_sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"_sion_set_position_posix: cannot set position to %ld (%lu),%lld (%lu) offset conversion error\n",
1213  offset, (unsigned long) sizeof(offset), startpointer, (unsigned long) sizeof(startpointer)));
1214  }
1215  newpos = result = lseek(fd, offset, SEEK_SET);
1216  }
1217 #endif
1218  DPRINTFP((32, "_sion_set_position_posix", -1, "leave (to %lld)\n",(long long) startpointer));
1219 
1220  return (newpos);
1221 }
1222 
1229 sion_int64 _sion_file_get_position_posix(int fd) {
1230 
1231  sion_int64 result=SION_SIZE_NOT_VALID;
1232 
1233 #if defined(_SION_LINUX)
1234  {
1235  off_t resulto;
1236  resulto = lseek(fd,0,SEEK_CUR);
1237  result = (sion_int64) resulto;
1238  DPRINTFP((4096, "_sion_get_position", -1, "get position=%ld (LINUX)\n", (long) result));
1239  }
1240 #elif defined(_SION_DARWIN)
1241  {
1242  off_t resulto;
1243  resulto = lseek(fd,0,SEEK_CUR);
1244  /* resulto = ftello(fileptr); */
1245  result = (sion_int64) resulto;
1246  DPRINTFP((4096, "_sion_get_position", -1, "get position=%ld (DARWIN)\n", (long) result));
1247  }
1248 #elif defined(_SION_AIX)
1249  {
1250  off_t resulto;
1251  resulto = lseek(fd,0,SEEK_CUR);
1252  /* resulto = ftello(fileptr); */
1253  result = (sion_int64) resulto;
1254  DPRINTFP((4096, "_sion_get_position", -1, "get position=%ld (AIX)\n", (long) result));
1255  }
1256 #elif defined(_SION_BGL)
1257  {
1258  off_t resulto;
1259  int fd = fileno(fileptr);
1260  resulto = lseek(fd, 0, SEEK_CUR);
1261  result = (sion_int64) resulto;
1262  DPRINTFP((4096, "_sion_get_position", -1, "get position=%ld (BGL)\n", (long) result));
1263  }
1264 #elif defined(_SION_BGP)
1265  {
1266  off_t resulto;
1267  resulto = lseek(fd, 0, SEEK_CUR);
1268  result = (sion_int64) resulto;
1269  DPRINTFP((4096, "_sion_get_position", -1, "get position=%ld (BGP)\n", (long) result));
1270  }
1271 #elif defined(_SION_BGQ)
1272  {
1273  off_t resulto;
1274  resulto = lseek(fd, 0, SEEK_CUR);
1275  result = (sion_int64) resulto;
1276  DPRINTFP((4096, "_sion_get_position", -1, "get position=%ld (BGQ)\n", (long) result));
1277  }
1278 #elif defined(_SION_XT)
1279  {
1280  off_t resulto;
1281  int fd = fileno(fileptr);
1282  resulto = lseek(fd, 0, SEEK_CUR);
1283  result = (sion_int64) resulto;
1284  DPRINTFP((4096, "_sion_get_position", -1, "get position=%ld (XT)\n", (long) result));
1285  }
1286 #endif
1287 
1288  return (result);
1289 }
1290 
1297 int _sion_file_flush_posix(int fd) {
1298 
1299  int rc = SION_SUCCESS;
1300  int frc;
1301 #if defined(_SION_BGP)
1302  frc=fsync(fd);
1303 #elif defined(_SION_BGQ)
1304  /* BGQ 20.09.13: bad fsync performance since V1R2M1, try without */
1305  /* rc=fsync(fd); */
1306 #else
1307  frc=fsync(fd);
1308 #endif
1309 
1310  if(frc) rc=SION_NOT_SUCCESS;
1311  return (rc);
1312 }
1313 
1322 int _sion_file_purge_posix(int fd) {
1323 
1324  int rc = SION_SUCCESS;
1325  int frc;
1326 #if defined(_SION_BGP)
1327  frc=fsync(fd);
1328 #elif defined(_SION_BGQ)
1329  /* BGQ 20.09.13: bad fsync performance since V1R2M1, try without */
1330  /* rc=fsync(fd); */
1331 #else
1332  frc=fsync(fd);
1333 #endif
1334 
1335  if(frc) rc=SION_NOT_SUCCESS;
1336  return (rc);
1337 }
1338 
1347 int _sion_file_set_buffer_posix(int fd, char *buffer, sion_int32 buffer_size) {
1348 
1349  int rc = SION_SUCCESS;
1350  int frc = 0;
1351  DPRINTFP((32, "_sion_file_set_buffer", -1, "set buffer of fileptr\n"));
1352 #if defined(_SION_BGP)
1353 #elif defined(_SION_AIX)
1354 #else
1355 #endif
1356  if(frc) rc=SION_NOT_SUCCESS;
1357  return (rc);
1358 }
1359 
1368 sion_int64 _sion_file_write_posix(const void *data, sion_int64 bytes, int fd ) {
1369  sion_int64 left,bsumwrote;
1370  size_t bwrite, bwrote;
1371  char *dataptr;
1372 
1373  left = bytes;
1374  bsumwrote = 0;
1375  dataptr = (char*) data;
1376 
1377  while (left > 0) {
1378  bwrite = left;
1379  bwrote = write(fd, dataptr, bwrite);
1380  left -= bwrote;
1381  dataptr += bwrote;
1382  bsumwrote += bwrote;
1383  }
1384  return (bsumwrote);
1385 }
1386 
1395 sion_int64 _sion_file_read_posix(void *data, sion_int64 bytes, int fd ) {
1396 
1397  sion_int64 left,bsumread;
1398  size_t btoread, bread;
1399  char *dataptr;
1400 
1401  left = bytes;
1402  bsumread = 0;
1403  dataptr = (char*) data;
1404  bread = 0;
1405 
1406  while (left > 0) {
1407  btoread = left;
1408  bread = read(fd, dataptr, btoread);
1409  if(bread>0) {
1410  left -= bread;
1411  dataptr += bread;
1412  bsumread += bread;
1413  } else {
1414  if(bread==0) return(bsumread);
1415  else return(bread);
1416  }
1417  }
1418  return (bsumread);
1419 }
1420 
1425 _sion_fileptr *_sion_file_alloc_and_init_sion_fileptr() {
1426  _sion_fileptr *sion_fileptr;
1427 
1428  sion_fileptr = (_sion_fileptr *) malloc(sizeof(_sion_fileptr));
1429  if (sion_fileptr == NULL) {
1430  _sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"cannot allocate _sion_fileptr structure of size %lu (_sion_fileptr), aborting ...\n",
1431  (unsigned long) sizeof(_sion_fileptr));
1432  return(NULL);
1433  }
1434  sion_fileptr->fileptr = NULL;
1435  sion_fileptr->second_fileptr = NULL;
1436  sion_fileptr->fd = -1;
1437  sion_fileptr->flags = 0;
1438 
1439  return (sion_fileptr);
1440 }
1441 
1442 #define STR_PRT(X) case X: return # X
1443 
1446 char* _sion_fileptrflags_to_str (unsigned int flag) {
1447  switch (flag) {
1448  STR_PRT(SION_FILE_FLAG_ANSI);
1449  STR_PRT(SION_FILE_FLAG_SCNDANSI);
1450  STR_PRT(SION_FILE_FLAG_POSIX);
1451  STR_PRT(SION_FILE_FLAG_CREATE);
1452  STR_PRT(SION_FILE_FLAG_WRITE);
1453  STR_PRT(SION_FILE_FLAG_READ);
1454  }
1455  return "";
1456 }
1457 
1458 
1462 char* _sion_get_fileptr_desc(_sion_fileptr *sion_fileptr) {
1463  int flags;
1464  if(!sion_fileptr) return("<undefined>");
1465  flags = sion_fileptr->flags;
1466 
1467  if(flags & SION_FILE_FLAG_ANSI) {
1468  if(flags & SION_FILE_FLAG_WRITE) {
1469  if(flags & SION_FILE_FLAG_CREATE) {
1470  return("<ANSI,WRITE,CREATE>");
1471  } else {
1472  return("<ANSI,WRITE>");
1473  }
1474  } else {
1475  return("<ANSI,READ>");
1476  }
1477  } else {
1478  if (flags & SION_FILE_FLAG_POSIX) {
1479  if(flags & SION_FILE_FLAG_WRITE) {
1480  if(flags & SION_FILE_FLAG_CREATE) {
1481  return("<POSIX,WRITE,CREATE>");
1482  } else {
1483  return("<POSIX,WRITE>");
1484  }
1485  } else {
1486  return("<POSIX,READ>");
1487  }
1488  }
1489  }
1490  return("<unknown>");
1491 
1492 }
_sion_file_write
sion_int64 _sion_file_write(const void *data, sion_int64 bytes, _sion_fileptr *sion_fileptr)
Write data to file.
Definition: sion_file.c:147
_sion_file_get_opt_blksize
long _sion_file_get_opt_blksize(_sion_fileptr *sion_fileptr)
Get optional file system block size for a file.
Definition: sion_file.c:189
_sion_file_get_position
sion_int64 _sion_file_get_position(_sion_fileptr *sion_fileptr)
Get new position in file.
Definition: sion_file.c:268
_sion_file_set_position
sion_int64 _sion_file_set_position(_sion_fileptr *sion_fileptr, sion_int64 startpointer)
Set new position in file.
Definition: sion_file.c:238
_sion_file_open
_sion_fileptr * _sion_file_open(const char *fname, unsigned int flags, unsigned int addflags)
Create and open a new file for writing.
Definition: sion_file.c:40
_sion_fileptrflags_to_str
char * _sion_fileptrflags_to_str(unsigned int flag)
Definition: sion_file.c:1446
_sion_file_get_opt_blksize_ansi
long _sion_file_get_opt_blksize_ansi(FILE *fileptr)
ANSI: Get optional file system block size for a file.
Definition: sion_file.c:635
SION_FILE_FLAG_WRITE
#define SION_FILE_FLAG_WRITE
Definition: sion_file.h:23
_sion_file_purge
int _sion_file_purge(_sion_fileptr *sion_fileptr)
Purge data to file.
Definition: sion_file.c:322
_sion_file_read
sion_int64 _sion_file_read(void *data, sion_int64 bytes, _sion_fileptr *sion_fileptr)
Read data from file.
Definition: sion_file.c:168
_sion_file_set_buffer
int _sion_file_set_buffer(_sion_fileptr *sion_fileptr, char *buffer, sion_int32 buffer_size)
Set buffer of fp.
Definition: sion_file.c:348
_sion_file_set_position_posix
sion_int64 _sion_file_set_position_posix(int fd, sion_int64 startpointer)
POSIX: Set the start position for the current task.
Definition: sion_file.c:1148
_sion_file_get_fd
int _sion_file_get_fd(_sion_fileptr *sion_fileptr)
Utility function: Get POSIX fp.
Definition: sion_file.c:416
SION_FILE_FLAG_READ
#define SION_FILE_FLAG_READ
Definition: sion_file.h:24
_sion_file_set_position_ansi
sion_int64 _sion_file_set_position_ansi(FILE *fileptr, sion_int64 startpointer)
ANSI: Set the start position for the current task.
Definition: sion_file.c:667
_sion_file_get_position_posix
sion_int64 _sion_file_get_position_posix(int fd)
POSIX: Get the current position in file.
Definition: sion_file.c:1229
_sion_file_get_opt_blksize_posix
long _sion_file_get_opt_blksize_posix(int fd)
POSIX: Get optional file system block size for a file.
Definition: sion_file.c:1117
_sion_file_read_ansi
sion_int64 _sion_file_read_ansi(void *data, sion_int64 bytes, FILE *fileptr)
ANSI: Read data from file.
Definition: sion_file.c:945
SION_FILE_FLAG_POSIX
#define SION_FILE_FLAG_POSIX
Definition: sion_file.h:21
_sion_file_get_position_ansi
sion_int64 _sion_file_get_position_ansi(FILE *fileptr)
ANSI: Get the current position in file.
Definition: sion_file.c:763
_sion_file_set_buffer_ansi
int _sion_file_set_buffer_ansi(FILE *fileptr, char *buffer, sion_int32 buffer_size)
ANSI: set buffer of fp.
Definition: sion_file.c:889
_sion_file_stat_file
int _sion_file_stat_file(const char *fname)
Check if file exists (LARGE_FILE support on BlueGene)
Definition: sion_file.c:209
SION_FILE_FLAG_ANSI
#define SION_FILE_FLAG_ANSI
Definition: sion_file.h:19
SION_FILE_FLAG_CREATE
#define SION_FILE_FLAG_CREATE
Definition: sion_file.h:22
_sion_get_fileptr_desc
char * _sion_get_fileptr_desc(_sion_fileptr *sion_fileptr)
Definition: sion_file.c:1462
_sion_file_close
int _sion_file_close(_sion_fileptr *sion_fileptr)
Close file and destroys fileptr structure.
Definition: sion_file.c:117
_sion_file_open_ansi_read
FILE * _sion_file_open_ansi_read(const char *fname, unsigned int addflags)
ANSI: Open a file for reading.
Definition: sion_file.c:555
_sion_errorprint
int _sion_errorprint(int rc, int level, const char *format,...)
Internal SION error.
Definition: sion_internal.c:1156
_sion_file_write_ansi
sion_int64 _sion_file_write_ansi(const void *data, sion_int64 bytes, FILE *fileptr)
ANSI: Write data to file.
Definition: sion_file.c:918
_sion_file_flush_posix
int _sion_file_flush_posix(int fd)
POSIX: Flush the data to the disk.
Definition: sion_file.c:1297
_sion_file_set_second_fileptr
int _sion_file_set_second_fileptr(_sion_fileptr *sion_fileptr, FILE *fileptr)
Set second fileptr for file if opened with ANSI.
Definition: sion_file.c:375
_sion_file_unset_second_fileptr
int _sion_file_unset_second_fileptr(_sion_fileptr *sion_fileptr)
Unset second fileptr for file if opened with ANSI.
Definition: sion_file.c:395
_sion_file_read_posix
sion_int64 _sion_file_read_posix(void *data, sion_int64 bytes, int fd)
POSIX: Read data from file.
Definition: sion_file.c:1395
_sion_file_write_posix
sion_int64 _sion_file_write_posix(const void *data, sion_int64 bytes, int fd)
POSIX: Write data to file.
Definition: sion_file.c:1368
sion_file.h
_sion_file_flush_ansi
int _sion_file_flush_ansi(FILE *fileptr)
ANSI: Flush the data to the disk.
Definition: sion_file.c:830
sion_debug.h
_sion_file_open_ansi_write_create
FILE * _sion_file_open_ansi_write_create(const char *fname, unsigned int addflags)
ANSI: Create and open a new file for writing.
Definition: sion_file.c:445
_sion_file_open_posix_write_create
int _sion_file_open_posix_write_create(const char *fname, unsigned int addflags)
POSIX: Create and open a new file for writing.
Definition: sion_file.c:976
_sion_file_open_posix_write_existing
int _sion_file_open_posix_write_existing(const char *fname, unsigned int addflags)
POSIX: Open a new file for writing.
Definition: sion_file.c:1013
sion_internal.h
_sion_fileptr_s
Definition: sion_file.h:26
_sion_file_purge_ansi
int _sion_file_purge_ansi(FILE *fileptr)
ANSI: Purge the data to the disk.
Definition: sion_file.c:853
_sion_file_open_posix_read
int _sion_file_open_posix_read(const char *fname, unsigned int addflags)
POSIX: Open a file for reading.
Definition: sion_file.c:1050
_sion_flush_file
int _sion_flush_file(int sid)
Flush the data to the disk for the current task.
Definition: sion_internal.c:962
_sion_file_flush
int _sion_file_flush(_sion_fileptr *sion_fileptr)
Flush data to file.
Definition: sion_file.c:298
_sion_file_alloc_and_init_sion_fileptr
_sion_fileptr * _sion_file_alloc_and_init_sion_fileptr()
Create and return _sion_fileptr.
Definition: sion_file.c:1425
_sion_file_open_ansi_write_existing
FILE * _sion_file_open_ansi_write_existing(const char *fname, unsigned int addflags)
ANSI: Open a new file for writing.
Definition: sion_file.c:499
_sion_file_purge_posix
int _sion_file_purge_posix(int fd)
POSIX: Purge the data to the disk.
Definition: sion_file.c:1322
_sion_file_close_posix
int _sion_file_close_posix(int fd)
POSIX: Close a file.
Definition: sion_file.c:1087
_sion_file_set_buffer_posix
int _sion_file_set_buffer_posix(int fd, char *buffer, sion_int32 buffer_size)
POSIX: set buffer of fd.
Definition: sion_file.c:1347
_sion_file_close_ansi
int _sion_file_close_ansi(FILE *fileptr)
ANSI: Close a file.
Definition: sion_file.c:607
SION_FILE_FLAG_SCNDANSI
#define SION_FILE_FLAG_SCNDANSI
Definition: sion_file.h:20
Generated by   doxygen 1.8.15