root/ompi/mca/io/romio321/romio/adio/ad_gpfs/ad_gpfs_open.c

DEFINITIONS

1. gpfs_free_all_locks
2. ADIOI_GPFS_Open

   1 /* ---------------------------------------------------------------- */
   2 /* (C)Copyright IBM Corp.  2007, 2008                               */
   3 /* ---------------------------------------------------------------- */
   4 /**
   5  * \file ad_gpfs_open.c
   6  * \brief ???
   7  */
   8 
   9 /* -*- Mode: C; c-basic-offset:4 ; -*- */
  10 /* 
  11  *   Copyright (C) 1997 University of Chicago. 
  12  *   See COPYRIGHT notice in top-level directory.
  13  */
  14 
  15 #include "ad_gpfs.h"
  16 #include "ad_gpfs_tuning.h"
  17 
  18 #include <sys/types.h>
  19 #include <sys/stat.h>
  20 #include <unistd.h>
  21 #include <fcntl.h>
  22 
  23 
  24 #ifdef HAVE_GPFS_H
  25 #include <gpfs.h>
  26 #endif
  27 #ifdef HAVE_GPFS_FCNTL_H
  28 #include <gpfs_fcntl.h>
  29 #endif
  30 
  31 #ifdef HAVE_GPFS_FCNTL_H
  32 static void gpfs_free_all_locks(int fd)
  33 {
  34     int rc;
  35     struct {
  36         gpfsFcntlHeader_t header;
  37         gpfsFreeRange_t release;
  38     } release_all;
  39 
  40     release_all.header.totalLength = sizeof(release_all);
  41     release_all.header.fcntlVersion = GPFS_FCNTL_CURRENT_VERSION;
  42     release_all.header.fcntlReserved = 0;
  43 
  44     release_all.release.structLen = sizeof(release_all.release);
  45     release_all.release.structType = GPFS_FREE_RANGE;
  46     release_all.release.start = 0;
  47     release_all.release.length = 0;
  48 
  49     rc = gpfs_fcntl(fd, &release_all);
  50     if (rc != 0) {
  51         DBGV_FPRINTF(stderr,"GPFS fcntl release failed with rc=%d, errno=%d\n",
  52                 rc,errno);
  53     }
  54 }
  55 #endif
  56 
  57 
  58 void ADIOI_GPFS_Open(ADIO_File fd, int *error_code)
  59 {
  60   int perm, old_mask, amode, rank, rc;
  61   static char myname[] = "ADIOI_GPFS_OPEN";
  62 
  63   /* set internal variables for tuning environment variables */
  64   ad_gpfs_get_env_vars();
  65 
  66   if (fd->perm == ADIO_PERM_NULL)  {
  67     old_mask = umask(022);
  68     umask(old_mask);
  69     perm = old_mask ^ 0666;
  70   }
  71   else perm = fd->perm;
  72 
  73     amode = 0;
  74     if (fd->access_mode & ADIO_CREATE)
  75         amode = amode | O_CREAT;
  76     if (fd->access_mode & ADIO_RDONLY)
  77         amode = amode | O_RDONLY;
  78     if (fd->access_mode & ADIO_WRONLY)
  79         amode = amode | O_WRONLY;
  80     if (fd->access_mode & ADIO_RDWR)
  81         amode = amode | O_RDWR;
  82     if (fd->access_mode & ADIO_EXCL)
  83         amode = amode | O_EXCL;
  84 #ifdef ADIOI_MPE_LOGGING
  85     MPE_Log_event(ADIOI_MPE_open_a, 0, NULL);
  86 #endif
  87     fd->fd_sys = open(fd->filename, amode, perm);
  88 #ifdef ADIOI_MPE_LOGGING
  89     MPE_Log_event(ADIOI_MPE_open_b, 0, NULL);
  90 #endif
  91   DBG_FPRINTF(stderr,"open('%s',%#X,%#X) rc=%d, errno=%d\n",fd->filename,amode,perm,fd->fd_sys,errno);
  92   fd->fd_direct = -1;
  93 
  94   if (gpfsmpio_devnullio == 1) {
  95       fd->null_fd = open("/dev/null", O_RDWR);
  96   } else {
  97       fd->null_fd = -1;
  98   }
  99 
 100   if ((fd->fd_sys != -1) && (fd->access_mode & ADIO_APPEND))
 101     fd->fp_ind = fd->fp_sys_posn = lseek(fd->fd_sys, 0, SEEK_END);
 102 
 103     if(fd->fd_sys != -1)
 104     {
 105 
 106         fd->blksize = 1048576; /* default to 1M */
 107 
 108 #ifdef ADIOI_MPE_LOGGING
 109         MPE_Log_event(ADIOI_MPE_stat_a, 0, NULL);
 110 #endif
 111         /* in this fs-specific routine, we might not be called over entire
 112          * communicator (deferred open).  Collect statistics on one process.
 113          * ADIOI_GEN_Opencoll (common-code caller) will take care of the
 114          * broadcast */
 115 
 116         MPI_Comm_rank(fd->comm, &rank);
 117         if ((rank == fd->hints->ranklist[0]) || (fd->comm == MPI_COMM_SELF)) {
 118             struct stat64 gpfs_statbuf;
 119             /* Get the (real) underlying file system block size */
 120             rc = stat64(fd->filename, &gpfs_statbuf);
 121             if (rc >= 0)
 122             {
 123                 fd->blksize = gpfs_statbuf.st_blksize;
 124                 DBGV_FPRINTF(stderr,"Successful stat '%s'.  Blocksize=%ld\n",
 125                         fd->filename,gpfs_statbuf.st_blksize);
 126             }
 127             else
 128             {
 129                 DBGV_FPRINTF(stderr,"Stat '%s' failed with rc=%d, errno=%d\n",
 130                         fd->filename,rc,errno);
 131             }
 132         }
 133         /* all other ranks have incorrect fd->blocksize, but ADIOI_GEN_Opencoll
 134          * will take care of that in both standard and deferred-open case */
 135 
 136 #ifdef ADIOI_MPE_LOGGING
 137         MPE_Log_event(ADIOI_MPE_stat_b, 0, NULL);
 138 #endif
 139 
 140 #ifdef HAVE_GPFS_FCNTL_H
 141         /* in parallel workload, might be helpful to immediately release block
 142          * tokens.  Or, system call overhead will outweigh any benefits... */
 143         if (getenv("ROMIO_GPFS_FREE_LOCKS")!=NULL)
 144             gpfs_free_all_locks(fd->fd_sys);
 145 
 146 #endif
 147     }
 148 
 149   if (fd->fd_sys == -1)  {
 150       *error_code = ADIOI_Err_create_code(myname, fd->filename, errno);
 151   }
 152   else *error_code = MPI_SUCCESS;
 153 }
 154 /* 
 155  *vim: ts=8 sts=4 sw=4 noexpandtab 
 156  */