SIONlib  1.7.0
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_error_handler.h"
28 #include "sion_internal.h"
29 #include "sion_file.h"
30 
31 
32 
41 _sion_fileptr *_sion_file_open(const char *fname, unsigned int flags, unsigned int addflags) {
42 
43  _sion_fileptr *sion_fileptr;
44 
45  /* allocate file pointer structure */
46  sion_fileptr = _sion_file_alloc_and_init_sion_fileptr();
47 
48  if(flags & SION_FILE_FLAG_ANSI) {
49  sion_fileptr->flags |= SION_FILE_FLAG_ANSI;
50  if(flags & SION_FILE_FLAG_WRITE) {
51  sion_fileptr->flags |= SION_FILE_FLAG_WRITE;
52 
53  if(flags & SION_FILE_FLAG_CREATE) {
54  sion_fileptr->flags |= SION_FILE_FLAG_CREATE;
55  sion_fileptr->fileptr=_sion_file_open_ansi_write_create(fname,addflags);
56  } else {
57  sion_fileptr->fileptr=_sion_file_open_ansi_write_existing(fname,addflags);
58  }
59  } else {
60  sion_fileptr->flags |= SION_FILE_FLAG_READ;
61  sion_fileptr->fileptr=_sion_file_open_ansi_read(fname,addflags);
62  }
63  } else {
64  if (flags & SION_FILE_FLAG_POSIX) {
65  sion_fileptr->flags |= SION_FILE_FLAG_POSIX;
66 
67  if(flags & SION_FILE_FLAG_WRITE) {
68  sion_fileptr->flags |= SION_FILE_FLAG_WRITE;
69  if(flags & SION_FILE_FLAG_CREATE) {
70  sion_fileptr->flags |= SION_FILE_FLAG_CREATE;
71  sion_fileptr->fd=_sion_file_open_posix_write_create(fname,addflags);
72  } else {
73  sion_fileptr->fd=_sion_file_open_posix_write_existing(fname,addflags);
74  }
75  } else {
76  sion_fileptr->flags |= SION_FILE_FLAG_READ;
77  sion_fileptr->fd=_sion_file_open_posix_read(fname,addflags);
78  }
79  }
80  }
81 
82  /* could not open ANSI file */
83  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI ) {
84  if(!sion_fileptr->fileptr) {
85  free(sion_fileptr);
86  _sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"error: could not open file (ANSI), %s %d %d, aborting ...\n", fname, flags, addflags);
87  return(NULL);
88  }
89  }
90 
91  /* could not open POSIX file */
92  if(sion_fileptr->flags & SION_FILE_FLAG_POSIX ) {
93  if(sion_fileptr->fd<0) {
94  free(sion_fileptr);
95  _sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"error: could not open file (POSIX), %s %d %d, aborting ...\n", fname, flags, addflags);
96  return(NULL);
97  }
98  }
99 
100  /* unknown mode? */
101  if(sion_fileptr->flags == 0) {
102  free(sion_fileptr);
103  _sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"internal error: unknown open type, %s %d %d, aborting ...\n", fname, flags, addflags);
104  return(NULL);
105  }
106 
107  return(sion_fileptr);
108 }
109 
110 
111 #define DFUNCTION "_sion_file_close"
112 
118 int _sion_file_close( _sion_fileptr *sion_fileptr ) {
119  int rc = SION_SUCCESS;
120  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI) {
121  if(sion_fileptr->flags & SION_FILE_FLAG_SCNDANSI) {
122  _sion_file_close_ansi(sion_fileptr->second_fileptr);
123  sion_fileptr->second_fileptr=NULL;
124  }
125  rc=_sion_file_close_ansi(sion_fileptr->fileptr);
126  sion_fileptr->fileptr=NULL;
127  }
128  if(sion_fileptr->flags & SION_FILE_FLAG_POSIX) {
129  rc=_sion_file_close_posix(sion_fileptr->fd);
130  }
131 
132  DPRINTFP((32, DFUNCTION, -1, "free now fileptr=%x %d rc=%d\n",sion_fileptr,sion_fileptr->flags,rc));
133 
134  free(sion_fileptr);
135 
136  return (rc);
137 }
138 #undef DFUNCTION
139 
148 sion_int64 _sion_file_write(const void *data, sion_int64 bytes, _sion_fileptr *sion_fileptr ) {
149  sion_int64 bytes_written=0;
150  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI) {
151  if(sion_fileptr->flags & SION_FILE_FLAG_SCNDANSI) bytes_written=_sion_file_write_ansi(data,bytes,sion_fileptr->second_fileptr);
152  else bytes_written=_sion_file_write_ansi(data,bytes,sion_fileptr->fileptr);
153  } else if(sion_fileptr->flags & SION_FILE_FLAG_POSIX) {
154  bytes_written=_sion_file_write_posix(data,bytes,sion_fileptr->fd);
155  } else {
156  return(_sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"_sion_file_write: cannot find valid file flag (flags=%d)\n",sion_fileptr->flags));
157  }
158  return(bytes_written);
159 }
160 
169 sion_int64 _sion_file_read(void *data, sion_int64 bytes, _sion_fileptr *sion_fileptr ) {
170 
171  sion_int64 bytes_read=0;
172  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI) {
173  if(sion_fileptr->flags & SION_FILE_FLAG_SCNDANSI) bytes_read=_sion_file_read_ansi(data,bytes,sion_fileptr->second_fileptr);
174  else bytes_read=_sion_file_read_ansi(data,bytes,sion_fileptr->fileptr);
175  } else if(sion_fileptr->flags & SION_FILE_FLAG_POSIX) {
176  bytes_read=_sion_file_read_posix(data,bytes,sion_fileptr->fd);
177  } else {
178  return(_sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"_sion_file_read: cannot find valid file flag (flags=%d)\n",sion_fileptr->flags));
179  }
180  return (bytes_read);
181 }
182 
183 
190 long _sion_file_get_opt_blksize( _sion_fileptr *sion_fileptr ) {
191  long opt_size=SION_SIZE_NOT_VALID;
192 
193  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI) {
194  opt_size=_sion_file_get_opt_blksize_ansi(sion_fileptr->fileptr);
195  }
196 
197  if(sion_fileptr->flags & SION_FILE_FLAG_POSIX) {
198  opt_size=_sion_file_get_opt_blksize_posix(sion_fileptr->fd);
199  }
200 
201  return (opt_size);
202 }
203 
210 int _sion_file_stat_file(const char *fname) {
211  struct stat sbuf;
212  int file_exists=0;
213 
214 #if defined(_SION_LINUX)
215  if (stat(fname, &sbuf) == 0) file_exists=1;
216 #elif defined(_SION_DARWIN)
217  if (stat(fname, &sbuf) == 0) file_exists=1;
218 #elif defined(_SION_AIX)
219  if (stat(fname, &sbuf) == 0) file_exists=1;
220 #elif defined(_SION_BGL)
221  if (stat(fname, &sbuf) == 0) file_exists=1;
222 #elif defined(_SION_BGP)
223  if (stat(fname, &sbuf) == 0) file_exists=1;
224 #elif defined(_SION_BGQ)
225  if (stat(fname, &sbuf) == 0) file_exists=1;
226 #elif defined(_SION_XT)
227  if (stat(fname, &sbuf) == 0) file_exists=1;
228 #endif
229  return (file_exists);
230 }
231 
239 sion_int64 _sion_file_set_position( _sion_fileptr *sion_fileptr, sion_int64 startpointer ) {
240  sion_int64 posinfile=SION_SIZE_NOT_VALID;
241 
242  if( sion_fileptr != NULL ) {
243 
244  /* needed to flush data written before set fp to new position */
245 #ifdef FLUSH_BEFORE_SETPOS
246  _sion_flush_file_fp(sion_fileptr);
247 #endif
248 
249  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI) {
250  if(sion_fileptr->flags & SION_FILE_FLAG_SCNDANSI) {
251  posinfile=_sion_file_set_position_ansi(sion_fileptr->second_fileptr, startpointer);
252  } else {
253  posinfile=_sion_file_set_position_ansi(sion_fileptr->fileptr, startpointer);
254  }
255  }
256 
257  if(sion_fileptr->flags & SION_FILE_FLAG_POSIX) {
258  posinfile=_sion_file_set_position_posix(sion_fileptr->fd, startpointer);
259  }
260  }
261 
262  return (posinfile);
263 }
264 
265 
272 sion_int64 _sion_file_get_position( _sion_fileptr *sion_fileptr ) {
273  sion_int64 posinfile=SION_SIZE_NOT_VALID;
274 
275  if(sion_fileptr==NULL) return(-1);
276 
277  /* needed to flush data written before set fp to new position */
278 #ifdef FLUSH_BEFORE_SETPOS
279  _sion_flush_file(sion_fileptr);
280 #endif
281 
282  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI) {
283  if(sion_fileptr->flags & SION_FILE_FLAG_SCNDANSI) {
284  posinfile=_sion_file_get_position_ansi(sion_fileptr->second_fileptr);
285  } else {
286  posinfile=_sion_file_get_position_ansi(sion_fileptr->fileptr);
287  }
288  }
289 
290  if(sion_fileptr->flags & SION_FILE_FLAG_POSIX) {
291  posinfile=_sion_file_get_position_posix(sion_fileptr->fd);
292  }
293 
294  return (posinfile);
295 }
296 
297 
304 int _sion_file_flush( _sion_fileptr *sion_fileptr ) {
305  int rc=SION_SUCCESS;
306 
307  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI) {
308  if(sion_fileptr->flags & SION_FILE_FLAG_SCNDANSI) {
309  rc=_sion_file_flush_ansi(sion_fileptr->second_fileptr);
310  } else {
311  rc=_sion_file_flush_ansi(sion_fileptr->fileptr);
312  }
313  }
314 
315  if(sion_fileptr->flags & SION_FILE_FLAG_POSIX) {
316  rc=_sion_file_flush_posix(sion_fileptr->fd);
317  }
318 
319  return (rc);
320 }
321 
328 int _sion_file_purge( _sion_fileptr *sion_fileptr ) {
329  int rc=SION_SUCCESS;
330 
331  if( sion_fileptr != NULL ) {
332  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI) {
333  if(sion_fileptr->flags & SION_FILE_FLAG_SCNDANSI) {
334  rc=_sion_file_purge_ansi(sion_fileptr->second_fileptr);
335  } else {
336  rc=_sion_file_purge_ansi(sion_fileptr->fileptr);
337  }
338  }
339 
340  if(sion_fileptr->flags & SION_FILE_FLAG_POSIX) {
341  rc=_sion_file_purge_posix(sion_fileptr->fd);
342  }
343  } else {
344  rc=SION_NOT_SUCCESS;
345  }
346 
347  return (rc);
348 }
349 
358 int _sion_file_set_buffer(_sion_fileptr *sion_fileptr, char *buffer, sion_int32 buffer_size) {
359 
360  int rc=SION_SUCCESS;
361 
362  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI) {
363  if(sion_fileptr->flags & SION_FILE_FLAG_SCNDANSI) {
364  rc=_sion_file_set_buffer_ansi(sion_fileptr->second_fileptr, buffer, buffer_size);
365  } else {
366  rc=_sion_file_set_buffer_ansi(sion_fileptr->fileptr, buffer, buffer_size);
367  }
368  }
369 
370  if(sion_fileptr->flags & SION_FILE_FLAG_POSIX) {
371  rc=_sion_file_set_buffer_posix(sion_fileptr->fd, buffer, buffer_size);
372  }
373 
374  return (rc);
375 
376 }
377 
385 int _sion_file_set_second_fileptr( _sion_fileptr *sion_fileptr, FILE* fileptr) {
386  int rc=SION_SUCCESS;
387  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI) {
388  if(sion_fileptr->flags & SION_FILE_FLAG_SCNDANSI) {
389  return(_sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"internal error: second fileptr already set, aborting ...\n"));
390  }
391  sion_fileptr->flags |= SION_FILE_FLAG_SCNDANSI;
392  sion_fileptr->second_fileptr=fileptr;
393  } else {
394  return(_sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"internal error: second fileptr could not be set for POSIX file, aborting ...\n"));
395  }
396  return (rc);
397 }
398 
405 int _sion_file_unset_second_fileptr( _sion_fileptr *sion_fileptr) {
406  int rc=SION_SUCCESS;
407  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI) {
408  if(sion_fileptr->flags & SION_FILE_FLAG_SCNDANSI) {
409  sion_fileptr->flags &= ~SION_FILE_FLAG_SCNDANSI;
410  sion_fileptr->second_fileptr=NULL;
411  } else {
412  return(_sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"internal error: second fileptr was not set, aborting ...\n"));
413  }
414  } else {
415  return(_sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"internal error: second fileptr could not be unset for POSIX file, aborting ...\n"));
416  }
417  return (rc);
418 }
419 
426 int _sion_file_get_fd( _sion_fileptr *sion_fileptr) {
427  int fd=SION_ID_UNDEF;
428  if(sion_fileptr->flags & SION_FILE_FLAG_POSIX) {
429  fd=sion_fileptr->fd;
430  }
431  if(sion_fileptr->flags & SION_FILE_FLAG_ANSI) {
432  if(sion_fileptr->flags & SION_FILE_FLAG_SCNDANSI) {
433  fd=fileno(sion_fileptr->second_fileptr);
434  } else {
435  fd=fileno(sion_fileptr->fileptr);
436  }
437  }
438 
439  return (fd);
440 }
441 
442 
443 
444 /* ********************************************************************************************** */
445 /* *** INTERFACE Functions */
446 /* ********************************************************************************************** */
447 
455 FILE *_sion_file_open_ansi_write_create(const char *fname, unsigned int addflags) {
456  FILE *fileptr=NULL;
457 #if defined(_SION_LINUX)
458  fileptr = fopen(fname, "w");
459 #elif defined(_SION_DARWIN)
460  fileptr = fopen(fname, "w");
461 #elif defined(_SION_AIX)
462  {
463  int fd_oflag = 0;
464  int fd;
465 
466  fd_oflag |= O_CREAT | O_RDWR;
467  fd = open64(fname, fd_oflag, 0664);
468 
469  fileptr = fdopen(fd, "w");
470 
471  }
472 #elif defined(_SION_BGL)
473  fileptr = fopen(fname, "w");
474 #elif defined(_SION_BGP)
475  {
476  int fd_oflag = 0;
477  int fd;
478 
479  fd_oflag |= O_CREAT | O_RDWR;
480  fd = open64(fname, fd_oflag, 0664);
481 
482  fileptr = fdopen(fd, "w");
483 
484  }
485 #elif defined(_SION_BGQ)
486  {
487  int fd_oflag = 0;
488  int fd;
489 
490  fd_oflag |= O_CREAT | O_RDWR;
491  fd = open64(fname, fd_oflag, 0664);
492 
493  fileptr = fdopen(fd, "w");
494 
495  }
496 #elif defined(_SION_XT)
497  fileptr = fopen(fname, "w");
498 #endif
499  return (fileptr);
500 }
501 
509 FILE *_sion_file_open_ansi_write_existing(const char *fname, unsigned int addflags) {
510  FILE *fileptr=NULL;
511 #if defined(_SION_LINUX)
512  /* changed from w to r+ to prevent time truncation of empty existing file */
513  fileptr = fopen(fname, "r+");
514 #elif defined(_SION_DARWIN)
515  fileptr = fopen(fname, "r+");
516 #elif defined(_SION_AIX)
517  {
518  int fd_oflag = 0;
519  int fd;
520 
521  fd_oflag |= O_CREAT | O_RDWR;
522  fd = open64(fname, fd_oflag, 0664);
523 
524  fileptr = fdopen(fd, "r+");
525 
526  }
527 #elif defined(_SION_BGL)
528  fileptr = fopen(fname, "r+");
529 #elif defined(_SION_BGP)
530  {
531  int fd_oflag = 0;
532  int fd;
533 
534  fd_oflag |= O_RDWR;
535  fd = open64(fname, fd_oflag, 0664);
536 
537  fileptr = fdopen(fd, "r+");
538 
539  }
540 #elif defined(_SION_BGQ)
541  {
542  int fd_oflag = 0;
543  int fd;
544 
545  fd_oflag |= O_RDWR;
546  fd = open64(fname, fd_oflag, 0664);
547 
548  fileptr = fdopen(fd, "r+");
549 
550  }
551 #elif defined(_SION_XT)
552  fileptr = fopen(fname, "r+");
553 #endif
554  return (fileptr);
555 }
556 
557 
565 FILE *_sion_file_open_ansi_read(const char *fname, unsigned int addflags) {
566  FILE *fileptr=NULL;
567 #if defined(_SION_LINUX)
568  fileptr = fopen(fname, "r");
569 #elif defined(_SION_DARWIN)
570  fileptr = fopen(fname, "r");
571 #elif defined(_SION_AIX)
572  {
573  int fd_oflag = 0;
574  int fd;
575 
576  fd_oflag |= O_RDONLY;
577  fd = open64(fname, fd_oflag, 0664);
578 
579  fileptr = fdopen(fd, "r");
580 
581  }
582 #elif defined(_SION_BGL)
583  fileptr = fopen(fname, "r");
584 #elif defined(_SION_BGP)
585  {
586  int fd_oflag = 0;
587  int fd;
588 
589  fd_oflag |= O_RDONLY;
590  fd = open64(fname, fd_oflag, 0664);
591 
592  fileptr = fdopen(fd, "r");
593 
594  }
595 #elif defined(_SION_BGQ)
596  {
597  int fd_oflag = 0;
598  int fd;
599 
600  fd_oflag |= O_RDONLY;
601  fd = open64(fname, fd_oflag, 0664);
602 
603  fileptr = fdopen(fd, "r");
604 
605  }
606 #elif defined(_SION_XT)
607  fileptr = fopen(fname, "r");
608 #endif
609  return (fileptr);
610 }
611  int _sion_file_close_ansi(FILE *fileptr) {
618  int rc=SION_SUCCESS;
619  int frc = 1;
620 #if defined(_SION_LINUX)
621  frc= fclose(fileptr);
622 #elif defined(_SION_DARWIN)
623  frc= fclose(fileptr);
624 #elif defined(_SION_AIX)
625  frc= fclose(fileptr);
626 #elif defined(_SION_BGL)
627  frc= fclose(fileptr);
628 #elif defined(_SION_BGP)
629  frc= fclose(fileptr);
630 #elif defined(_SION_BGQ)
631  frc= fclose(fileptr);
632 #elif defined(_SION_XT)
633  frc= fclose(fileptr);
634 #endif
635  if(frc) rc=SION_NOT_SUCCESS;
636  return(rc);
637 }
638 
645 long _sion_file_get_opt_blksize_ansi( FILE *fileptr ) {
646  struct stat sbuf;
647  int fd;
648  long opt_size=SION_SIZE_NOT_VALID;
649 
650  fd = fileno(fileptr);
651 
652 #if defined(_SION_LINUX)
653  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
654 #elif defined(_SION_DARWIN)
655  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
656 #elif defined(_SION_AIX)
657  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
658 #elif defined(_SION_BGL)
659  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
660 #elif defined(_SION_BGP)
661  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
662 #elif defined(_SION_BGQ)
663  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
664 #elif defined(_SION_XT)
665  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
666 #endif
667  return (opt_size);
668 }
669 
677 sion_int64 _sion_file_set_position_ansi(FILE *fileptr, sion_int64 startpointer) {
678 
679  sion_int64 newpos = SION_SIZE_NOT_VALID;
680 
681  DPRINTFP((32, "_sion_set_position_ansi", -1, "enter (to %lld) (to %ld)\n", (long long) startpointer, (long) startpointer));
682 
683 #if defined(_SION_LINUX)
684  {
685  off_t offset = (off_t) startpointer;
686  off_t result;
687  int fd;
688  fd = fileno(fileptr);
689  if (offset != startpointer) {
690  DPRINTFP((32, "_sion_set_position_ansi", -1, "_sion_set_position_ansi: cannot set position to %ld (%lu),%lld (%lu) offset conversion error\n",
691  offset, (unsigned long) sizeof(offset), startpointer, (unsigned long) sizeof(startpointer)));
692  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",
693  offset, (unsigned long) sizeof(offset), startpointer, (unsigned long) sizeof(startpointer)));
694  }
695  newpos = result = lseek(fd, offset, SEEK_SET);
696  DPRINTFP((1024, "_sion_set_position_ansi", -1, "set position=%lld (LINUX)\n", (long long) result));
697  }
698 #elif defined(_SION_DARWIN)
699  {
700  off_t offset = (off_t) startpointer;
701  off_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  newpos = result = fseek(fileptr, offset, SEEK_SET);
707  DPRINTFP((1024, "_sion_set_position_ansi", -1, "set position=%lld (LINUX)\n", (long long) result));
708  }
709 #elif defined(_SION_AIX)
710  off64_t offset = (off_t) startpointer;
711  off64_t result;
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  result = fseeko64(fileptr, offset, SEEK_SET);
717  newpos = result = ftello64(fileptr);
718 #elif defined(_SION_BGL)
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_BGP)
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_BGQ)
739  off_t offset = (off_t) startpointer;
740  off_t result;
741  int fd;
742  if (offset != startpointer) {
743  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",
744  offset, (unsigned long) sizeof(offset), startpointer, (unsigned long) sizeof(startpointer)));
745  }
746  fd = fileno(fileptr);
747  newpos = result = lseek(fd, offset, SEEK_SET);
748 #elif defined(_SION_XT)
749  {
750  off_t offset = (off_t) startpointer;
751  off_t result;
752  int fd;
753  if (offset != startpointer) {
754  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",
755  offset, (unsigned long) sizeof(offset), startpointer, (unsigned long) sizeof(startpointer)));
756  }
757  fd = fileno(fileptr);
758  newpos = result = lseek(fd, offset, SEEK_SET);
759  }
760 #endif
761  DPRINTFP((32, "_sion_set_position_ansi", -1, "leave (%lld --> %lld)\n",(long long) startpointer, (long long) newpos));
762 
763  return (newpos);
764 }
765 
766 
773 sion_int64 _sion_file_get_position_ansi(FILE *fileptr) {
774 
775  sion_int64 result = 0;
776 #if defined(_SION_LINUX)
777  {
778  off_t resulto;
779  int fd = fileno(fileptr);
780  resulto = lseek(fd,0,SEEK_CUR);
781  result = (sion_int64) resulto;
782  DPRINTFP((4096, "_sion_get_position", -1, "get position=%ld (LINUX)\n", (long) result));
783  }
784 #elif defined(_SION_DARWIN)
785  {
786  off_t resulto;
787  resulto = ftello(fileptr);
788  result = (sion_int64) resulto;
789  DPRINTFP((4096, "_sion_get_position", -1, "get position=%ld (DARWIN)\n", (long) result));
790  }
791 #elif defined(_SION_AIX)
792  {
793  result = ftell(fileptr);
794  DPRINTFP((4096, "_sion_get_position", -1, "got position=%lld (AIX)\n", result));
795  }
796 #elif defined(_SION_BGL)
797  {
798  off_t resulto;
799  int fd = fileno(fileptr);
800  resulto = lseek(fd, 0, SEEK_CUR);
801  result = (sion_int64) resulto;
802  DPRINTFP((4096, "_sion_get_position", -1, "got position=%lld (BGL)\n", result));
803  }
804 #elif defined(_SION_BGP)
805  {
806  off_t resulto;
807  int fd = fileno(fileptr);
808  resulto = lseek(fd, 0, SEEK_CUR);
809  result = (sion_int64) resulto;
810  DPRINTFP((4096, "_sion_get_position", -1, "got position=%lld (BGP)\n", result));
811  }
812 #elif defined(_SION_BGQ)
813  {
814  off_t resulto;
815  int fd = fileno(fileptr);
816  resulto = lseek(fd, 0, SEEK_CUR);
817  result = (sion_int64) resulto;
818  DPRINTFP((4096, "_sion_get_position", -1, "got position=%lld (BGQ)\n", result));
819  }
820 #elif defined(_SION_XT)
821  {
822  off_t resulto;
823  int fd = fileno(fileptr);
824  resulto = lseek(fd, 0, SEEK_CUR);
825  result = (sion_int64) resulto;
826  DPRINTFP((4096, "_sion_get_position", -1, "got position=%lld (XT)\n", result));
827  }
828 #endif
829 
830  return (result);
831 }
832 
833 
840 int _sion_file_flush_ansi(FILE *fileptr) {
841 
842  int rc = SION_SUCCESS;
843  int frc;
844 
845 #if defined(_SION_BGP)
846  frc=fflush(fileptr);
847 #elif defined(_SION_BGQ)
848  frc=fflush(fileptr);
849 #else
850  frc=fflush(fileptr);
851 #endif
852  if(frc) rc=SION_NOT_SUCCESS;
853  return (rc);
854 }
855 
856 
863 int _sion_file_purge_ansi(FILE *fileptr) {
864 
865  int rc = SION_SUCCESS;
866  int frc;
867 
868 #if defined(_SION_BGP)
869  /* 1: int fd = fileno(fileptr); */
870  /* fsync(fd); */
871  /* 2: __fpurge(fileptr); */
872  /* restored to fflush due to a not working fpurge in scalasca */
873  frc=fflush(fileptr);
874 #elif defined(_SION_BGQ)
875  /* 1: int fd = fileno(fileptr); */
876  /* fsync(fd); */
877  /* 2: __fpurge(fileptr); */
878  /* restored to fflush due to a not working fpurge in scalasca */
879  frc=fflush(fileptr);
880 #else
881  frc=fflush(fileptr);
882 #endif
883 
884  if(frc) rc=SION_NOT_SUCCESS;
885  return (rc);
886 }
887 
888 
889 
890 
899 int _sion_file_set_buffer_ansi(FILE *fileptr, char *buffer, sion_int32 buffer_size) {
900 
901  int rc = SION_SUCCESS;
902  int frc;
903 
904  DPRINTFP((32, "_sion_file_set_buffer", -1, "set buffer of fileptr\n"));
905 #if defined(_SION_BGP)
906  frc=setvbuf(fileptr, buffer, _IOFBF, (size_t) buffer_size);
907 #elif defined(_SION_BGQ)
908  frc=setvbuf(fileptr, buffer, _IOFBF, (size_t) buffer_size);
909 #elif defined(_SION_AIX)
910  frc=setvbuf(fileptr, buffer, _IOFBF, (size_t) buffer_size);
911 #else
912  frc=setvbuf(fileptr, buffer, _IOFBF, (size_t) buffer_size);
913 #endif
914 
915  if(frc) rc=SION_NOT_SUCCESS;
916  return (rc);
917 }
918 
919 
928 sion_int64 _sion_file_write_ansi(const void *data, sion_int64 bytes, FILE *fileptr ) {
929  sion_int64 left,bsumwrote;
930  size_t bwrite, bwrote;
931  char *dataptr;
932 
933  left = bytes;
934  bsumwrote = 0;
935  dataptr = (char*) data;
936 
937  while (left > 0) {
938  bwrite = left;
939  bwrote = fwrite(dataptr, 1, bwrite, fileptr);
940  left -= bwrote;
941  dataptr += bwrote;
942  bsumwrote += bwrote;
943  }
944  return (bsumwrote);
945 }
946 
955 sion_int64 _sion_file_read_ansi(void *data, sion_int64 bytes, FILE *fileptr ) {
956 
957  sion_int64 left,bsumread;
958  size_t btoread, bread;
959  char *dataptr;
960 
961  left = bytes;
962  bsumread = 0;
963  dataptr = (char*) data;
964 
965  while ((left > 0) && (!feof(fileptr))) {
966  btoread = left;
967  bread = fread(dataptr, 1, btoread, fileptr);
968  left -= bread;
969  dataptr += bread;
970  bsumread += bread;
971  }
972  return (bsumread);
973 }
974 
975 
976 
977 
985 int _sion_file_open_posix_write_create(const char *fname, unsigned int addflags) {
986 
987  int fd = 0;
988  int fd_oflag = 0;
989 
990 #if defined(_SION_LINUX)
991  fd_oflag |= O_CREAT | O_RDWR;
992  fd = open(fname, fd_oflag, 0664);
993 #elif defined(_SION_DARWIN)
994  fd_oflag |= O_CREAT | O_RDWR;
995  fd = open(fname, fd_oflag, 0664);
996 #elif defined(_SION_AIX)
997  fd_oflag |= O_CREAT | O_RDWR;
998  fd = open64(fname, fd_oflag, 0664);
999 #elif defined(_SION_BGL)
1000  fd_oflag |= O_CREAT | O_RDWR;
1001  fd = open64(fname, fd_oflag, 0664);
1002 #elif defined(_SION_BGP)
1003  fd_oflag |= O_CREAT | O_RDWR;
1004  fd = open64(fname, fd_oflag, 0664);
1005 #elif defined(_SION_BGQ)
1006  fd_oflag |= O_CREAT | O_RDWR;
1007  fd = open64(fname, fd_oflag, 0664);
1008 #elif defined(_SION_XT)
1009  fd_oflag |= O_CREAT | O_RDWR;
1010  fd = open64(fname, fd_oflag, 0664);
1011 #endif
1012  return (fd);
1013 }
1014 
1022 int _sion_file_open_posix_write_existing(const char *fname, unsigned int addflags) {
1023 
1024  int fd = 0;
1025  int fd_oflag = 0;
1026 
1027 #if defined(_SION_LINUX)
1028  fd_oflag |= O_RDWR;
1029  fd = open(fname, fd_oflag, 0664);
1030 #elif defined(_SION_DARWIN)
1031  fd_oflag |= O_RDWR;
1032  fd = open(fname, fd_oflag, 0664);
1033 #elif defined(_SION_AIX)
1034  fd_oflag |= O_RDWR;
1035  fd = open64(fname, fd_oflag, 0664);
1036 #elif defined(_SION_BGL)
1037  fd_oflag |= O_RDWR;
1038  fd = open64(fname, fd_oflag, 0664);
1039 #elif defined(_SION_BGP)
1040  fd_oflag |= O_RDWR;
1041  fd = open64(fname, fd_oflag, 0664);
1042 #elif defined(_SION_BGQ)
1043  fd_oflag |= O_RDWR;
1044  fd = open64(fname, fd_oflag, 0664);
1045 #elif defined(_SION_XT)
1046  fd_oflag |= O_RDWR|O_NOATIME;
1047  fd = open64(fname, fd_oflag, 0664);
1048 #endif
1049  return (fd);
1050 }
1051 
1059 int _sion_file_open_posix_read(const char *fname, unsigned int addflags) {
1060  int fd = 0;
1061  int fd_oflag = 0;
1062 
1063 #if defined(_SION_LINUX)
1064  fd_oflag |= O_RDONLY;
1065  fd = open(fname, fd_oflag, 0664);
1066 #elif defined(_SION_DARWIN)
1067  fd_oflag |= O_RDONLY;
1068  fd = open(fname, fd_oflag, 0664);
1069 #elif defined(_SION_AIX)
1070  fd_oflag |= O_RDONLY;
1071  fd = open64(fname, fd_oflag, 0664);
1072 #elif defined(_SION_BGL)
1073  fd_oflag |= O_RDONLY;
1074  fd = open64(fname, fd_oflag, 0664);
1075 #elif defined(_SION_BGP)
1076  fd_oflag |= O_RDONLY;
1077  fd = open64(fname, fd_oflag, 0664);
1078 #elif defined(_SION_BGQ)
1079  fd_oflag |= O_RDONLY;
1080  fd = open64(fname, fd_oflag, 0664);
1081 #elif defined(_SION_XT)
1082  fd_oflag |= O_RDONLY|O_NOATIME;
1083  fd = open(fname, fd_oflag, 0664);
1084 #endif
1085  return (fd);
1086 }
1087 
1088 
1089 
1096 int _sion_file_close_posix(int fd) {
1097  int rc=SION_SUCCESS;
1098  int frc = 1;
1099 
1100 #if defined(_SION_LINUX)
1101  frc= close(fd);
1102 #elif defined(_SION_DARWIN)
1103  frc= close(fd);
1104 #elif defined(_SION_AIX)
1105  frc= close(fd);
1106 #elif defined(_SION_BGL)
1107  frc= close(fd);
1108 #elif defined(_SION_BGP)
1109  frc= close(fd);
1110 #elif defined(_SION_BGQ)
1111  frc= close(fd);
1112 #elif defined(_SION_XT)
1113  frc= close(fd);
1114 #endif
1115 
1116  if(frc) rc=SION_NOT_SUCCESS;
1117  return(rc);
1118 }
1119 
1126 long _sion_file_get_opt_blksize_posix( int fd ) {
1127  struct stat sbuf;
1128  long opt_size=SION_SIZE_NOT_VALID;
1129 
1130 #if defined(_SION_LINUX)
1131  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
1132 #elif defined(_SION_DARWIN)
1133  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
1134 #elif defined(_SION_AIX)
1135  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
1136 #elif defined(_SION_BGL)
1137  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
1138 #elif defined(_SION_BGP)
1139  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
1140 #elif defined(_SION_BGQ)
1141  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
1142 #elif defined(_SION_XT)
1143  if (fstat(fd, &sbuf) == 0) opt_size=(long) sbuf.st_blksize;
1144 #endif
1145  return (opt_size);
1146 }
1147 
1148 
1149 
1157 sion_int64 _sion_file_set_position_posix(int fd, sion_int64 startpointer) {
1158  sion_int64 newpos = SION_SIZE_NOT_VALID;
1159 
1160  DPRINTFP((32, "_sion_set_position_posix", -1, "enter (to %lld)\n", (long long) startpointer));
1161 
1162 #if defined(_SION_LINUX)
1163  {
1164  off_t offset = (off_t) startpointer;
1165  off_t result;
1166  if (offset != startpointer) {
1167  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",
1168  offset, (unsigned long) sizeof(offset), startpointer, (unsigned long) sizeof(startpointer)));
1169  }
1170  newpos = result = lseek(fd, offset, SEEK_SET);
1171  DPRINTFP((4096, "_sion_set_position_posix", -1, "set position=%lld (LINUX)\n", (long long) result));
1172  }
1173 #elif defined(_SION_DARWIN)
1174  {
1175  off_t offset = (off_t) startpointer;
1176  off_t result;
1177  if (offset != startpointer) {
1178  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",
1179  offset, (unsigned long) sizeof(offset), startpointer, (unsigned long) sizeof(startpointer)));
1180  }
1181  newpos = result = lseek(fd, offset, SEEK_SET);
1182  DPRINTFP((4096, "_sion_set_position_posix", -1, "set position=%lld (LINUX)\n", (long long) result));
1183  }
1184 #elif defined(_SION_AIX)
1185  off64_t offset = (off_t) startpointer;
1186  off64_t result;
1187  if (offset != startpointer) {
1188  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",
1189  offset, (unsigned long) sizeof(offset), startpointer, (unsigned long) sizeof(startpointer)));
1190  }
1191  newpos = result = lseek(fd, offset, SEEK_SET);
1192 #elif defined(_SION_BGL)
1193  off_t offset = (off_t) startpointer;
1194  off_t result;
1195  if (offset != startpointer) {
1196  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",
1197  offset, (unsigned long) sizeof(offset), startpointer, (unsigned long) sizeof(startpointer)));
1198  }
1199  newpos = result = lseek(fd, offset, SEEK_SET);
1200 #elif defined(_SION_BGP)
1201  off_t offset = (off_t) startpointer;
1202  off_t result;
1203  if (offset != startpointer) {
1204  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",
1205  offset, (unsigned long) sizeof(offset), startpointer, (unsigned long) sizeof(startpointer)));
1206  }
1207  newpos = result = lseek(fd, offset, SEEK_SET);
1208 #elif defined(_SION_BGQ)
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 #elif defined(_SION_XT)
1217  {
1218  off_t offset = (off_t) startpointer;
1219  off_t result;
1220  if (offset != startpointer) {
1221  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",
1222  offset, (unsigned long) sizeof(offset), startpointer, (unsigned long) sizeof(startpointer)));
1223  }
1224  newpos = result = lseek(fd, offset, SEEK_SET);
1225  }
1226 #endif
1227  DPRINTFP((32, "_sion_set_position_posix", -1, "leave (to %lld)\n",(long long) startpointer));
1228 
1229  return (newpos);
1230 }
1231 
1238 sion_int64 _sion_file_get_position_posix(int fd) {
1239 
1240  sion_int64 result=SION_SIZE_NOT_VALID;
1241 
1242 #if defined(_SION_LINUX)
1243  {
1244  off_t resulto;
1245  resulto = lseek(fd,0,SEEK_CUR);
1246  result = (sion_int64) resulto;
1247  DPRINTFP((4096, "_sion_get_position", -1, "get position=%ld (LINUX)\n", (long) result));
1248  }
1249 #elif defined(_SION_DARWIN)
1250  {
1251  off_t resulto;
1252  resulto = lseek(fd,0,SEEK_CUR);
1253  /* resulto = ftello(fileptr); */
1254  result = (sion_int64) resulto;
1255  DPRINTFP((4096, "_sion_get_position", -1, "get position=%ld (DARWIN)\n", (long) result));
1256  }
1257 #elif defined(_SION_AIX)
1258  {
1259  off_t resulto;
1260  resulto = lseek(fd,0,SEEK_CUR);
1261  /* resulto = ftello(fileptr); */
1262  result = (sion_int64) resulto;
1263  DPRINTFP((4096, "_sion_get_position", -1, "get position=%ld (AIX)\n", (long) result));
1264  }
1265 #elif defined(_SION_BGL)
1266  {
1267  off_t resulto;
1268  int fd = fileno(fileptr);
1269  resulto = lseek(fd, 0, SEEK_CUR);
1270  result = (sion_int64) resulto;
1271  DPRINTFP((4096, "_sion_get_position", -1, "get position=%ld (BGL)\n", (long) result));
1272  }
1273 #elif defined(_SION_BGP)
1274  {
1275  off_t resulto;
1276  resulto = lseek(fd, 0, SEEK_CUR);
1277  result = (sion_int64) resulto;
1278  DPRINTFP((4096, "_sion_get_position", -1, "get position=%ld (BGP)\n", (long) result));
1279  }
1280 #elif defined(_SION_BGQ)
1281  {
1282  off_t resulto;
1283  resulto = lseek(fd, 0, SEEK_CUR);
1284  result = (sion_int64) resulto;
1285  DPRINTFP((4096, "_sion_get_position", -1, "get position=%ld (BGQ)\n", (long) result));
1286  }
1287 #elif defined(_SION_XT)
1288  {
1289  off_t resulto;
1290  int fd = fileno(fileptr);
1291  resulto = lseek(fd, 0, SEEK_CUR);
1292  result = (sion_int64) resulto;
1293  DPRINTFP((4096, "_sion_get_position", -1, "get position=%ld (XT)\n", (long) result));
1294  }
1295 #endif
1296 
1297  return (result);
1298 }
1299 
1306 int _sion_file_flush_posix(int fd) {
1307 
1308  int rc = SION_SUCCESS;
1309  int frc = 0;
1310 #if defined(_SION_BGP)
1311  frc=fsync(fd);
1312 #elif defined(_SION_BGQ)
1313  /* BGQ 20.09.13: bad fsync performance since V1R2M1, try without */
1314  /* rc=fsync(fd); */
1315 #else
1316  frc=fsync(fd);
1317 #endif
1318 
1319  if(frc) rc=SION_NOT_SUCCESS;
1320  return (rc);
1321 }
1322 
1331 int _sion_file_purge_posix(int fd) {
1332 
1333  int rc = SION_SUCCESS;
1334  int frc = 1;
1335 #if defined(_SION_BGP)
1336  frc=fsync(fd);
1337 #elif defined(_SION_BGQ)
1338  /* BGQ 20.09.13: bad fsync performance since V1R2M1, try without */
1339  /* rc=fsync(fd); */
1340 #else
1341  frc=fsync(fd);
1342 #endif
1343 
1344  if(frc) rc=SION_NOT_SUCCESS;
1345  return (rc);
1346 }
1347 
1356 int _sion_file_set_buffer_posix(int fd, char *buffer, sion_int32 buffer_size) {
1357 
1358  int rc = SION_SUCCESS;
1359  int frc = 0;
1360  DPRINTFP((32, "_sion_file_set_buffer", -1, "set buffer of fileptr\n"));
1361 #if defined(_SION_BGP)
1362 #elif defined(_SION_AIX)
1363 #else
1364 #endif
1365  if(frc) rc=SION_NOT_SUCCESS;
1366  return (rc);
1367 }
1368 
1377 sion_int64 _sion_file_write_posix(const void *data, sion_int64 bytes, int fd ) {
1378  sion_int64 left,bsumwrote;
1379  size_t bwrite, bwrote;
1380  char *dataptr;
1381 
1382  left = bytes;
1383  bsumwrote = 0;
1384  dataptr = (char*) data;
1385 
1386  while (left > 0) {
1387  bwrite = left;
1388  bwrote = write(fd, dataptr, bwrite);
1389  left -= bwrote;
1390  dataptr += bwrote;
1391  bsumwrote += bwrote;
1392  }
1393  return (bsumwrote);
1394 }
1395 
1404 sion_int64 _sion_file_read_posix(void *data, sion_int64 bytes, int fd ) {
1405 
1406  sion_int64 left,bsumread;
1407  size_t btoread, bread;
1408  char *dataptr;
1409 
1410  left = bytes;
1411  bsumread = 0;
1412  dataptr = (char*) data;
1413 
1414  while (left > 0) {
1415  btoread = left;
1416  bread = read(fd, dataptr, btoread);
1417  if(bread>0) {
1418  left -= bread;
1419  dataptr += bread;
1420  bsumread += bread;
1421  } else {
1422  if(bread==0) return(bsumread);
1423  else return(bread);
1424  }
1425  }
1426  return (bsumread);
1427 }
1428 
1433 _sion_fileptr *_sion_file_alloc_and_init_sion_fileptr() {
1434  _sion_fileptr *sion_fileptr;
1435 
1436  sion_fileptr = (_sion_fileptr *) malloc(sizeof(_sion_fileptr));
1437  if (sion_fileptr == NULL) {
1438  _sion_errorprint(SION_NOT_SUCCESS,_SION_ERROR_RETURN,"cannot allocate _sion_fileptr structure of size %lu (_sion_fileptr), aborting ...\n",
1439  (unsigned long) sizeof(_sion_fileptr));
1440  return(NULL);
1441  }
1442  sion_fileptr->fileptr = NULL;
1443  sion_fileptr->second_fileptr = NULL;
1444  sion_fileptr->fd = -1;
1445  sion_fileptr->flags = 0;
1446 
1447  return (sion_fileptr);
1448 }
1449 
1450 #define STR_PRT(X) case X: return # X
1451 
1454 char* _sion_fileptrflags_to_str (unsigned int flag) {
1455  switch (flag) {
1456  STR_PRT(SION_FILE_FLAG_ANSI);
1457  STR_PRT(SION_FILE_FLAG_SCNDANSI);
1458  STR_PRT(SION_FILE_FLAG_POSIX);
1459  STR_PRT(SION_FILE_FLAG_CREATE);
1460  STR_PRT(SION_FILE_FLAG_WRITE);
1461  STR_PRT(SION_FILE_FLAG_READ);
1462  }
1463  return "";
1464 }
1465 
1466 
1470 char* _sion_get_fileptr_desc(_sion_fileptr *sion_fileptr) {
1471  int flags;
1472  if(!sion_fileptr) return("<undefined>");
1473  flags = sion_fileptr->flags;
1474 
1475  if(flags & SION_FILE_FLAG_ANSI) {
1476  if(flags & SION_FILE_FLAG_WRITE) {
1477  if(flags & SION_FILE_FLAG_CREATE) {
1478  return("<ANSI,WRITE,CREATE>");
1479  } else {
1480  return("<ANSI,WRITE>");
1481  }
1482  } else {
1483  return("<ANSI,READ>");
1484  }
1485  } else {
1486  if (flags & SION_FILE_FLAG_POSIX) {
1487  if(flags & SION_FILE_FLAG_WRITE) {
1488  if(flags & SION_FILE_FLAG_CREATE) {
1489  return("<POSIX,WRITE,CREATE>");
1490  } else {
1491  return("<POSIX,WRITE>");
1492  }
1493  } else {
1494  return("<POSIX,READ>");
1495  }
1496  }
1497  }
1498  return("<unknown>");
1499 
1500 }
_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:148
_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:190
_sion_file_get_position
sion_int64 _sion_file_get_position(_sion_fileptr *sion_fileptr)
Get new position in file.
Definition: sion_file.c:272
_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:239
_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:41
_sion_fileptrflags_to_str
char * _sion_fileptrflags_to_str(unsigned int flag)
Definition: sion_file.c:1454
_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:645
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:328
_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:169
_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:358
_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:1157
_sion_file_get_fd
int _sion_file_get_fd(_sion_fileptr *sion_fileptr)
Utility function: Get POSIX fp.
Definition: sion_file.c:426
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:677
_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:1238
_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:1126
_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:955
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:773
_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:899
_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:210
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:1470
_sion_file_close
int _sion_file_close(_sion_fileptr *sion_fileptr)
Close file and destroys fileptr structure.
Definition: sion_file.c:118
_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:565
_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:928
_sion_file_flush_posix
int _sion_file_flush_posix(int fd)
POSIX: Flush the data to the disk.
Definition: sion_file.c:1306
_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:385
_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:405
_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:1404
_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:1377
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:840
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:455
_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:985
_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:1022
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:863
_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:1059
_sion_flush_file
int _sion_flush_file(int sid)
Flush the data to the disk for the current task.
Definition: sion_internal.c:971
_sion_file_flush
int _sion_file_flush(_sion_fileptr *sion_fileptr)
Flush data to file.
Definition: sion_file.c:304
_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:1433
_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:509
_sion_file_purge_posix
int _sion_file_purge_posix(int fd)
POSIX: Purge the data to the disk.
Definition: sion_file.c:1331
_sion_file_close_posix
int _sion_file_close_posix(int fd)
POSIX: Close a file.
Definition: sion_file.c:1096
_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:1356
_sion_file_close_ansi
int _sion_file_close_ansi(FILE *fileptr)
ANSI: Close a file.
Definition: sion_file.c:617
SION_FILE_FLAG_SCNDANSI
#define SION_FILE_FLAG_SCNDANSI
Definition: sion_file.h:20
Generated by   doxygen 1.8.15