Bring SWMR support in to the main development branch. (Finally!) More tests

and the tool and API wrappers will be coming in over the weekend.

1 files changed, 149 insertions, 7 deletions

diff --git a/src/H5Fint.c b/src/H5Fint.c
index 9cf129c..363812d 100644
--- a/src/H5Fint.c
+++ b/src/H5Fint.c
@@ -641,8 +641,8 @@ H5F_new(H5F_file_t *shared, unsigned flags, hid_t fcpl_id, hid_t fapl_id, H5FD_t
             HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, NULL, "can't get sieve buffer size")
         if(H5P_get(plist, H5F_ACS_LATEST_FORMAT_NAME, &latest_format) < 0)
             HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, NULL, "can't get 'latest format' flag")
-        /* For latest format, activate all latest version support */
-        if(latest_format)
+        /* For latest format or SWMR_WRITE, activate all latest version support */
+        if(latest_format || (H5F_INTENT(f) & H5F_ACC_SWMR_WRITE))
             f->shared->latest_flags |= H5F_LATEST_ALL_FLAGS;
         if(H5P_get(plist, H5F_ACS_USE_MDC_LOGGING_NAME, &(f->shared->use_mdc_logging)) < 0)
             HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, NULL, "can't get 'use mdc logging' flag")
@@ -672,6 +672,15 @@ H5F_new(H5F_file_t *shared, unsigned flags, hid_t fcpl_id, hid_t fapl_id, H5FD_t
             HGOTO_ERROR(H5E_FILE, H5E_BADVALUE, NULL, "bad maximum address from VFD")
         if(H5FD_get_feature_flags(lf, &f->shared->feature_flags) < 0)
             HGOTO_ERROR(H5E_FILE, H5E_CANTGET, NULL, "can't get feature flags from VFD")
+
+        /* Require the SWMR feature flag if SWMR I/O is desired */
+        if(!H5F_HAS_FEATURE(f, H5FD_FEAT_SUPPORTS_SWMR_IO) && (H5F_INTENT(f) & (H5F_ACC_SWMR_WRITE | H5F_ACC_SWMR_READ)))
+            HGOTO_ERROR(H5E_FILE, H5E_BADVALUE, NULL, "must use a SWMR-compatible VFD when SWMR is specified")
+
+        /* Require a POSIX compatible VFD to use SWMR feature */
+        /* (It's reasonable to try to expand this to other VFDs eventually -QAK) */
+        if(!H5F_HAS_FEATURE(f, H5FD_FEAT_POSIX_COMPAT_HANDLE) && (H5F_INTENT(f) & (H5F_ACC_SWMR_WRITE | H5F_ACC_SWMR_READ)))
+            HGOTO_ERROR(H5E_FILE, H5E_BADVALUE, NULL, "must use POSIX compatible VFD with SWMR write access")
         if(H5FD_get_fs_type_map(lf, f->shared->fs_type_map) < 0)
             HGOTO_ERROR(H5E_FILE, H5E_CANTGET, NULL, "can't get free space type mapping from VFD")
         if(H5MF_init_merge_flags(f) < 0)
@@ -692,9 +701,23 @@ H5F_new(H5F_file_t *shared, unsigned flags, hid_t fcpl_id, hid_t fapl_id, H5FD_t
         if(H5P_get(plist, H5F_ACS_METADATA_READ_ATTEMPTS_NAME, &f->shared->read_attempts) < 0)
             HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, NULL, "can't get the # of read attempts")
 
-        /* If no value for read attempts has been set, use the default */
-        if(!f->shared->read_attempts)
-            f->shared->read_attempts = H5F_METADATA_READ_ATTEMPTS;
+        /* When opening file with SWMR access, the # of read attempts is H5F_SWMR_METADATA_READ_ATTEMPTS if not set */
+        /* When opening file without SWMR access, the # of read attempts is always H5F_METADATA_READ_ATTEMPTS (set or not set) */
+        if(H5F_INTENT(f) & (H5F_ACC_SWMR_READ | H5F_ACC_SWMR_WRITE)) {
+            /* If no value for read attempts has been set, use the default */
+            if(!f->shared->read_attempts)
+                f->shared->read_attempts = H5F_SWMR_METADATA_READ_ATTEMPTS;
+
+            /* Turn off accumulator with SWMR */
+            f->shared->feature_flags &= ~(unsigned)H5FD_FEAT_ACCUMULATE_METADATA;
+            if(H5FD_set_feature_flags(f->shared->lf, f->shared->feature_flags) < 0)
+                 HGOTO_ERROR(H5E_FILE, H5E_CANTSET, NULL, "can't set feature_flags in VFD")
+        } /* end if */
+        else {
+            /* If no value for read attempts has been set, use the default */
+            if(!f->shared->read_attempts)
+                f->shared->read_attempts = H5F_METADATA_READ_ATTEMPTS;
+        } /* end else */
 
         /* Determine the # of bins for metdata read retries */
         if(H5F_set_retries(f) < 0)
@@ -831,10 +854,19 @@ H5F_dest(H5F_t *f, hid_t dxpl_id, hbool_t flush)
                 /* Flush the file again (if requested), as shutting down the
                  * free space manager may dirty some data structures again.
                  */
-                if(flush)
+                if(flush) {
+		    /* Clear status_flags */
+                    f->shared->sblock->status_flags &= (uint8_t)(~H5F_SUPER_WRITE_ACCESS);
+                    f->shared->sblock->status_flags &= (uint8_t)(~H5F_SUPER_SWMR_WRITE_ACCESS);
+                    /* Mark superblock dirty in cache, so change will get encoded */
+                    /* Push error, but keep going*/
+                    if(H5F_super_dirty(f) < 0)
+                        HDONE_ERROR(H5E_FILE, H5E_CANTMARKDIRTY, FAIL, "unable to mark superblock as dirty")
+
                     if(H5F_flush(f, dxpl_id, TRUE) < 0)
                         /* Push error, but keep going*/
                         HDONE_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to flush cache")
+		} /* end if */
             } /* end if */
 
             /* if it exists, unpin the driver information block cache entry,
@@ -979,6 +1011,37 @@ H5F_dest(H5F_t *f, hid_t dxpl_id, hbool_t flush)
  *		The ACCESS_PARMS argument is optional.  A null pointer will
  *		cause the default file access parameters to be used.
  *
+ * The following two tables show results of file opens for single and concurrent access:
+ *
+ * SINGLE PROCESS ACCESS                        CONCURRENT ACCESS
+ *
+ *             #1st open#                                   #1st open#
+ *             -- SR SR -- -- SR SR --                      -- SR SR -- -- SR SR --
+ *             -- -- SW SW SW SW -- --                      -- -- SW SW SW SW -- --
+ *              W  W  W  W  R  R  R  R                       W  W  W  W  R  R  R  R
+ * #2nd open#                                   #2nd open#
+ *            --------------------------                   --------------------------
+ *   -- --  W | s  x  x  s  x  x  f  f |          -- --  W | f  x  x  f  x  x  f  f |
+ *   SR --  W | x  x  x  x  x  x  x  x |          SR --  W | x  x  x  x  x  x  x  x |
+ *   SR SW  W | x  x  x  x  x  x  x  x |          SR SW  W | x  x  x  x  x  x  x  x |
+ *   -- SW  W | f  x  x  s  x  x  f  f |          -- SW  W | f  x  x  f  x  x  f  f |
+ *   -- SW  R | x  x  x  x  x  x  x  x |          -- SW  R | x  x  x  x  x  x  x  x |
+ *   SR SW  R | x  x  x  x  x  x  x  x |          SR SW  R | x  x  x  x  x  x  x  x |
+ *   SR --  R | s  x  x  s  x  x  s  f |          SR --  R | f  x  x  s  x  x  s  s |
+ *   -- --  R | s  x  x  s  x  x  s  s |          -- --  R | f  x  x  f  x  x  s  s |
+ *            --------------------------                   --------------------------
+ *
+ *      Notations:
+ *        W:  H5F_ACC_RDWR
+ *        R:  H5F_ACC_RDONLY
+ *        SW: H5F_ACC_SWMR_WRITE
+ *        SR: H5F_ACC_SWMR_READ
+ *
+ *        x: the first open or second open itself fails due to invalid flags combination
+ *        f: the open fails with flags combination from both the first and second opens
+ *        s: the open succeeds with flags combination from both the first and second opens
+ *
+ *
  * Return:	Success:	A new file pointer.
  *		Failure:	NULL
  *
@@ -998,6 +1061,8 @@ H5F_open(const char *name, unsigned flags, hid_t fcpl_id, hid_t fapl_id,
     H5FD_class_t       *drvr;               /*file driver class info        */
     H5P_genplist_t     *a_plist;            /*file access property list     */
     H5F_close_degree_t  fc_degree;          /*file close degree             */
