Refactor all the 'H5VL_*_optional' callbacks to move the type of operation out

of the va_list, so it's at least possible for another connector to know what
the operation is and decide whether to implement it or not.

Added a new VOL sub-class called "introspect" where callbacks that report
information about the connector or container can be placed.  Added an
'opt_query' callback to this sub-class, for a connector to report back
to the library whether a particular optional callback operation is supported.
Also added a 'get_conn_cls' introspection callback, to retrieve the H5VL_class_t
of a connector (either the "current" connector, H5VL_GET_CONN_LVL_CURR, or
the terminal connector, H5VL_GET_CONN_LVL_TERM).

Moved the "post open" operation from a file 'specific' operation to a file
'optional' operation, now that it's possible to detect (with the 'opt_query'
introspection callback) whether a VOL connector implements an optional
operation, without just returning an error.

Added new internal VOL helper routines: H5VL_object_is_native, to determine
if an object is in (or is a) native file, and H5VL_file_is_same, to determine
if two objects are in (or are) the same terminal VOL connector's container.
(And moved the special handling for FILE_IS_EQUAL operation out of internal VOL
callback routine into H5VL_file_is_same)

Made new dataset 'get' operation for H5Dvlen_get_buf_size, aligning it better
with other 'get' operations in API.

Fixed several issues with pass-through connectors, which are now passing the
'make check-passthrough-vol' tests again.

A bunch of warning and style cleanups as well.

1 files changed, 403 insertions, 3 deletions