+    hbool_t             set_flag = FALSE;   /*set the status_flags in the superblock */
+    hbool_t             clear = FALSE;      /*clear the status_flags 	    */
     hbool_t             evict_on_close;     /* evict on close value from plist  */
     H5F_t              *ret_value = NULL;   /*actual return value           */
     char               *lock_env_var = NULL;/*env var pointer               */
@@ -1074,7 +1139,8 @@ H5F_open(const char *name, unsigned flags, hid_t fcpl_id, hid_t fapl_id,
          * file (since we can't do that while the file is open), or if the
          * request was to create a non-existent file (since the file already
          * exists), or if the new request adds write access (since the
-         * readers don't expect the file to change under them).
+         * readers don't expect the file to change under them), or if the
+         * SWMR write/read access flags don't agree.
          */
         if(H5FD_close(lf) < 0)
             HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "unable to close low-level file info")
@@ -1085,6 +1151,11 @@ H5F_open(const char *name, unsigned flags, hid_t fcpl_id, hid_t fapl_id,
         if((flags & H5F_ACC_RDWR) && 0 == (shared->flags & H5F_ACC_RDWR))
             HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "file is already open for read-only")
 
+        if((flags & H5F_ACC_SWMR_WRITE) && 0 == (shared->flags & H5F_ACC_SWMR_WRITE))
+            HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "SWMR write access flag not the same for file that is already open")
+        if((flags & H5F_ACC_SWMR_READ) && !((shared->flags & H5F_ACC_SWMR_WRITE) || (shared->flags & H5F_ACC_SWMR_READ) || (shared->flags & H5F_ACC_RDWR)))
+            HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "SWMR read access flag not the same for file that is already open")
+
         /* Allocate new "high-level" file struct */
         if((file = H5F_new(shared, flags, fcpl_id, fapl_id, NULL)) == NULL)
             HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "unable to create new file object")
@@ -1116,6 +1187,10 @@ H5F_open(const char *name, unsigned flags, hid_t fcpl_id, hid_t fapl_id,
         /* Create the 'top' file structure */
         if(NULL == (file = H5F_new(NULL, flags, fcpl_id, fapl_id, lf)))
             HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "unable to initialize file structure")
+
+        /* Need to set status_flags in the superblock if the driver has a 'lock' method */
+        if(drvr->lock)
+            set_flag = TRUE;
     } /* end else */
 
     /* Retain the name the file was opened with */
@@ -1171,6 +1246,15 @@ H5F_open(const char *name, unsigned flags, hid_t fcpl_id, hid_t fapl_id,
     if(H5P_get(a_plist, H5F_ACS_CLOSE_DEGREE_NAME, &fc_degree) < 0)
         HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, NULL, "can't get file close degree")
 
+    /* This is a private property to clear the status_flags in the super block */
+    /* Use by h5clear and a routine in test/flush2.c to clear the test file's status_flags */
+    if(H5P_exist_plist(a_plist, H5F_ACS_CLEAR_STATUS_FLAGS_NAME) > 0) {
+        if(H5P_get(a_plist, H5F_ACS_CLEAR_STATUS_FLAGS_NAME, &clear) < 0)
+            HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, NULL, "can't get clearance for status_flags")
+        else if(clear)
+            file->shared->sblock->status_flags = 0;
+    } /* end if */
+
     if(shared->nrefs == 1) {
         if(fc_degree == H5F_CLOSE_DEFAULT)
             shared->fc_degree = lf->cls->fc_degree;
@@ -1207,6 +1291,53 @@ H5F_open(const char *name, unsigned flags, hid_t fcpl_id, hid_t fapl_id,
     if(H5F_build_actual_name(file, a_plist, name, &file->actual_name) < 0)
         HGOTO_ERROR(H5E_FILE, H5E_CANTINIT, NULL, "unable to build actual name")
 
+    if(set_flag) {
+        if(H5F_INTENT(file) & H5F_ACC_RDWR) { /* Set and check consistency of status_flags */
+            /* Skip check of status_flags for file with < superblock version 3 */
+            if(file->shared->sblock->super_vers >= HDF5_SUPERBLOCK_VERSION_3) {
+
+                if(file->shared->sblock->status_flags & H5F_SUPER_WRITE_ACCESS ||
+                        file->shared->sblock->status_flags & H5F_SUPER_SWMR_WRITE_ACCESS)
+                    HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "file is already open for write/SWMR write (may use <h5clear file> to clear file consistency flags)")
+            } /* version 3 superblock */
+
+            file->shared->sblock->status_flags |= H5F_SUPER_WRITE_ACCESS;
+            if(H5F_INTENT(file) & H5F_ACC_SWMR_WRITE)
+                file->shared->sblock->status_flags |= H5F_SUPER_SWMR_WRITE_ACCESS;
+
+            /* Flush the superblock */
+            if(H5F_super_dirty(file) < 0)
+                HGOTO_ERROR(H5E_FILE, H5E_CANTMARKDIRTY, NULL, "unable to mark superblock as dirty")
+            if(H5F_flush_tagged_metadata(file, H5AC__SUPERBLOCK_TAG, H5AC_ind_read_dxpl_id) < 0)
+                HGOTO_ERROR(H5E_FILE, H5E_CANTFLUSH, NULL, "unable to flush superblock")
+
+            /* Remove the file lock for SWMR_WRITE */
+            if(use_file_locking && (H5F_INTENT(file) & H5F_ACC_SWMR_WRITE)) { 
+                if(H5FD_unlock(file->shared->lf) < 0)
+                    HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "unable to unlock the file")
+            } /* end if */
+        } /* end if */
+        else { /* H5F_ACC_RDONLY: check consistency of status_flags */
+            /* Skip check of status_flags for file with < superblock version 3 */
+            if(file->shared->sblock->super_vers >= HDF5_SUPERBLOCK_VERSION_3) {
+
+                if(H5F_INTENT(file) & H5F_ACC_SWMR_READ) { 
+                    if((file->shared->sblock->status_flags & H5F_SUPER_WRITE_ACCESS && 
+                            !(file->shared->sblock->status_flags & H5F_SUPER_SWMR_WRITE_ACCESS))
+                            || 
+                            (!(file->shared->sblock->status_flags & H5F_SUPER_WRITE_ACCESS) && 
+                            file->shared->sblock->status_flags & H5F_SUPER_SWMR_WRITE_ACCESS))
+                        HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "file is not already open for SWMR writing")
+
+                } /* end if */
+                else if((file->shared->sblock->status_flags & H5F_SUPER_WRITE_ACCESS) ||
+                        (file->shared->sblock->status_flags & H5F_SUPER_SWMR_WRITE_ACCESS))
+                    HGOTO_ERROR(H5E_FILE, H5E_CANTOPENFILE, NULL, "file is already open for write (may use <h5clear file> to clear file consistency flags)")
+
+            } /* version 3 superblock */
+        } /* end else */
+    } /* end if set_flag */
+
     /* Success */
     ret_value = file;
 