diff --git a/src/H5trace.c b/src/H5trace.c
index 2fcf82f..f52db02 100644
--- a/src/H5trace.c
+++ b/src/H5trace.c
@@ -2605,6 +2605,25 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
+                    case 'A':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf (out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            H5VL_blob_optional_t optional = (H5VL_blob_optional_t)HDva_arg(ap, int);
+
+                            switch(optional) {
+                                default:
+                                    HDfprintf(out, "%ld", (long)optional);
+                                    break;
+                            } /* end switch */
+                        } /* end else */
+                        break;
+
                     case 'b':
                         if(ptr) {
                             if(vp)
@@ -2634,6 +2653,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'B':
                         if(ptr) {
                             if(vp)
@@ -2663,6 +2683,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'C':
                         if(ptr) {
                             if(vp)
@@ -2679,6 +2700,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                                 HDfprintf(out, "%ld", (long)class_val);
                         } /* end else */
                         break;
+
                     case 'c':
                         if(ptr) {
                             if(vp)
@@ -2711,12 +2733,16 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                                 case H5VL_DATASET_GET_OFFSET:
                                     HDfprintf(out, "H5VL_DATASET_GET_OFFSET");
                                     break;
+                                case H5VL_DATASET_GET_VLEN_BUF_SIZE:
+                                    HDfprintf(out, "H5VL_DATASET_GET_VLEN_BUF_SIZE");
+                                    break;
                                 default:
                                     HDfprintf(out, "%ld", (long)get);
                                     break;
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'd':
                         if(ptr) {
                             if(vp)
@@ -2743,6 +2769,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'e':
                         if(ptr) {
                             if(vp)
@@ -2766,6 +2793,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'f':
                         if(ptr) {
                             if(vp)
@@ -2789,6 +2817,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'g':
                         if(ptr) {
                             if(vp)
@@ -2830,6 +2859,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'h':
                         if(ptr) {
                             if(vp)
@@ -2841,9 +2871,6 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             H5VL_file_specific_t specific = (H5VL_file_specific_t)HDva_arg(ap, int);
 
                             switch(specific) {
-                                case H5VL_FILE_POST_OPEN:
-                                    HDfprintf(out, "H5VL_FILE_POST_OPEN");
-                                    break;
                                 case H5VL_FILE_FLUSH:
                                     HDfprintf(out, "H5VL_FILE_FLUSH");
                                     break;
@@ -2871,6 +2898,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'i':
                         if(ptr) {
                             if(vp)
@@ -2894,6 +2922,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'j':
                         if(ptr) {
                             if(vp)
@@ -2917,6 +2946,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'k':
                         if(ptr) {
                             if(vp)
@@ -2943,6 +2973,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'l':
                         if(ptr) {
                             if(vp)
@@ -2969,6 +3000,31 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
+                    case 'L':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf (out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            H5VL_get_conn_lvl_t get = (H5VL_get_conn_lvl_t)HDva_arg(ap, int);
+
+                            switch(get) {
+                                case H5VL_GET_CONN_LVL_CURR:
+                                    HDfprintf(out, "H5VL_GET_CONN_LVL_CURR");
+                                    break;
+                                case H5VL_GET_CONN_LVL_TERM:
+                                    HDfprintf(out, "H5VL_GET_CONN_LVL_TERM");
+                                    break;
+                                default:
+                                    HDfprintf(out, "%ld", (long)get);
+                                    break;
+                            } /* end switch */
+                        } /* end else */
+                        break;
+
                     case 'm':
                         if(ptr) {
                             if(vp)
@@ -2995,6 +3051,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'n':
                         if(ptr) {
                             if(vp)
@@ -3021,6 +3078,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'o':
                         if(ptr) {
                             if(vp)
@@ -3056,6 +3114,7 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
                     case 'r':
                         if(ptr) {
                             if(vp)
@@ -3082,6 +3141,347 @@ H5_trace(const double *returning, const char *func, const char *type, ...)
                             } /* end switch */
                         } /* end else */
                         break;
+
+                    case 's':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf (out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            H5VL_attr_optional_t optional = (H5VL_attr_optional_t)HDva_arg(ap, int);
+
+                            switch(optional) {
+#ifndef H5_NO_DEPRECATED_SYMBOLS
+                                case H5VL_NATIVE_ATTR_ITERATE_OLD:
+                                    HDfprintf(out, "H5VL_NATIVE_ATTR_ITERATE_OLD");
+                                    break;
+#endif /* H5_NO_DEPRECATED_SYMBOLS */
+                                default:
+                                    HDfprintf(out, "%ld", (long)optional);
+                                    break;
+                            } /* end switch */
+                        } /* end else */
+                        break;
+
+                    case 'S':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf (out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            H5VL_subclass_t subclass = (H5VL_subclass_t)HDva_arg(ap, int);
+
+                            switch(subclass) {
+                                case H5VL_SUBCLS_NONE:
+                                    HDfprintf(out, "H5VL_SUBCLS_NONE");
+                                    break;
+                                case H5VL_SUBCLS_INFO:
+                                    HDfprintf(out, "H5VL_SUBCLS_INFO");
+                                    break;
+                                case H5VL_SUBCLS_WRAP:
+                                    HDfprintf(out, "H5VL_SUBCLS_WRAP");
+                                    break;
+                                case H5VL_SUBCLS_ATTR:
+                                    HDfprintf(out, "H5VL_SUBCLS_ATTR");
+                                    break;
+                                case H5VL_SUBCLS_DATASET:
+                                    HDfprintf(out, "H5VL_SUBCLS_DATASET");
+                                    break;
+                                case H5VL_SUBCLS_DATATYPE:
+                                    HDfprintf(out, "H5VL_SUBCLS_DATATYPE");
+                                    break;
+                                case H5VL_SUBCLS_FILE:
+                                    HDfprintf(out, "H5VL_SUBCLS_FILE");
+                                    break;
+                                case H5VL_SUBCLS_GROUP:
+                                    HDfprintf(out, "H5VL_SUBCLS_GROUP");
+                                    break;
+                                case H5VL_SUBCLS_LINK:
+                                    HDfprintf(out, "H5VL_SUBCLS_LINK");
+                                    break;
+                                case H5VL_SUBCLS_OBJECT:
+                                    HDfprintf(out, "H5VL_SUBCLS_OBJECT");
+                                    break;
+                                case H5VL_SUBCLS_REQUEST:
+                                    HDfprintf(out, "H5VL_SUBCLS_REQUEST");
+                                    break;
+                                case H5VL_SUBCLS_BLOB:
+                                    HDfprintf(out, "H5VL_SUBCLS_BLOB");
+                                    break;
+                                default:
+                                    HDfprintf(out, "%ld", (long)subclass);
+                                    break;
+                            } /* end switch */
+                        } /* end else */
+                        break;
+
+                    case 't':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf (out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            H5VL_dataset_optional_t optional = (H5VL_dataset_optional_t)HDva_arg(ap, int);
+
+                            switch(optional) {
+                                case H5VL_NATIVE_DATASET_FORMAT_CONVERT:
+                                    HDfprintf(out, "H5VL_NATIVE_DATASET_FORMAT_CONVERT");
+                                    break;
+                                case H5VL_NATIVE_DATASET_GET_CHUNK_INDEX_TYPE:
+                                    HDfprintf(out, "H5VL_NATIVE_DATASET_GET_CHUNK_INDEX_TYPE");
+                                    break;
+                                case H5VL_NATIVE_DATASET_GET_CHUNK_STORAGE_SIZE:
+                                    HDfprintf(out, "H5VL_NATIVE_DATASET_GET_CHUNK_STORAGE_SIZE");
+                                    break;
+                                case H5VL_NATIVE_DATASET_GET_NUM_CHUNKS:
+                                    HDfprintf(out, "H5VL_NATIVE_DATASET_GET_NUM_CHUNKS");
+                                    break;
+                                case H5VL_NATIVE_DATASET_GET_CHUNK_INFO_BY_IDX:
+                                    HDfprintf(out, "H5VL_NATIVE_DATASET_GET_CHUNK_INFO_BY_IDX");
+                                    break;
+                                case H5VL_NATIVE_DATASET_GET_CHUNK_INFO_BY_COORD:
+                                    HDfprintf(out, "H5VL_NATIVE_DATASET_GET_CHUNK_INFO_BY_COORD");
+                                    break;
+                                case H5VL_NATIVE_DATASET_CHUNK_READ:
+                                    HDfprintf(out, "H5VL_NATIVE_DATASET_CHUNK_READ");
+                                    break;
+                                case H5VL_NATIVE_DATASET_CHUNK_WRITE:
+                                    HDfprintf(out, "H5VL_NATIVE_DATASET_CHUNK_WRITE");
+                                    break;
+                                default:
+                                    HDfprintf(out, "%ld", (long)optional);
+                                    break;
+                            } /* end switch */
+                        } /* end else */
+                        break;
+
+                    case 'u':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf (out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            H5VL_datatype_optional_t optional = (H5VL_datatype_optional_t)HDva_arg(ap, int);
+
+                            switch(optional) {
+                                default:
+                                    HDfprintf(out, "%ld", (long)optional);
+                                    break;
+                            } /* end switch */
+                        } /* end else */
+                        break;
+
+                    case 'v':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf (out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            H5VL_file_optional_t optional = (H5VL_file_optional_t)HDva_arg(ap, int);
+
+                            switch(optional) {
+                                case H5VL_NATIVE_FILE_CLEAR_ELINK_CACHE:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_CLEAR_ELINK_CACHE");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_FILE_IMAGE:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_FILE_IMAGE");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_FREE_SECTIONS:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_FREE_SECTIONS");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_FREE_SPACE:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_FREE_SPACE");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_INFO:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_INFO");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_MDC_CONF:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_MDC_CONF");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_MDC_HR:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_MDC_HR");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_MDC_SIZE:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_MDC_SIZE");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_SIZE:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_SIZE");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_VFD_HANDLE:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_VFD_HANDLE");
+                                    break;
+                                case H5VL_NATIVE_FILE_RESET_MDC_HIT_RATE:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_RESET_MDC_HIT_RATE");
+                                    break;
+                                case H5VL_NATIVE_FILE_SET_MDC_CONFIG:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_SET_MDC_CONFIG");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_METADATA_READ_RETRY_INFO:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_METADATA_READ_RETRY_INFO");
+                                    break;
+                                case H5VL_NATIVE_FILE_START_SWMR_WRITE:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_START_SWMR_WRITE");
+                                    break;
+                                case H5VL_NATIVE_FILE_START_MDC_LOGGING:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_START_MDC_LOGGING");
+                                    break;
+                                case H5VL_NATIVE_FILE_STOP_MDC_LOGGING:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_STOP_MDC_LOGGING");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_MDC_LOGGING_STATUS:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_MDC_LOGGING_STATUS");
+                                    break;
+                                case H5VL_NATIVE_FILE_FORMAT_CONVERT:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_FORMAT_CONVERT");
+                                    break;
+                                case H5VL_NATIVE_FILE_RESET_PAGE_BUFFERING_STATS:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_RESET_PAGE_BUFFERING_STATS");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_PAGE_BUFFERING_STATS:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_PAGE_BUFFERING_STATS");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_MDC_IMAGE_INFO:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_MDC_IMAGE_INFO");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_EOA:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_EOA");
+                                    break;
+                                case H5VL_NATIVE_FILE_INCR_FILESIZE:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_INCR_FILESIZE");
+                                    break;
+                                case H5VL_NATIVE_FILE_SET_LIBVER_BOUNDS:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_SET_LIBVER_BOUNDS");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_MIN_DSET_OHDR_FLAG:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_MIN_DSET_OHDR_FLAG");
+                                    break;
+                                case H5VL_NATIVE_FILE_SET_MIN_DSET_OHDR_FLAG:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_SET_MIN_DSET_OHDR_FLAG");
+                                    break;
+                                case H5VL_NATIVE_FILE_GET_MPI_ATOMICITY:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_GET_MPI_ATOMICITY");
+                                    break;
+                                case H5VL_NATIVE_FILE_SET_MPI_ATOMICITY:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_SET_MPI_ATOMICITY");
+                                    break;
+                                case H5VL_NATIVE_FILE_POST_OPEN:
+                                    HDfprintf(out, "H5VL_NATIVE_FILE_POST_OPEN");
+                                    break;
+                                default:
+                                    HDfprintf(out, "%ld", (long)optional);
+                                    break;
+                            } /* end switch */
+                        } /* end else */
+                        break;
+
+                    case 'w':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf (out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            H5VL_group_optional_t optional = (H5VL_group_optional_t)HDva_arg(ap, int);
+
+                            switch(optional) {
+#ifndef H5_NO_DEPRECATED_SYMBOLS
+                                case H5VL_NATIVE_GROUP_ITERATE_OLD:
+                                    HDfprintf(out, "H5VL_NATIVE_GROUP_ITERATE_OLD");
+                                    break;
+                                case H5VL_NATIVE_GROUP_GET_OBJINFO:
+                                    HDfprintf(out, "H5VL_NATIVE_GROUP_GET_OBJINFO");
+                                    break;
+#endif /* H5_NO_DEPRECATED_SYMBOLS */
+                                default:
+                                    HDfprintf(out, "%ld", (long)optional);
+                                    break;
+                            } /* end switch */
+                        } /* end else */
+                        break;
+
+                    case 'x':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf (out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            H5VL_link_optional_t optional = (H5VL_link_optional_t)HDva_arg(ap, int);
+
+                            switch(optional) {
+                                default:
+                                    HDfprintf(out, "%ld", (long)optional);
+                                    break;
+                            } /* end switch */
+                        } /* end else */
+                        break;
+
+                    case 'y':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf (out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            H5VL_object_optional_t optional = (H5VL_object_optional_t)HDva_arg(ap, int);
+
+                            switch(optional) {
+                                case H5VL_NATIVE_OBJECT_GET_COMMENT:
+                                    HDfprintf(out, "H5VL_NATIVE_OBJECT_GET_COMMENT");
+                                    break;
+                                case H5VL_NATIVE_OBJECT_GET_INFO:
+                                    HDfprintf(out, "H5VL_NATIVE_OBJECT_GET_INFO");
+                                    break;
+                                case H5VL_NATIVE_OBJECT_SET_COMMENT:
+                                    HDfprintf(out, "H5VL_NATIVE_OBJECT_SET_COMMENT");
+                                    break;
+                                case H5VL_NATIVE_OBJECT_DISABLE_MDC_FLUSHES:
+                                    HDfprintf(out, "H5VL_NATIVE_OBJECT_DISABLE_MDC_FLUSHES");
+                                    break;
+                                case H5VL_NATIVE_OBJECT_ENABLE_MDC_FLUSHES:
+                                    HDfprintf(out, "H5VL_NATIVE_OBJECT_ENABLE_MDC_FLUSHES");
+                                    break;
+                                case H5VL_NATIVE_OBJECT_ARE_MDC_FLUSHES_DISABLED:
+                                    HDfprintf(out, "H5VL_NATIVE_OBJECT_ARE_MDC_FLUSHES_DISABLED");
+                                    break;
+                                default:
+                                    HDfprintf(out, "%ld", (long)optional);
+                                    break;
+                            } /* end switch */
+                        } /* end else */
+                        break;
+
+                    case 'z':
+                        if(ptr) {
+                            if(vp)
+                                HDfprintf (out, "0x%lx", (unsigned long)vp);
+                            else
+                                HDfprintf(out, "NULL");
+                        } /* end if */
+                        else {
+                            H5VL_request_optional_t optional = (H5VL_request_optional_t)HDva_arg(ap, int);
+
+                            switch(optional) {
+                                default:
+                                    HDfprintf(out, "%ld", (long)optional);
+                                    break;
+                            } /* end switch */
+                        } /* end else */
+                        break;
+
                     default:
                         HDfprintf(out, "BADTYPE(Z%c)", type[1]);
                         goto error;