@@ -2149,6 +2280,8 @@ H5F_get_file_image(H5F_t *file, void *buf_ptr, size_t buf_len, hid_t dxpl_id)
     /* test to see if a buffer was provided -- if not, we are done */
     if(buf_ptr != NULL) {
         size_t	space_needed;		/* size of file image */
+        hsize_t tmp;
+        size_t tmp_size;
         H5P_genplist_t *xfer_plist= NULL;  /* Dataset transfer property list object */
 
         /* Check for buffer too small */
@@ -2165,6 +2298,15 @@ H5F_get_file_image(H5F_t *file, void *buf_ptr, size_t buf_len, hid_t dxpl_id)
         /* (Note compensation for base address addition in internal routine) */
         if(H5FD_read(fd_ptr, xfer_plist, H5FD_MEM_DEFAULT, 0, space_needed, buf_ptr) < 0)
             HGOTO_ERROR(H5E_FILE, H5E_READERROR, FAIL, "file image read request failed")
+
+        /* Offset to "status_flags" in the superblock */
+        tmp = H5F_SUPER_STATUS_FLAGS_OFF(file->shared->sblock->super_vers);
+        /* Size of "status_flags" depends on the superblock version */
+        tmp_size = H5F_SUPER_STATUS_FLAGS_SIZE(file->shared->sblock->super_vers);
+
+        /* Clear "status_flags" */
+        HDmemset((uint8_t *)(buf_ptr) + tmp, 0, tmp_size);
+
     } /* end if */
     
 done: