[svn-r28851] merge from trunk.

0 files changed, 0 insertions, 0 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 65124ab..23b55c6 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -376,6 +376,14 @@ if (HDF5_ENABLE_USING_MEMCHECKER)
 endif (HDF5_ENABLE_USING_MEMCHECKER)
 
 #-----------------------------------------------------------------------------
+# Option to indicate internal memory allocation sanity checks are enabled
+#-----------------------------------------------------------------------------
+option (HDF5_MEMORY_ALLOC_SANITY_CHECK "Indicate that internal memory allocation sanity checks are enabled" OFF)
+if (HDF5_MEMORY_ALLOC_SANITY_CHECK)
+  set (H5_MEMORY_ALLOC_SANITY_CHECK 1)
+endif (HDF5_MEMORY_ALLOC_SANITY_CHECK)
+
+#-----------------------------------------------------------------------------
 # Option to use deprecated public API symbols
 #-----------------------------------------------------------------------------
 option (HDF5_ENABLE_DEPRECATED_SYMBOLS "Enable deprecated public API symbols" ON)
diff --git a/MANIFEST b/MANIFEST
index a870613..3923060 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -643,9 +643,11 @@
 ./src/H5HL.c
 ./src/H5HLcache.c
 ./src/H5HLdbg.c
+./src/H5HLdblk.c
 ./src/H5HLint.c
 ./src/H5HLmodule.h
 ./src/H5HLpkg.h
+./src/H5HLprfx.c
 ./src/H5HLprivate.h
 ./src/H5HLpublic.h
 ./src/H5HP.c
diff --git a/README.txt b/README.txt
index 291e8a6..6dfd021 100644
--- a/README.txt
+++ b/README.txt
@@ -1,4 +1,4 @@
-HDF5 version 1.9.233 released on 2015-10-06
+HDF5 version 1.9.234 currently under development
 Please refer to the release_docs/INSTALL file for installation instructions.
 ------------------------------------------------------------------------------
 
diff --git a/bin/cmakehdf5 b/bin/cmakehdf5
index 772e54c..6e22e17 100755
--- a/bin/cmakehdf5
+++ b/bin/cmakehdf5
@@ -12,8 +12,6 @@
 DPRINT=:
 #DPRINT=echo
 
-# use the ctest scripting method if --script is given
-if [ "$1" != "--script" ]; then
 # variable names
 # The "extra" number is the step number and easier to see all logfiles in
 # the sorted order of steps
@@ -126,12 +124,12 @@ STEP()
 
     echo "$banner" with output saved in $logfile
     (TIMESTAMP; nerror=0 ;
-  echo "eval $command"
-  eval $command || nerror=1 ;
-  TIMESTAMP; exit $nerror) < /dev/null > "$logfile" 2>&1
+	echo "eval $command"
+	eval $command || nerror=1 ;
+	TIMESTAMP; exit $nerror) < /dev/null > "$logfile" 2>&1
     if [ $? -ne 0 ]; then
-  echo "error in '$banner'.  $progname aborted."
-  exit 1
+	echo "error in '$banner'.  $progname aborted."
+	exit 1
     fi
 }
 
@@ -145,26 +143,26 @@ INSTALL_HDF5()
 {
     myos="`uname -s`"
     case "$myos" in
-  Linux)
-      install_file=./HDF5-${version}-Linux.sh
-      $install_file  --skip-license $*
-      ;;
-  Darwin)		# Mac OSX DMG file
-      install_file=HDF5-${version}-Darwin.dmg
-      test -d hdf5 || mkdir hdf5
-      basename=`basename $install_file .dmg`
-      # mount the DMG file as /Volumes/$basename
-      # echo 'Y' as yes for license.
-      echo Y | hdiutil mount $install_file
-      # copy the contents to the install location
-      cp -R "/Volumes/$basename/HDF_Group" hdf5
-      # unmount the DMG file
-      hdiutil unmount /Volumes/$basename
-      ;;
-  *) 		# unknown/unsupported OS.
-      echo "INSTALL_HDF5: Error--unknown/unsupported OS($myos)"
-      return 1
-      ;;
+	Linux)
+	    install_file=./HDF5-${version}-Linux.sh
+	    $install_file  --skip-license $*
+	    ;;
+	Darwin)		# Mac OSX DMG file
+	    install_file=HDF5-${version}-Darwin.dmg
+	    test -d hdf5 || mkdir hdf5
+	    basename=`basename $install_file .dmg`
+	    # mount the DMG file as /Volumes/$basename
+	    # echo 'Y' as yes for license.
+	    echo Y | hdiutil mount $install_file
+	    # copy the contents to the install location
+	    cp -R "/Volumes/$basename/HDF_Group" hdf5
+	    # unmount the DMG file
+	    hdiutil unmount /Volumes/$basename
+	    ;;
+	*) 		# unknown/unsupported OS.
+	    echo "INSTALL_HDF5: Error--unknown/unsupported OS($myos)"
+	    return 1
+	    ;;
     esac
 }
 
@@ -174,14 +172,14 @@ INSTALL_HDF5()
 DUMP_LOGFILE()
 {
     for x in $*; do
-  if [ -f $x ]; then
-      echo "=================================="
-      echo "Dumping $x"
-      echo "=================================="
-      cat $x
-      echo "==== END $x ====="
-      echo
-  fi
+	if [ -f $x ]; then
+	    echo "=================================="
+	    echo "Dumping $x"
+	    echo "=================================="
+	    cat $x
+	    echo "==== END $x ====="
+	    echo
+	fi
     done
 }
 
@@ -209,84 +207,84 @@ fi
 # tools		Build tools
 while [ $# -gt 0 ]; do
     case "$1" in
-  --enable-fortran)
-      build_fortran=-DHDF5_BUILD_FORTRAN:BOOL=ON
-      ;;
-  --disable-fortran)
-      build_fortran=-DHDF5_BUILD_FORTRAN:BOOL=OFF
-      ;;
-  --enable-cxx)
-      build_cpp_lib=-DHDF5_BUILD_CPP_LIB:BOOL=ON
-      ;;
-  --disable-cxx)
-      build_cpp_lib=-DHDF5_BUILD_CPP_LIB:BOOL=OFF
-      ;;
-  --enable-hl)
-      build_hl_lib=-DHDF5_BUILD_HL_LIB:BOOL=ON
-      ;;
-  --disable-hl)
-      build_hl_lib=-DHDF5_BUILD_HL_LIB:BOOL=OFF
-      ;;
-  --enable-shared)
-      shared_lib=-DBUILD_SHARED_LIBS:BOOL=ON
-      ;;
-  --disable-shared)
-      shared_lib=-DBUILD_SHARED_LIBS:BOOL=OFF
-      ;;
-  --enable-tools)
-      build_tools=-DHDF5_BUILD_TOOLS:BOOL=ON
-      ;;
-  --disable-tools)
-      build_tools=-DHDF5_BUILD_TOOLS:BOOL=OFF
-      ;;
-  --enable-testing)
-      build_testing=-DBUILD_TESTING:BOOL=ON
-      ;;
-  --disable-testing)
-      build_testing=-DBUILD_TESTING:BOOL=OFF
-      ;;
-  --with-zlib)
-      with_zlib=-DHDF5_ENABLE_Z_LIB_SUPPORT:BOOL=ON
-      ;;
-  --with-zlib=*)
-      xarg=`echo $1 | cut -d= -f2-`
-      with_zlib="-DHDF5_ENABLE_Z_LIB_SUPPORT:BOOL=ON -DZLIB_ROOT=$xarg"
-      ;;
-  --without-zlib)
-      with_zlib=-DHDF5_ENABLE_Z_LIB_SUPPORT:BOOL=OFF
-      ;;
-  --with-szlib)
-      with_szlib=-DHDF5_ENABLE_SZIP_SUPPORT:BOOL=ON
-      szlib_path=""	# szlib is in default paths
-      ;;
-  --with-szlib=*)
-      xarg=`echo $1 | cut -d= -f2-`
-      with_szlib="-DHDF5_ENABLE_SZIP_SUPPORT:BOOL=ON"
-      szlib_path="SZIP_INSTALL=$xarg"
-      ;;
-  --without-szlib)
-      with_szlib=-DHDF5_ENABLE_SZIP_SUPPORT:BOOL=OFF
-      szlib_path=""	# reset the path
-      ;;
-  --njobs=*)
-      njobs=`echo $1 | cut -d= -f2-`
-      ;;
-  --enable-verbose)
-      vflag=1
-      ;;
-  --disable-verbose)
-      vflag=0
-      ;;
-  --help)
-      # print the detail help page and exit
-      HELP
-      exit 0
-      ;;
-  *)
-      echo "Unknown options: $1"
-      HELP
-      exit 1
-      ;;
+	--enable-fortran)
+	    build_fortran=-DHDF5_BUILD_FORTRAN:BOOL=ON
+	    ;;
+	--disable-fortran)
+	    build_fortran=-DHDF5_BUILD_FORTRAN:BOOL=OFF
+	    ;;
+	--enable-cxx)
+	    build_cpp_lib=-DHDF5_BUILD_CPP_LIB:BOOL=ON
+	    ;;
+	--disable-cxx)
+	    build_cpp_lib=-DHDF5_BUILD_CPP_LIB:BOOL=OFF
+	    ;;
+	--enable-hl)
+	    build_hl_lib=-DHDF5_BUILD_HL_LIB:BOOL=ON
+	    ;;
+	--disable-hl)
+	    build_hl_lib=-DHDF5_BUILD_HL_LIB:BOOL=OFF
+	    ;;
+	--enable-shared)
+	    shared_lib=-DBUILD_SHARED_LIBS:BOOL=ON
+	    ;;
+	--disable-shared)
+	    shared_lib=-DBUILD_SHARED_LIBS:BOOL=OFF
+	    ;;
+	--enable-tools)
+	    build_tools=-DHDF5_BUILD_TOOLS:BOOL=ON
+	    ;;
+	--disable-tools)
+	    build_tools=-DHDF5_BUILD_TOOLS:BOOL=OFF
+	    ;;
+	--enable-testing)
+	    build_testing=-DBUILD_TESTING:BOOL=ON
+	    ;;
+	--disable-testing)
+	    build_testing=-DBUILD_TESTING:BOOL=OFF
+	    ;;
+	--with-zlib)
+	    with_zlib=-DHDF5_ENABLE_Z_LIB_SUPPORT:BOOL=ON
+	    ;;
+	--with-zlib=*)
+	    xarg=`echo $1 | cut -d= -f2-`
+	    with_zlib="-DHDF5_ENABLE_Z_LIB_SUPPORT:BOOL=ON -DZLIB_ROOT=$xarg"
+	    ;;
+	--without-zlib)
+	    with_zlib=-DHDF5_ENABLE_Z_LIB_SUPPORT:BOOL=OFF
+	    ;;
+	--with-szlib)
+	    with_szlib=-DHDF5_ENABLE_SZIP_SUPPORT:BOOL=ON
+	    szlib_path=""	# szlib is in default paths
+	    ;;
+	--with-szlib=*)
+	    xarg=`echo $1 | cut -d= -f2-`
+	    with_szlib="-DHDF5_ENABLE_SZIP_SUPPORT:BOOL=ON"
+	    szlib_path="SZIP_INSTALL=$xarg"
+	    ;;
+	--without-szlib)
+	    with_szlib=-DHDF5_ENABLE_SZIP_SUPPORT:BOOL=OFF
+	    szlib_path=""	# reset the path
+	    ;;
+	--njobs=*)
+	    njobs=`echo $1 | cut -d= -f2-`
+	    ;;
+	--enable-verbose)
+	    vflag=1
+	    ;;
+	--disable-verbose)
+	    vflag=0
+	    ;;
+	--help)
+	    # print the detail help page and exit
+	    HELP
+	    exit 0
+	    ;;
+	*)
+	    echo "Unknown options: $1"
+	    HELP
+	    exit 1
+	    ;;
     esac
     shift
 done
@@ -353,267 +351,3 @@ exit_code=$?
 # Show a closing time stamp
 TIMESTAMP
 exit $exit_code
-
-else
-# ---------------
-# older version
-# ---------------
-
-# variable names
-progname=`basename $0`	# program name
-cminfile="cmakemin.$$" # Cmake minimum file
-cfgfile=$progname.$$	# configure file
-ctest_log=ctest.log    # output of ctest script
-install_log=install.log  # output of installation
-$DPRINT $cfgfile
-
-# Remove temporary generated files if exit 0
-trap "rm -f $cminfile $cfgfile" 0
-
-#=============
-# Function definitions
-#=============
-TIMESTAMP()
-{
-    echo "=====" "`date`" "====="
-}
-
-
-#==========
-# main
-#==========
-# Show a start time stamp
-TIMESTAMP
-
-# Explain what and where log files are.
-cat <<EOF
-$ctest_log: output of ctest script.
-$install_log: output of installation
-Log files will be stored in Testing/Temporary:
-    LastConfigure_<timestamp>.log: output of configure
-    LastBuild_<timestamp>.log: output of build
-    LastTest_<timestamp>.log: output of testing
-    LastTestsFailed_<timestamp>.log: list of failed tests
-
-EOF
-
-# First generate the two needed input files, the $cimnfile and $cfgfile.
-# Then use ctest to use the two input files.
-
-#==========
-# create the configure file
-#==========
-# Create the cmake minimum required file to be used by the following
-# configure file. Though not absolute needed, it is better to generate
-# this file before the configure file.  Quote the EOF to preven substitution
-# in the text.
-#==========
-#==========
-cat > $cfgfile <<'EOF'
-cmake_minimum_required(VERSION 3.1.0 FATAL_ERROR)
-########################################################
-# This dashboard is maintained by The HDF Group
-# For any comments please contact cdashhelp@hdfgroup.org
-#
-########################################################
-
-set (CTEST_DASHBOARD_ROOT ${CTEST_SCRIPT_DIRECTORY})
-set (CTEST_SOURCE_DIRECTORY "../hdf5")
-set (CTEST_BINARY_DIRECTORY ".")
-set (CTEST_CMAKE_GENERATOR "Unix Makefiles")
-set (CTEST_BUILD_CONFIGURATION "Release")
-set (CTEST_MAX_N 8)
-
-# -- CDash variables
-set (LOCAL_NO_SUBMIT TRUE)	# No CDash submit.
-set (MODEL "Experimental")
-set (CDASH_LOCAL TRUE)
-set (SITE_BUILDNAME_SUFFIX "cmakehdf5")
-
-# -- URL set for internal check, default is to not update
-set (LOCAL_SKIP_UPDATE TRUE)
-set (REPOSITORY_URL "http://svn.${hdfgroup_url}/hdf5/branches/hdf5_1_8")
-# -- Standard build options
-set (ADD_BUILD_OPTIONS "-DCMAKE_INSTALL_PREFIX:PATH=${CTEST_BINARY_DIRECTORY} -DHDF5_ALLOW_EXTERNAL_SUPPORT:STRING=\"SVN\" -DHDF5_PACKAGE_EXTLIBS:BOOL=ON")
-
-# Use multiple CPU cores to build
-include(ProcessorCount)
-ProcessorCount(N)
-if(NOT N EQUAL 0)
-  if(N GREATER ${CTEST_MAX_N})
-    set(N ${CTEST_MAX_N})
-  endif(N GREATER ${CTEST_MAX_N})
-  set(CTEST_BUILD_FLAGS -j${N})
-  set(ctest_test_args ${ctest_test_args} PARALLEL_LEVEL ${N})
-endif()
-
-# -----------------------------------------------------------
-# -- Get environment
-# -----------------------------------------------------------
-  ## -- set hostname
-  ## --------------------------
-  find_program (HOSTNAME_CMD NAMES hostname)
-  exec_program (${HOSTNAME_CMD} ARGS OUTPUT_VARIABLE HOSTNAME)
-  set (CTEST_SITE "${HOSTNAME}${CTEST_SITE_EXT}")
-  find_program (UNAME NAMES uname)
-  macro (getuname name flag)
-    exec_program ("${UNAME}" ARGS "${flag}" OUTPUT_VARIABLE "${name}")
-  endmacro (getuname)
-
-  getuname (osname -s)
-  getuname (osrel  -r)
-  getuname (cpu    -m)
-
-  if (SITE_BUILDNAME_SUFFIX)
-    set (CTEST_BUILD_NAME  "${osname}-${osrel}-${cpu}-${SITE_BUILDNAME_SUFFIX}")
-  else (SITE_BUILDNAME_SUFFIX)
-    set (CTEST_BUILD_NAME  "${osname}-${osrel}-${cpu}")
-  endif (SITE_BUILDNAME_SUFFIX)
-# -----------------------------------------------------------
-
-set (BUILD_OPTIONS "${ADD_BUILD_OPTIONS} -DSITE:STRING=${CTEST_SITE} -DBUILDNAME:STRING=${CTEST_BUILD_NAME}")
-
-#-----------------------------------------------------------------------------
-# MAC machines need special option
-#-----------------------------------------------------------------------------
-if (APPLE)
-  # Compiler choice
-  execute_process(COMMAND xcrun --find cc OUTPUT_VARIABLE XCODE_CC OUTPUT_STRIP_TRAILING_WHITESPACE)
-  execute_process(COMMAND xcrun --find c++ OUTPUT_VARIABLE XCODE_CXX OUTPUT_STRIP_TRAILING_WHITESPACE)
-  set(ENV{CC} "${XCODE_CC}")
-  set(ENV{CXX} "${XCODE_CXX}")
-  # Shared fortran is not supported, build static
-  set (BUILD_OPTIONS "${BUILD_OPTIONS} -DBUILD_SHARED_LIBS:BOOL=OFF -DCMAKE_ANSI_CFLAGS:STRING=-fPIC")
-  set (BUILD_OPTIONS "${BUILD_OPTIONS} -DCTEST_USE_LAUNCHERS:BOOL=ON -DCMAKE_BUILD_WITH_INSTALL_RPATH:BOOL=OFF")
-endif (APPLE)
-
-
-# -----------------------------------------------------------
-find_package (Subversion)
-set (CTEST_UPDATE_COMMAND "${Subversion_SVN_EXECUTABLE}")
-# -- Only clean build folder if LOCAL_CLEAR_BUILD is set
-if (LOCAL_CLEAR_BUILD)
-  set (CTEST_START_WITH_EMPTY_BINARY_DIRECTORY TRUE)
-  if(NOT EXISTS "${CTEST_BINARY_DIRECTORY}")
-    file(MAKE_DIRECTORY "${CTEST_BINARY_DIRECTORY}")
-  else()
-    ctest_empty_binary_directory(${CTEST_BINARY_DIRECTORY})
-  endif()
-endif (LOCAL_CLEAR_BUILD)
-
-#-----------------------------------------------------------------------------
-# Send the main script as a note.
-list (APPEND CTEST_NOTES_FILES
-  "${CMAKE_CURRENT_LIST_FILE}"
-  "${CTEST_SOURCE_DIRECTORY}/config/cmake/cacheinit.cmake"
-  )
-
-# Check for required variables.
-foreach (req
-    CTEST_CMAKE_GENERATOR
-    CTEST_SITE
-    CTEST_BUILD_NAME
-    )
-  if (NOT DEFINED ${req})
-    message(FATAL_ERROR "The containing script must set ${req}")
-  endif (NOT DEFINED ${req})
-endforeach (req)
-
-## -- set output to english
-set($ENV{LC_MESSAGES}  "en_EN")
-
-#-----------------------------------------------------------------------------
-# Initialize the CTEST commands
-#------------------------------
-set (CTEST_CMAKE_COMMAND "\"${CMAKE_COMMAND}\"")
-set (CTEST_CONFIGURE_COMMAND
-    "${CTEST_CMAKE_COMMAND} -C \"${CTEST_SOURCE_DIRECTORY}/config/cmake/cacheinit.cmake\" -DCMAKE_BUILD_TYPE:STRING=${CTEST_BUILD_CONFIGURATION} ${BUILD_OPTIONS} \"-G${CTEST_CMAKE_GENERATOR}\" \"${CTEST_SOURCE_DIRECTORY}\"")
-
-# Print summary information.
-foreach (v
-    CTEST_SITE
-    CTEST_BUILD_NAME
-    CTEST_SOURCE_DIRECTORY
-    CTEST_BINARY_DIRECTORY
-    CTEST_CMAKE_GENERATOR
-    CTEST_BUILD_CONFIGURATION
-    CTEST_CONFIGURE_COMMAND
-    CTEST_SCRIPT_DIRECTORY
-    )
-  set (vars "${vars}  ${v}=[${${v}}]\n")
-endforeach (v)
-message ("Dashboard script configuration:\n${vars}\n")
-
-ctest_start (${MODEL} TRACK ${MODEL})
-if (NOT LOCAL_SKIP_UPDATE)
-  ctest_update (SOURCE "${CTEST_SOURCE_DIRECTORY}")
-endif (NOT LOCAL_SKIP_UPDATE)
-if(NOT res STREQUAL "0")
-  message (FATAL_ERROR "Configure FAILED")
-endif()
-message ("Configure DONE")
-configure_file(${CTEST_SOURCE_DIRECTORY}/config/cmake/CTestCustom.cmake ${CTEST_BINARY_DIRECTORY}/CTestCustom.cmake)
-ctest_read_custom_files ("${CTEST_BINARY_DIRECTORY}")
-ctest_configure (BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)
-if (NOT LOCAL_NO_SUBMIT)
-  ctest_submit (PARTS Update Configure Notes)
-endif (NOT LOCAL_NO_SUBMIT)
-ctest_build (BUILD "${CTEST_BINARY_DIRECTORY}" APPEND RETURN_VALUE res)
-if (NOT LOCAL_NO_SUBMIT)
-  ctest_submit (PARTS Build)
-endif (NOT LOCAL_NO_SUBMIT)
-if(NOT res STREQUAL "0")
-  message (FATAL_ERROR "Build FAILED")
-endif()
-message ("build DONE")
-if (NOT LOCAL_SKIP_TEST)
-  ctest_build (BUILD "${CTEST_BINARY_DIRECTORY}" APPEND ${ctest_test_args} RETURN_VALUE res)
-  if (NOT LOCAL_NO_SUBMIT)
-    ctest_submit (PARTS Test)
-  endif (NOT LOCAL_NO_SUBMIT)
-  if(NOT res STREQUAL "0")
-    message (FATAL_ERROR "Test FAILED")
-  endif()
-  message ("test DONE")
-endif (NOT LOCAL_SKIP_TEST)
-if(NOT LOCAL_MEMCHECK_TEST)
-  ##-----------------------------------------------
-  ## Package the product
-  ##-----------------------------------------------
-  execute_process(COMMAND cpack -C ${CTEST_BUILD_CONFIGURATION} -V
-    WORKING_DIRECTORY ${CTEST_BINARY_DIRECTORY}
-    RESULT_VARIABLE cpackResult
-    OUTPUT_VARIABLE cpackLog
-    ERROR_VARIABLE cpackLog.err
-  )
-  file(WRITE ${CTEST_BINARY_DIRECTORY}/cpack.log "${cpackLog.err}" "${cpackLog}")
-endif(NOT LOCAL_MEMCHECK_TEST)
-#-----------------------------------------------------------------------------
-
-message ("DONE")
-EOF
-
-
-# Run ctest
-ctest -S $cfgfile -C Release -V -O $ctest_log
-exit_code=$?
-if [ $exit_code = 0 ]; then
-    echo CTest script completed without error
-else
-    echo Error encountered CTest script
-fi
-# Using HDF5-*.sh because actual name is unavailable
-install_sh=HDF5-*.sh
-echo installing with $install_sh ...
-./$install_sh --skip-license > $install_log
-exit_code=$?
-if [ $exit_code = 0 ]; then
-    echo Complete without error
-else
-    echo Error encountered
-fi
-TIMESTAMP
-exit $exit_code
-
-fi
-
diff --git a/bin/make_err b/bin/make_err
index 4b1f474..1b39d53fb 100755
--- a/bin/make_err
+++ b/bin/make_err
@@ -175,6 +175,12 @@ sub create_public ($) {
     print_warning(*HEADER);
     print_startprotect(*HEADER, $file);
 
+    # Begin extern C block
+    print HEADER "\n";
+    print HEADER "#ifdef __cplusplus\n";
+    print HEADER "extern \"C\" {\n";
+    print HEADER "#endif\n";
+
     # Iterate over all the major errors
     print HEADER "\n/*********************/\n";
     print HEADER   "/* Major error codes */\n";
@@ -202,6 +208,12 @@ sub create_public ($) {
         }
     }
 
+    # End extern C block
+    print HEADER "\n";
+    print HEADER "#ifdef __cplusplus\n";
+    print HEADER "}\n";
+    print HEADER "#endif\n";
+
     print_endprotect(*HEADER, $file);
 
     # Close header file
diff --git a/c++/src/cpp_doc_config b/c++/src/cpp_doc_config
index 7060fd2..623f9c7 100644
--- a/c++/src/cpp_doc_config
+++ b/c++/src/cpp_doc_config
@@ -38,7 +38,7 @@ PROJECT_NAME           = "HDF5 C++ API"
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = "1.9.233 currently under development"
+PROJECT_NUMBER         = "1.9.234 currently under development"
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
diff --git a/config/cmake/cacheinit.cmake b/config/cmake/cacheinit.cmake
index 4bef99f..5cae21b 100644
--- a/config/cmake/cacheinit.cmake
+++ b/config/cmake/cacheinit.cmake
@@ -36,6 +36,8 @@ set (HDF5_ENABLE_COVERAGE OFF CACHE BOOL "Enable code coverage for Libraries and
 
 set (HDF5_ENABLE_USING_MEMCHECKER OFF CACHE BOOL "Indicate that a memory checker is used" FORCE)
 
+set (HDF5_MEMORY_ALLOC_SANITY_CHECK OFF CACHE BOOL "Indicate that internal memory allocation sanity checks are enabled" FORCE)
+
 set (HDF5_DISABLE_COMPILER_WARNINGS OFF CACHE BOOL "Disable compiler warnings" FORCE)
 
 set (HDF5_USE_FOLDERS ON CACHE BOOL "Enable folder grouping of projects in IDEs." FORCE)
diff --git a/config/cmake/libhdf5.settings.cmake.in b/config/cmake/libhdf5.settings.cmake.in
index ba764a4..cc6ae3e 100644
--- a/config/cmake/libhdf5.settings.cmake.in
+++ b/config/cmake/libhdf5.settings.cmake.in
@@ -65,6 +65,7 @@ Features:
                         dmalloc: @H5_HAVE_LIBDMALLOC@
 Clear file buffers before write: @HDF5_Enable_Clear_File_Buffers@
            Using memory checker: @HDF5_ENABLE_USING_MEMCHECKER@
+Memory allocation sanity checks: @HDF5_MEMORY_ALLOC_SANITY_CHECK@
          Function Stack Tracing: @HDF5_ENABLE_CODESTACK@
       Strict File Format Checks: @HDF5_STRICT_FORMAT_CHECKS@
    Optimization Instrumentation: @HDF5_Enable_Instrument@
diff --git a/config/cmake/mccacheinit.cmake b/config/cmake/mccacheinit.cmake
index 19ecc15..e54db1f 100644
--- a/config/cmake/mccacheinit.cmake
+++ b/config/cmake/mccacheinit.cmake
@@ -48,6 +48,8 @@ set (HDF5_ENABLE_COVERAGE OFF CACHE BOOL "Enable code coverage for Libraries and
 
 set (HDF5_ENABLE_USING_MEMCHECKER ON CACHE BOOL "Indicate that a memory checker is used" FORCE)
 
+set (HDF5_MEMORY_ALLOC_SANITY_CHECK OFF CACHE BOOL "Indicate that internal memory allocation sanity checks are enabled" FORCE)
+
 set (HDF5_DISABLE_COMPILER_WARNINGS OFF CACHE BOOL "Disable compiler warnings" FORCE)
 
 set (HDF5_USE_FOLDERS ON CACHE BOOL "Enable folder grouping of projects in IDEs." FORCE)
diff --git a/config/lt_vers.am b/config/lt_vers.am
index 401bcb9..a3b7634 100644
--- a/config/lt_vers.am
+++ b/config/lt_vers.am
@@ -19,7 +19,7 @@
 # After making changes, run bin/reconfigure to update other configure related
 # files like Makefile.in.
 LT_VERS_INTERFACE = 6
-LT_VERS_REVISION = 223
+LT_VERS_REVISION = 224
 LT_VERS_AGE = 0
 
 ## If the API changes *at all*, increment LT_VERS_INTERFACE and
diff --git a/configure.ac b/configure.ac
index 0c3514c..9c1d5b0 100644
--- a/configure.ac
+++ b/configure.ac
@@ -26,7 +26,7 @@ AC_PREREQ([2.69])
 ## NOTE: Do not forget to change the version number here when we do a
 ## release!!!
 ##
-AC_INIT([HDF5], [1.9.232], [help@hdfgroup.org])
+AC_INIT([HDF5], [1.9.234], [help@hdfgroup.org])
 
 AC_CONFIG_SRCDIR([src/H5.c])
 AC_CONFIG_HEADERS([src/H5config.h])
@@ -2044,6 +2044,8 @@ AC_ARG_ENABLE([using-memchecker],
                               library.  Enabling this causes the library to be
                               more picky about it's memory operations and also
                               disables the library's free space manager code.
+                              This option is orthogonal to the
+                              --enable-memory-alloc-sanity-check option.
                               Default=no.])],
               [USINGMEMCHECKER=$enableval])
 
@@ -2062,6 +2064,35 @@ case "X-$USINGMEMCHECKER" in
     ;;
 esac
 
+## ----------------------------------------------------------------------
+## Check if they would like to enable the internal memory allocation sanity
+##     checking code.
+##
+AC_SUBST([MEMORYALLOCSANITYCHECK])
+AC_MSG_CHECKING([whether internal memory allocation sanity checking is used])
+AC_ARG_ENABLE([memory-alloc-sanity-check],
+              [AS_HELP_STRING([--enable-memory-alloc-sanity-check],
+                              [Enable this option to turn on internal memory
+                              allocation sanity checking.  This could cause
+                              more memory use and somewhat slower allocation.
+                              This option is orthogonal to the
+                              --enable-using-memchecker option.
+                              Default=no.])],
+              [MEMORYALLOCSANITYCHECK=$enableval])
+
+case "X-$MEMORYALLOCSANITYCHECK" in
+  X-yes)
+      MEMORYALLOCSANITYCHECK=yes
+      AC_MSG_RESULT([yes])
+      AC_DEFINE([MEMORY_ALLOC_SANITY_CHECK], [1],
+                [Define to enable internal memory allocation sanity checking.])
+    ;;
+  *)
+      MEMORYALLOCSANITYCHECK=no
+      AC_MSG_RESULT([no])
+    ;;
+esac
+
 ## Checkpoint the cache
 AC_CACHE_SAVE
 
diff --git a/examples/h5_vds-percival-unlim.c b/examples/h5_vds-percival-unlim.c
index b5f3ebd..2496c37 100644
--- a/examples/h5_vds-percival-unlim.c
+++ b/examples/h5_vds-percival-unlim.c
@@ -288,8 +288,9 @@ main (void)
 
     /* Read all VDS data */
 
-    //EIP We should be able to do it by using H5S_ALL instead of making selection
-    // or using H5Sselect_all from vspace.
+    /* EIP We should be able to do it by using H5S_ALL instead of making selection
+     * or using H5Sselect_all from vspace. 
+     */
     start[0] = 0;
     start[1] = 0;
     start[2] = 0;
diff --git a/fortran/src/H5Pf.c b/fortran/src/H5Pf.c
index 523ed0b..3989512 100644
--- a/fortran/src/H5Pf.c
+++ b/fortran/src/H5Pf.c
@@ -5273,7 +5273,7 @@ h5pget_file_image_c(hid_t_f *fapl_id, void **buf_ptr, size_t_f *buf_len_ptr)
   *buf_len_ptr=(size_t_f)c_buf_len_ptr;
 
   ret_value = 0;
-  if(c_buf_ptr) HDfree(c_buf_ptr);
+  if(c_buf_ptr) H5free_memory(c_buf_ptr);
 
   return ret_value;
 }
diff --git a/release_docs/INSTALL_CMake.txt b/release_docs/INSTALL_CMake.txt
index e745084..37326ed 100644
--- a/release_docs/INSTALL_CMake.txt
+++ b/release_docs/INSTALL_CMake.txt
@@ -411,6 +411,7 @@ These five steps are described in detail below.
                 set (HDF5_BUILD_PARALLEL_ALL OFF CACHE BOOL "Build Parallel Programs" FORCE)
                 set (HDF5_ENABLE_COVERAGE OFF CACHE BOOL "Enable code coverage for Libraries and Programs" FORCE)
                 set (HDF5_ENABLE_USING_MEMCHECKER OFF CACHE BOOL "Indicate that a memory checker is used" FORCE)
+                set (HDF5_MEMORY_ALLOC_SANITY_CHECK OFF CACHE BOOL "Indicate that internal memory allocation sanity checks are enabled" FORCE)
                 set (HDF5_DISABLE_COMPILER_WARNINGS OFF CACHE BOOL "Disable compiler warnings" FORCE)
                 set (HDF5_USE_FOLDERS ON CACHE BOOL "Enable folder grouping of projects in IDEs." FORCE)
                 set (HDF5_USE_16_API_DEFAULT OFF CACHE BOOL "Use the HDF5 1.6.x API by default" FORCE)
@@ -587,6 +588,7 @@ HDF5_ENABLE_LARGE_FILE         "Enable support for large (64-bit) files on Linux
 HDF5_ENABLE_PARALLEL           "Enable parallel build (requires MPI)"                         OFF
 HDF5_ENABLE_TRACE              "Enable API tracing capability"                                OFF
 HDF5_ENABLE_USING_MEMCHECKER   "Indicate that a memory checker is used"                       OFF
+HDF5_MEMORY_ALLOC_SANITY_CHECK "Indicate that internal memory allocation sanity checks are enabled" OFF
 HDF5_METADATA_TRACE_FILE       "Enable metadata trace file collection"                        OFF
 HDF5_NO_PACKAGES               "Do not include CPack Packaging"                               OFF
 HDF5_PACKAGE_EXTLIBS           "CPACK - include external libraries"                           OFF
diff --git a/release_docs/RELEASE.txt b/release_docs/RELEASE.txt
index 1cfe382..2c9c79f 100644
--- a/release_docs/RELEASE.txt
+++ b/release_docs/RELEASE.txt
@@ -1,4 +1,4 @@
-HDF5 version 1.9.233 released on 2015-10-06
+HDF5 version 1.9.234 currently under development
 ================================================================================
 
 
diff --git a/src/H5.c b/src/H5.c
index 33ac340..a522398 100644
--- a/src/H5.c
+++ b/src/H5.c
@@ -396,6 +396,11 @@ H5_term_library(void)
         (void)H5MM_free(tmp_open_stream);
     } /* end while */
 
+#if defined H5_MEMORY_ALLOC_SANITY_CHECK
+    /* Sanity check memory allocations */
+    H5MM_final_sanity_check();
+#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
+
     /* Reset flag indicating that the library is being shut down */
     H5_TERM_GLOBAL = FALSE;
 
@@ -942,7 +947,6 @@ H5allocate_memory(size_t size, hbool_t clear)
         ret_value = H5MM_malloc(size);
 
     FUNC_LEAVE_API(ret_value)
-
 } /* end H5allocate_memory() */
 
 
@@ -981,7 +985,6 @@ H5resize_memory(void *mem, size_t size)
     ret_value = H5MM_realloc(mem, size);
 
     FUNC_LEAVE_API(ret_value)
-
 } /* end H5resize_memory() */
 
 
@@ -1004,10 +1007,9 @@ H5free_memory(void *mem)
     H5TRACE1("e", "*x", mem);
 
     /* At this time, it is impossible for this to fail. */
-    HDfree(mem);
+    H5MM_xfree(mem);
 
     FUNC_LEAVE_API(SUCCEED)
-
 } /* end H5free_memory() */
 
 
diff --git a/src/H5A.c b/src/H5A.c
index 8dcea8d..ea95fdd 100644
--- a/src/H5A.c
+++ b/src/H5A.c
@@ -244,7 +244,6 @@ H5A_term_package(void)
     develop.
 
 --------------------------------------------------------------------------*/
-/* ARGSUSED */
 hid_t
 H5Acreate2(hid_t loc_id, const char *attr_name, hid_t type_id, hid_t space_id,
     hid_t acpl_id, hid_t aapl_id)
@@ -325,7 +324,6 @@ done:
     develop.
 
 --------------------------------------------------------------------------*/
-/* ARGSUSED */
 hid_t
 H5Acreate_by_name(hid_t loc_id, const char *obj_name, const char *attr_name,
     hid_t type_id, hid_t space_id, hid_t acpl_id, hid_t aapl_id,
diff --git a/src/H5AC.c b/src/H5AC.c
index 52e7e58..39de07e 100644
--- a/src/H5AC.c
+++ b/src/H5AC.c
@@ -46,6 +46,7 @@
 #include "H5FDprivate.h"	/* File drivers				*/
 #include "H5Iprivate.h"		/* IDs			  		*/
 #include "H5Pprivate.h"         /* Property lists                       */
+#include "H5SLprivate.h"        /* Skip Lists                           */
 
 
 /****************/
diff --git a/src/H5Abtree2.c b/src/H5Abtree2.c
index 972fb0b..716ad4a 100644
--- a/src/H5Abtree2.c
+++ b/src/H5Abtree2.c
@@ -116,9 +116,7 @@ const H5B2_class_t H5A_BT2_NAME[1]={{  /* B-tree class information */
     H5A__dense_btree2_name_compare,     /* Record comparison callback */
     H5A__dense_btree2_name_encode,      /* Record encoding callback */
     H5A__dense_btree2_name_decode,      /* Record decoding callback */
-    H5A__dense_btree2_name_debug,       /* Record debugging callback */
-    NULL,                              /* Create debugging context */
-    NULL                               /* Destroy debugging context */
+    H5A__dense_btree2_name_debug        /* Record debugging callback */
 }};
 
 /* v2 B-tree class for indexing 'creation order' field of attributes */
@@ -132,9 +130,7 @@ const H5B2_class_t H5A_BT2_CORDER[1]={{ /* B-tree class information */
     H5A__dense_btree2_corder_compare,   /* Record comparison callback */
     H5A__dense_btree2_corder_encode,    /* Record encoding callback */
     H5A__dense_btree2_corder_decode,    /* Record decoding callback */
-    H5A__dense_btree2_corder_debug,     /* Record debugging callback */
-    NULL,                              /* Create debugging context */
-    NULL                               /* Destroy debugging context */
+    H5A__dense_btree2_corder_debug      /* Record debugging callback */
 }};
 
 
diff --git a/src/H5Aint.c b/src/H5Aint.c
index baa352c..12ffb7d 100644
--- a/src/H5Aint.c
+++ b/src/H5Aint.c
@@ -1878,7 +1878,7 @@ H5A_set_version(const H5F_t *f, H5A_t *attr)
 
     /* Check which version to encode attribute with */
     if(use_latest_format)
-        attr->shared->version = H5O_ATTR_VERSION_LATEST;      /* Write out latest version of format */
+        attr->shared->version = H5O_ATTR_VERSION_LATEST;      /* Write out latest attribute version */
     else if(attr->shared->encoding != H5T_CSET_ASCII)
         attr->shared->version = H5O_ATTR_VERSION_3;   /* Write version which includes the character encoding */
     else if(type_shared || space_shared)
diff --git a/src/H5B.c b/src/H5B.c
index 7f933cd..b26c38b 100644
--- a/src/H5B.c
+++ b/src/H5B.c
@@ -612,6 +612,7 @@ H5B_insert(H5F_t *f, hid_t dxpl_id, const H5B_class_t *type, haddr_t addr, void
 
     /* Check if the root node split */
     if(H5B_INS_NOOP == my_ins) {
+        /* The root node did not split - just return */
         HDassert(!split_bt_ud.bt);
         HGOTO_DONE(SUCCEED)
     } /* end if */
@@ -2035,7 +2036,7 @@ htri_t
 H5B_valid(H5F_t *f, hid_t dxpl_id, const H5B_class_t *type, haddr_t addr)
 {
     H5B_t               *bt = NULL;             /* The B-tree */
-    H5UC_t	        *rc_shared;             /* Ref-counted shared info */
+    H5UC_t              *rc_shared;             /* Ref-counted shared info */
     H5B_shared_t        *shared;                /* Pointer to shared B-tree info */
     H5B_cache_ud_t      cache_udata;            /* User-data for metadata cache callback */
     htri_t		ret_value = SUCCEED;    /* Return value */
diff --git a/src/H5B2.c b/src/H5B2.c
index 7eb88c4..a1e9d37 100644
--- a/src/H5B2.c
+++ b/src/H5B2.c
@@ -42,6 +42,7 @@
 #include "H5private.h"		/* Generic Functions			*/
 #include "H5B2pkg.h"		/* v2 B-trees				*/
 #include "H5Eprivate.h"		/* Error handling		  	*/
+#include "H5MMprivate.h"	/* Memory management			*/
 
 
 /****************/
@@ -86,6 +87,7 @@ extern const H5B2_class_t H5G_BT2_CORDER[1];
 extern const H5B2_class_t H5SM_INDEX[1];
 extern const H5B2_class_t H5A_BT2_NAME[1];
 extern const H5B2_class_t H5A_BT2_CORDER[1];
+extern const H5B2_class_t H5B2_TEST2[1];
 
 const H5B2_class_t *const H5B2_client_class_g[] = {
     H5B2_TEST,			/* 0 - H5B2_TEST_ID 			*/
@@ -98,6 +100,7 @@ const H5B2_class_t *const H5B2_client_class_g[] = {
     H5SM_INDEX,			/* 7 - H5B2_SOHM_INDEX_ID 		*/
     H5A_BT2_NAME,		/* 8 - H5B2_ATTR_DENSE_NAME_ID 		*/
     H5A_BT2_CORDER,		/* 9 - H5B2_ATTR_DENSE_CORDER_ID 	*/
+    H5B2_TEST2,			/* 10 - H5B2_TEST_ID 			*/
 };
 
 
@@ -134,7 +137,6 @@ H5B2_create(H5F_t *f, hid_t dxpl_id, const H5B2_create_t *cparam, void *ctx_udat
 {
     H5B2_t      *bt2 = NULL;            /* Pointer to the B-tree */
     H5B2_hdr_t  *hdr = NULL;            /* Pointer to the B-tree header */
-    H5B2_hdr_cache_ud_t cache_udata;    /* User-data for callback */
     haddr_t     hdr_addr;               /* B-tree header address */
     H5B2_t      *ret_value = NULL;      /* Return value */
 
@@ -158,11 +160,8 @@ H5B2_create(H5F_t *f, hid_t dxpl_id, const H5B2_create_t *cparam, void *ctx_udat
         HGOTO_ERROR(H5E_BTREE, H5E_CANTALLOC, NULL, "memory allocation failed for v2 B-tree info")
 
     /* Look up the B-tree header */
-    cache_udata.f = f;
-    cache_udata.addr = hdr_addr;
-    cache_udata.ctx_udata = ctx_udata;
-    if(NULL == (hdr = (H5B2_hdr_t *)H5AC_protect(f, dxpl_id, H5AC_BT2_HDR, hdr_addr, &cache_udata, H5AC__NO_FLAGS_SET)))
-        HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, NULL, "unable to load B-tree header")
+    if(NULL == (hdr = H5B2__hdr_protect(f, dxpl_id, hdr_addr, ctx_udata, H5AC__NO_FLAGS_SET)))
+        HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, NULL, "unable to protect v2 B-tree header")
 
     /* Point v2 B-tree wrapper at header and bump it's ref count */
     bt2->hdr = hdr;
@@ -180,7 +179,7 @@ H5B2_create(H5F_t *f, hid_t dxpl_id, const H5B2_create_t *cparam, void *ctx_udat
     ret_value = bt2;
 
 done:
-    if(hdr && H5AC_unprotect(f, dxpl_id, H5AC_BT2_HDR, hdr_addr, hdr, H5AC__NO_FLAGS_SET) < 0)
+    if(hdr && H5B2__hdr_unprotect(hdr, dxpl_id, H5AC__NO_FLAGS_SET) < 0)
         HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, NULL, "unable to release v2 B-tree header")
     if(!ret_value && bt2)
         if(H5B2_close(bt2, dxpl_id) < 0)
@@ -209,7 +208,6 @@ H5B2_open(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *ctx_udata)
 {
     H5B2_t	*bt2 = NULL;            /* Pointer to the B-tree */
     H5B2_hdr_t	*hdr = NULL;            /* Pointer to the B-tree header */
-    H5B2_hdr_cache_ud_t cache_udata;    /* User-data for callback */
     H5B2_t	*ret_value = NULL;      /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
@@ -219,11 +217,8 @@ H5B2_open(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *ctx_udata)
     HDassert(H5F_addr_defined(addr));
 
     /* Look up the B-tree header */
-    cache_udata.f = f;
-    cache_udata.addr = addr;
-    cache_udata.ctx_udata = ctx_udata;
-    if(NULL == (hdr = (H5B2_hdr_t *)H5AC_protect(f, dxpl_id, H5AC_BT2_HDR, addr, &cache_udata, H5AC__READ_ONLY_FLAG)))
-	HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, NULL, "unable to load B-tree header")
+    if(NULL == (hdr = H5B2__hdr_protect(f, dxpl_id, addr, ctx_udata, H5AC__READ_ONLY_FLAG)))
+	HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, NULL, "unable to protect v2 B-tree header")
 
     /* Check for pending heap deletion */
     if(hdr->pending_delete)
@@ -249,7 +244,7 @@ H5B2_open(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *ctx_udata)
     ret_value = bt2;
 
 done:
-    if(hdr && H5AC_unprotect(f, dxpl_id, H5AC_BT2_HDR, addr, hdr, H5AC__NO_FLAGS_SET) < 0)
+    if(hdr && H5B2__hdr_unprotect(hdr, dxpl_id, H5AC__NO_FLAGS_SET) < 0)
         HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, NULL, "unable to release v2 B-tree header")
     if(!ret_value && bt2)
         if(H5B2_close(bt2, dxpl_id) < 0)
@@ -290,36 +285,78 @@ H5B2_insert(H5B2_t *bt2, hid_t dxpl_id, void *udata)
     /* Get the v2 B-tree header */
     hdr = bt2->hdr;
 
+    /* Insert the record */
+    if(H5B2__insert_hdr(hdr, dxpl_id, udata) < 0)
+        HGOTO_ERROR(H5E_BTREE, H5E_CANTINSERT, FAIL, "unable to insert record into B-tree")
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5B2_insert() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5B2_update
+ *
+ * Purpose:	Insert or modify a record to the B-tree.
+ *		If the record exists already, it is modified as if H5B2_modify
+ *		was called).  If it doesn't exist, it is inserted as if
+ *		H5B2_insert was called.
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Quincey Koziol
+ *		koziol@hdfgroup.org
+ *		Dec 23 2015
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5B2_update(H5B2_t *bt2, hid_t dxpl_id, void *udata, H5B2_modify_t op, void *op_data)
+{
+    H5B2_hdr_t	*hdr;           /* Pointer to the B-tree header */
+    H5B2_update_status_t status = H5B2_UPDATE_UNKNOWN;   /* Whether the record was inserted/modified */
+    herr_t ret_value = SUCCEED; /* Return value */
+
+    FUNC_ENTER_NOAPI(FAIL)
+
+    /* Check arguments. */
+    HDassert(bt2);
+    HDassert(udata);
+
+    /* Set the shared v2 B-tree header's file context for this operation */
+    bt2->hdr->f = bt2->f;
+
+    /* Get the v2 B-tree header */
+    hdr = bt2->hdr;
+
     /* Check if the root node is allocated yet */
     if(!H5F_addr_defined(hdr->root.addr)) {
         /* Create root node as leaf node in B-tree */
         if(H5B2__create_leaf(hdr, dxpl_id, &(hdr->root)) < 0)
 	    HGOTO_ERROR(H5E_BTREE, H5E_CANTINIT, FAIL, "unable to create root node")
     } /* end if */
-    /* Check if we need to split the root node (equiv. to a 1->2 node split) */
-    else if(hdr->root.node_nrec == hdr->node_info[hdr->depth].split_nrec) {
-        /* Split root node */
-        if(H5B2__split_root(hdr, dxpl_id) < 0)
-            HGOTO_ERROR(H5E_BTREE, H5E_CANTSPLIT, FAIL, "unable to split root node")
-    } /* end if */
 
     /* Attempt to insert record into B-tree */
     if(hdr->depth > 0) {
-        if(H5B2__insert_internal(hdr, dxpl_id, hdr->depth, NULL, &hdr->root, H5B2_POS_ROOT, udata) < 0)
-            HGOTO_ERROR(H5E_BTREE, H5E_CANTINSERT, FAIL, "unable to insert record into B-tree internal node")
+        if(H5B2__update_internal(hdr, dxpl_id, hdr->depth, NULL, &hdr->root, &status, H5B2_POS_ROOT, udata, op, op_data) < 0)
+            HGOTO_ERROR(H5E_BTREE, H5E_CANTINSERT, FAIL, "unable to update record in B-tree internal node")
     } /* end if */
     else {
-        if(H5B2__insert_leaf(hdr, dxpl_id, &hdr->root, H5B2_POS_ROOT, udata) < 0)
-            HGOTO_ERROR(H5E_BTREE, H5E_CANTINSERT, FAIL, "unable to insert record into B-tree leaf node")
+        if(H5B2__update_leaf(hdr, dxpl_id, &hdr->root, &status, H5B2_POS_ROOT, udata, op, op_data) < 0)
+            HGOTO_ERROR(H5E_BTREE, H5E_CANTINSERT, FAIL, "unable to update record in B-tree leaf node")
     } /* end else */
 
-    /* Mark B-tree header as dirty */
-    if(H5B2__hdr_dirty(hdr) < 0)
-        HGOTO_ERROR(H5E_BTREE, H5E_CANTMARKDIRTY, FAIL, "unable to mark B-tree header dirty")
+    /* Sanity check */
+    HDassert(H5B2_UPDATE_UNKNOWN != status);
+
+    /* Use insert algorithm if nodes to leaf full */
+    if(H5B2_UPDATE_INSERT_CHILD_FULL == status)
+        if(H5B2__insert_hdr(hdr, dxpl_id, udata) < 0)
+            HGOTO_ERROR(H5E_BTREE, H5E_CANTINSERT, FAIL, "unable to insert record into B-tree")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* H5B2_insert() */
+} /* H5B2_update() */
 
 
 /*-------------------------------------------------------------------------
@@ -578,7 +615,7 @@ H5B2_find(H5B2_t *bt2, hid_t dxpl_id, void *udata, H5B2_found_t op,
                 if(idx == 0) {
                     if(H5B2_POS_LEFT == curr_pos || H5B2_POS_ROOT == curr_pos) {
                         if(hdr->min_native_rec == NULL)
-                            if(NULL == (hdr->min_native_rec = (uint8_t *)HDmalloc(hdr->cls->nrec_size)))
+                            if(NULL == (hdr->min_native_rec = H5MM_malloc(hdr->cls->nrec_size)))
                                 HGOTO_ERROR(H5E_BTREE, H5E_CANTALLOC, FAIL, "memory allocation failed for v2 B-tree min record info")
                         HDmemcpy(hdr->min_native_rec, H5B2_LEAF_NREC(leaf, hdr, idx), hdr->cls->nrec_size);
                     } /* end if */
@@ -586,7 +623,7 @@ H5B2_find(H5B2_t *bt2, hid_t dxpl_id, void *udata, H5B2_found_t op,
                 if(idx == (unsigned)(leaf->nrec - 1)) {
                     if(H5B2_POS_RIGHT == curr_pos || H5B2_POS_ROOT == curr_pos) {
                         if(hdr->max_native_rec == NULL)
-                            if(NULL == (hdr->max_native_rec = (uint8_t *)HDmalloc(hdr->cls->nrec_size)))
+                            if(NULL == (hdr->max_native_rec = H5MM_malloc(hdr->cls->nrec_size)))
                                 HGOTO_ERROR(H5E_BTREE, H5E_CANTALLOC, FAIL, "memory allocation failed for v2 B-tree max record info")
                         HDmemcpy(hdr->max_native_rec, H5B2_LEAF_NREC(leaf, hdr, idx), hdr->cls->nrec_size);
                     } /* end if */
@@ -1188,7 +1225,7 @@ H5B2_modify(H5B2_t *bt2, hid_t dxpl_id, void *udata, H5B2_modify_t op,
                 if(idx == 0) {
                     if(H5B2_POS_LEFT == curr_pos || H5B2_POS_ROOT == curr_pos) {
                         if(hdr->min_native_rec == NULL)
-                            if(NULL == (hdr->min_native_rec = (uint8_t *)HDmalloc(hdr->cls->nrec_size)))
+                            if(NULL == (hdr->min_native_rec = H5MM_malloc(hdr->cls->nrec_size)))
                                 HGOTO_ERROR(H5E_BTREE, H5E_CANTALLOC, FAIL, "memory allocation failed for v2 B-tree min record info")
                         HDmemcpy(hdr->min_native_rec, H5B2_LEAF_NREC(leaf, hdr, idx), hdr->cls->nrec_size);
                     } /* end if */
@@ -1196,7 +1233,7 @@ H5B2_modify(H5B2_t *bt2, hid_t dxpl_id, void *udata, H5B2_modify_t op,
                 if(idx == (unsigned)(leaf->nrec - 1)) {
                     if(H5B2_POS_RIGHT == curr_pos || H5B2_POS_ROOT == curr_pos) {
                         if(hdr->max_native_rec == NULL)
-                            if(NULL == (hdr->max_native_rec = (uint8_t *)HDmalloc(hdr->cls->nrec_size)))
+                            if(NULL == (hdr->max_native_rec = H5MM_malloc(hdr->cls->nrec_size)))
                                 HGOTO_ERROR(H5E_BTREE, H5E_CANTALLOC, FAIL, "memory allocation failed for v2 B-tree max record info")
                         HDmemcpy(hdr->max_native_rec, H5B2_LEAF_NREC(leaf, hdr, idx), hdr->cls->nrec_size);
                     } /* end if */
@@ -1210,7 +1247,7 @@ H5B2_modify(H5B2_t *bt2, hid_t dxpl_id, void *udata, H5B2_modify_t op,
         /* Unlock current node */
         if(H5AC_unprotect(hdr->f, dxpl_id, H5AC_BT2_LEAF, curr_node_ptr.addr, leaf, leaf_flags) < 0)
             HGOTO_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree node")
-    }
+    } /* end block */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -1282,7 +1319,7 @@ H5B2_close(H5B2_t *bt2, hid_t dxpl_id)
 
         /* Lock the v2 B-tree header into memory */
         /* (OK to pass in NULL for callback context, since we know the header must be in the cache) */
-        if(NULL == (hdr = (H5B2_hdr_t *)H5AC_protect(bt2->f, dxpl_id, H5AC_BT2_HDR, bt2_addr, NULL, H5AC__NO_FLAGS_SET)))
+        if(NULL == (hdr = H5B2__hdr_protect(bt2->f, dxpl_id, bt2_addr, NULL, H5AC__NO_FLAGS_SET)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to protect v2 B-tree header")
 
         /* Set the shared v2 B-tree header's file context for this operation */
@@ -1344,7 +1381,6 @@ H5B2_delete(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *ctx_udata,
     H5B2_remove_t op, void *op_data)
 {
     H5B2_hdr_t	*hdr = NULL;            /* Pointer to the B-tree header */
-    H5B2_hdr_cache_ud_t cache_udata;    /* User-data for callback */
     herr_t	ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
@@ -1357,10 +1393,7 @@ H5B2_delete(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *ctx_udata,
 #ifdef QAK
 HDfprintf(stderr, "%s: addr = %a\n", FUNC, addr);
 #endif /* QAK */
-    cache_udata.f = f;
-    cache_udata.addr = addr;
-    cache_udata.ctx_udata = ctx_udata;
-    if(NULL == (hdr = (H5B2_hdr_t *)H5AC_protect(f, dxpl_id, H5AC_BT2_HDR, addr, &cache_udata, H5AC__NO_FLAGS_SET)))
+    if(NULL == (hdr = H5B2__hdr_protect(f, dxpl_id, addr, ctx_udata, H5AC__NO_FLAGS_SET)))
         HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to protect v2 B-tree header")
 
     /* Remember the callback & context for later */
@@ -1382,7 +1415,7 @@ HDfprintf(stderr, "%s: addr = %a\n", FUNC, addr);
 
 done:
     /* Unprotect the header, if an error occurred */
-    if(hdr && H5AC_unprotect(f, dxpl_id, H5AC_BT2_HDR, addr, hdr, H5AC__NO_FLAGS_SET) < 0)
+    if(hdr && H5B2__hdr_unprotect(hdr, dxpl_id, H5AC__NO_FLAGS_SET) < 0)
         HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release v2 B-tree header")
 
     FUNC_LEAVE_NOAPI(ret_value)
diff --git a/src/H5B2dbg.c b/src/H5B2dbg.c
index ad9f970..ddff9e9 100644
--- a/src/H5B2dbg.c
+++ b/src/H5B2dbg.c
@@ -92,10 +92,8 @@ H5B2__hdr_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE *stream, int indent,
     const H5B2_class_t *type, haddr_t obj_addr)
 {
     H5B2_hdr_t	*hdr = NULL;            /* B-tree header info */
-    void        *dbg_ctx = NULL;	/* v2 B-tree debugging context */
     unsigned    u;                      /* Local index variable */
     char        temp_str[128];          /* Temporary string, for formatting */
-    H5B2_hdr_cache_ud_t cache_udata;    /* User-data for callback */
     herr_t      ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_PACKAGE
@@ -110,23 +108,9 @@ H5B2__hdr_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE *stream, int indent,
     HDassert(indent >= 0);
     HDassert(fwidth >= 0);
     HDassert(type);
-    HDassert((type->crt_dbg_ctx && type->dst_dbg_ctx) ||
-        (NULL == type->crt_dbg_ctx && NULL == type->dst_dbg_ctx));
 
-    /* Check for debugging context callback available */
-    if(type->crt_dbg_ctx) {
-        /* Create debugging context */
-        if(NULL == (dbg_ctx = (type->crt_dbg_ctx)(f, dxpl_id, obj_addr)))
-	    HGOTO_ERROR(H5E_BTREE, H5E_CANTGET, FAIL, "unable to create v2 B-tree debugging context")
-    } /* end if */
-
-    /*
-     * Load the B-tree header.
-     */
-    cache_udata.f = f;
-    cache_udata.addr = addr;
-    cache_udata.ctx_udata = dbg_ctx;
-    if(NULL == (hdr = (H5B2_hdr_t *)H5AC_protect(f, dxpl_id, H5AC_BT2_HDR, addr, &cache_udata, H5AC__READ_ONLY_FLAG)))
+    /* Load the B-tree header  */
+    if(NULL == (hdr = H5B2__hdr_protect(f, dxpl_id, addr, f, H5AC__READ_ONLY_FLAG)))
 	HGOTO_ERROR(H5E_BTREE, H5E_CANTLOAD, FAIL, "unable to load B-tree header")
 
     /* Set file pointer for this B-tree operation */
@@ -178,13 +162,8 @@ H5B2__hdr_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE *stream, int indent,
     } /* end for */
 
 done:
-    if(dbg_ctx && (type->dst_dbg_ctx)(dbg_ctx) < 0)
-        HDONE_ERROR(H5E_BTREE, H5E_CANTRELEASE, FAIL, "unable to release v2 B-tree debugging context")
-    if(hdr) {
-        hdr->f = NULL;
-        if(H5AC_unprotect(f, dxpl_id, H5AC_BT2_HDR, addr, hdr, H5AC__NO_FLAGS_SET) < 0)
-            HDONE_ERROR(H5E_BTREE, H5E_PROTECT, FAIL, "unable to release B-tree header")
-    } /* end if */
+    if(hdr && H5B2__hdr_unprotect(hdr, dxpl_id, H5AC__NO_FLAGS_SET) < 0)
+        HDONE_ERROR(H5E_BTREE, H5E_PROTECT, FAIL, "unable to release v2 B-tree header")
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5B2__hdr_debug() */
@@ -209,10 +188,8 @@ H5B2__int_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE *stream, int indent,
 {
     H5B2_hdr_t	*hdr = NULL;            /* B-tree header */
     H5B2_internal_t	*internal = NULL;   /* B-tree internal node */
-    void        *dbg_ctx = NULL;	/* v2 B-tree debugging context */
     unsigned	u;                      /* Local index variable */
     char        temp_str[128];          /* Temporary string, for formatting */
-    H5B2_hdr_cache_ud_t cache_udata;    /* User-data for callback */
     herr_t      ret_value=SUCCEED;      /* Return value */
 
     FUNC_ENTER_PACKAGE
@@ -226,27 +203,13 @@ H5B2__int_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE *stream, int indent,
     HDassert(indent >= 0);
     HDassert(fwidth >= 0);
     HDassert(type);
-    HDassert((type->crt_dbg_ctx && type->dst_dbg_ctx) ||
-        (NULL == type->crt_dbg_ctx && NULL == type->dst_dbg_ctx));
     HDassert(H5F_addr_defined(hdr_addr));
     HDassert(H5F_addr_defined(obj_addr));
     HDassert(nrec > 0);
 
-    /* Check for debugging context callback available */
-    if(type->crt_dbg_ctx) {
-        /* Create debugging context */
-        if(NULL == (dbg_ctx = (type->crt_dbg_ctx)(f, dxpl_id, obj_addr)))
-	    HGOTO_ERROR(H5E_BTREE, H5E_CANTGET, FAIL, "unable to create v2 B-tree debugging context")
-    } /* end if */
-
-    /*
-     * Load the B-tree header.
-     */
-    cache_udata.f = f;
-    cache_udata.addr = hdr_addr;
-    cache_udata.ctx_udata = dbg_ctx;
-    if(NULL == (hdr = (H5B2_hdr_t *)H5AC_protect(f, dxpl_id, H5AC_BT2_HDR, hdr_addr, &cache_udata, H5AC__READ_ONLY_FLAG)))
-	HGOTO_ERROR(H5E_BTREE, H5E_CANTLOAD, FAIL, "unable to load B-tree header")
+    /* Load the B-tree header */
+    if(NULL == (hdr = H5B2__hdr_protect(f, dxpl_id, hdr_addr, f, H5AC__READ_ONLY_FLAG)))
+	HGOTO_ERROR(H5E_BTREE, H5E_CANTLOAD, FAIL, "unable to load v2 B-tree header")
 
     /* Set file pointer for this B-tree operation */
     hdr->f = f;
@@ -295,7 +258,7 @@ H5B2__int_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE *stream, int indent,
         HDfprintf(stream, "%*s%-*s\n", indent + 3, "", MAX(0, fwidth - 3),
                   temp_str);
         HDassert(H5B2_INT_NREC(internal, hdr, u));
-        (void)(type->debug)(stream, indent + 6, MAX (0, fwidth-6), H5B2_INT_NREC(internal, hdr, u), dbg_ctx);
+        (void)(type->debug)(stream, indent + 6, MAX (0, fwidth-6), H5B2_INT_NREC(internal, hdr, u), hdr->cb_ctx);
     } /* end for */
 
     /* Print final node pointer */
@@ -307,13 +270,8 @@ H5B2__int_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE *stream, int indent,
               internal->node_ptrs[u].addr);
 
 done:
-    if(dbg_ctx && (type->dst_dbg_ctx)(dbg_ctx) < 0)
-        HDONE_ERROR(H5E_BTREE, H5E_CANTRELEASE, FAIL, "unable to release v2 B-tree debugging context")
-    if(hdr) {
-        hdr->f = NULL;
-        if(H5AC_unprotect(f, dxpl_id, H5AC_BT2_HDR, hdr_addr, hdr, H5AC__NO_FLAGS_SET) < 0)
-            HDONE_ERROR(H5E_BTREE, H5E_PROTECT, FAIL, "unable to release B-tree header")
-    } /* end if */
+    if(hdr && H5B2__hdr_unprotect(hdr, dxpl_id, H5AC__NO_FLAGS_SET) < 0)
+        HDONE_ERROR(H5E_BTREE, H5E_PROTECT, FAIL, "unable to release v2 B-tree header")
     if(internal && H5AC_unprotect(f, dxpl_id, H5AC_BT2_INT, addr, internal, H5AC__NO_FLAGS_SET) < 0)
         HDONE_ERROR(H5E_BTREE, H5E_PROTECT, FAIL, "unable to release B-tree internal node")
 
@@ -340,8 +298,6 @@ H5B2__leaf_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE *stream, int indent
 {
     H5B2_hdr_t	*hdr = NULL;            /* B-tree header */
     H5B2_leaf_t	*leaf = NULL;           /* B-tree leaf node */
-    H5B2_hdr_cache_ud_t cache_udata;    /* User-data for callback */
-    void        *dbg_ctx = NULL;	/* v2 B-tree debugging context */
     unsigned	u;                      /* Local index variable */
     char        temp_str[128];          /* Temporary string, for formatting */
     herr_t      ret_value = SUCCEED;    /* Return value */
@@ -357,27 +313,13 @@ H5B2__leaf_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE *stream, int indent
     HDassert(indent >= 0);
     HDassert(fwidth >= 0);
     HDassert(type);
-    HDassert((type->crt_dbg_ctx && type->dst_dbg_ctx) ||
-        (NULL == type->crt_dbg_ctx && NULL == type->dst_dbg_ctx));
     HDassert(H5F_addr_defined(hdr_addr));
     HDassert(H5F_addr_defined(obj_addr));
     HDassert(nrec > 0);
 
-    /* Check for debugging context callback available */
-    if(type->crt_dbg_ctx) {
-        /* Create debugging context */
-        if(NULL == (dbg_ctx = (type->crt_dbg_ctx)(f, dxpl_id, obj_addr)))
-	    HGOTO_ERROR(H5E_BTREE, H5E_CANTGET, FAIL, "unable to create v2 B-tree debugging context")
-    } /* end if */
-
-    /*
-     * Load the B-tree header.
-     */
-    cache_udata.f = f;
-    cache_udata.addr = hdr_addr;
-    cache_udata.ctx_udata = dbg_ctx;
-    if(NULL == (hdr = (H5B2_hdr_t *)H5AC_protect(f, dxpl_id, H5AC_BT2_HDR, hdr_addr, &cache_udata, H5AC__READ_ONLY_FLAG)))
-	HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to protect B-tree header")
+    /* Load the B-tree header */
+    if(NULL == (hdr = H5B2__hdr_protect(f, dxpl_id, hdr_addr, f, H5AC__READ_ONLY_FLAG)))
+	HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to protect v2 B-tree header")
 
     /* Set file pointer for this B-tree operation */
     hdr->f = f;
@@ -417,17 +359,12 @@ H5B2__leaf_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE *stream, int indent
         HDfprintf(stream, "%*s%-*s\n", indent + 3, "", MAX(0, fwidth - 3),
                   temp_str);
         HDassert(H5B2_LEAF_NREC(leaf, hdr, u));
-        (void)(type->debug)(stream, indent + 6, MAX (0, fwidth-6), H5B2_LEAF_NREC(leaf, hdr, u), dbg_ctx);
+        (void)(type->debug)(stream, indent + 6, MAX (0, fwidth-6), H5B2_LEAF_NREC(leaf, hdr, u), hdr->cb_ctx);
     } /* end for */
 
 done:
-    if(dbg_ctx && (type->dst_dbg_ctx)(dbg_ctx) < 0)
-        HDONE_ERROR(H5E_BTREE, H5E_CANTRELEASE, FAIL, "unable to release v2 B-tree debugging context")
-    if(hdr) {
-        hdr->f = NULL;
-        if(H5AC_unprotect(f, dxpl_id, H5AC_BT2_HDR, hdr_addr, hdr, H5AC__NO_FLAGS_SET) < 0)
-            HDONE_ERROR(H5E_BTREE, H5E_PROTECT, FAIL, "unable to release B-tree header")
-    } /* end if */
+    if(hdr && H5B2__hdr_unprotect(hdr, dxpl_id, H5AC__NO_FLAGS_SET) < 0)
+        HDONE_ERROR(H5E_BTREE, H5E_PROTECT, FAIL, "unable to release B-tree header")
     if(leaf && H5AC_unprotect(f, dxpl_id, H5AC_BT2_LEAF, addr, leaf, H5AC__NO_FLAGS_SET) < 0)
         HDONE_ERROR(H5E_BTREE, H5E_PROTECT, FAIL, "unable to release B-tree leaf node")
 
diff --git a/src/H5B2hdr.c b/src/H5B2hdr.c
index 16d8467..ab424b7 100644
--- a/src/H5B2hdr.c
+++ b/src/H5B2hdr.c
@@ -38,7 +38,8 @@
 #include "H5B2pkg.h"		/* v2 B-trees				*/
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5MFprivate.h"	/* File memory management		*/
-#include "H5VMprivate.h"		/* Vectors and arrays 			*/
+#include "H5MMprivate.h"	/* Memory management			*/
+#include "H5VMprivate.h"	/* Vectors and arrays 			*/
 
 /****************/
 /* Local Macros */
@@ -209,10 +210,9 @@ HDmemset(hdr->page, 0, hdr->node_size);
     } /* end if */
 
     /* Create the callback context, if the callback exists */
-    if(hdr->cls->crt_context) {
+    if(hdr->cls->crt_context)
         if(NULL == (hdr->cb_ctx = (*hdr->cls->crt_context)(ctx_udata)))
             HGOTO_ERROR(H5E_BTREE, H5E_CANTCREATE, FAIL, "unable to create v2 B-tree client callback context")
-    } /* end if */
 
 done:
     if(ret_value < 0)
@@ -488,6 +488,82 @@ done:
 
 
 /*-------------------------------------------------------------------------
+ * Function:	H5B2__hdr_protect
+ *
+ * Purpose:	Convenience wrapper around protecting v2 B-tree header
+ *
+ * Return:	Non-NULL pointer to header on success/NULL on failure
+ *
+ * Programmer:	Quincey Koziol
+ *		koziol@hdfgroup.org
+ *		Dec 18 2015
+ *
+ *-------------------------------------------------------------------------
+ */
+H5B2_hdr_t *
+H5B2__hdr_protect(H5F_t *f, hid_t dxpl_id, haddr_t hdr_addr, void *ctx_udata,
+    unsigned flags)
+{
+    H5B2_hdr_cache_ud_t udata;          /* User data for cache callbacks */
+    H5B2_hdr_t *ret_value = NULL;       /* Return value */
+
+    FUNC_ENTER_PACKAGE
+
+    /* Sanity check */
+    HDassert(f);
+    HDassert(H5F_addr_defined(hdr_addr));
+
+    /* only the H5AC__READ_ONLY_FLAG may appear in flags */
+    HDassert((flags & (unsigned)(~H5AC__READ_ONLY_FLAG)) == 0);
+
+    /* Set up user data for cache callbacks */
+    udata.f = f;
+    udata.addr = hdr_addr;
+    udata.ctx_udata = ctx_udata;
+
+    /* Protect the header */
+    if(NULL == (ret_value = (H5B2_hdr_t *)H5AC_protect(f, dxpl_id, H5AC_BT2_HDR, hdr_addr, &udata, flags)))
+        HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, NULL, "unable to load v2 B-tree header, address = %llu", (unsigned long long)hdr_addr)
+    ret_value->f = f;   /* (Must be set again here, in case the header was already in the cache -QAK) */
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5B2__hdr_protect() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5B2__hdr_unprotect
+ *
+ * Purpose:	Convenience wrapper around unprotecting v2 B-tree header
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Quincey Koziol
+ *		koziol@hdfgroup.org
+ *		Dec 18 2015
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5B2__hdr_unprotect(H5B2_hdr_t *hdr, hid_t dxpl_id, unsigned cache_flags)
+{
+    herr_t ret_value = SUCCEED;         /* Return value */
+
+    FUNC_ENTER_PACKAGE
+
+    /* Sanity check */
+    HDassert(hdr);
+
+    /* Unprotect the header */
+    if(H5AC_unprotect(hdr->f, dxpl_id, H5AC_BT2_HDR, hdr->addr, hdr, cache_flags) < 0)
+        HGOTO_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to unprotect v2 B-tree header, address = %llu", (unsigned long long)hdr->addr)
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5B2__hdr_unprotect() */
+
+
+/*-------------------------------------------------------------------------
  * Function:	H5B2__hdr_free
  *
  * Purpose:	Free B-tree header info
@@ -544,14 +620,10 @@ H5B2__hdr_free(H5B2_hdr_t *hdr)
     } /* end if */
 
     /* Release the min & max record info, if set */
-    if(hdr->min_native_rec) {
-	HDfree(hdr->min_native_rec);
-	hdr->min_native_rec = NULL;
-    } /* end if */
-    if(hdr->max_native_rec) {
-	HDfree(hdr->max_native_rec);
-	hdr->max_native_rec = NULL;
-    } /* end if */
+    if(hdr->min_native_rec)
+	hdr->min_native_rec = H5MM_xfree(hdr->min_native_rec);
+    if(hdr->max_native_rec)
+	hdr->max_native_rec = H5MM_xfree(hdr->max_native_rec);
 
     /* Free B-tree header info */
     hdr = H5FL_FREE(H5B2_hdr_t, hdr);
@@ -609,8 +681,8 @@ H5B2__hdr_delete(H5B2_hdr_t *hdr, hid_t dxpl_id)
 
 done:
     /* Unprotect the header with appropriate flags */
-    if(H5AC_unprotect(hdr->f, dxpl_id, H5AC_BT2_HDR, hdr->addr, hdr, cache_flags) < 0)
-        HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release B-tree header")
+    if(H5B2__hdr_unprotect(hdr, dxpl_id, cache_flags) < 0)
+        HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release v2 B-tree header")
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5B2__hdr_delete() */
diff --git a/src/H5B2int.c b/src/H5B2int.c
index b8c9634..a69774a 100644
--- a/src/H5B2int.c
+++ b/src/H5B2int.c
@@ -38,7 +38,8 @@
 #include "H5B2pkg.h"		/* v2 B-trees				*/
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5MFprivate.h"	/* File memory management		*/
-#include "H5VMprivate.h"		/* Vectors and arrays 			*/
+#include "H5MMprivate.h"	/* Memory management			*/
+#include "H5VMprivate.h"	/* Vectors and arrays 			*/
 
 /****************/
 /* Local Macros */
@@ -1513,6 +1514,62 @@ done:
 
 
 /*-------------------------------------------------------------------------
+ * Function:	H5B2__insert_hdr
+ *
+ * Purpose:	Adds a new record to the B-tree.
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Quincey Koziol
+ *		koziol@hdfgroup.org
+ *		Dec 23 2015
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5B2__insert_hdr(H5B2_hdr_t *hdr, hid_t dxpl_id, void *udata)
+{
+    herr_t	ret_value = SUCCEED;    /* Return value */
+
+    FUNC_ENTER_PACKAGE
+
+    /* Check arguments. */
+    HDassert(hdr);
+    HDassert(udata);
+
+    /* Check if the root node is allocated yet */
+    if(!H5F_addr_defined(hdr->root.addr)) {
+        /* Create root node as leaf node in B-tree */
+        if(H5B2__create_leaf(hdr, dxpl_id, &(hdr->root)) < 0)
+	    HGOTO_ERROR(H5E_BTREE, H5E_CANTINIT, FAIL, "unable to create root node")
+    } /* end if */
+    /* Check if we need to split the root node (equiv. to a 1->2 node split) */
+    else if(hdr->root.node_nrec == hdr->node_info[hdr->depth].split_nrec) {
+        /* Split root node */
+        if(H5B2__split_root(hdr, dxpl_id) < 0)
+            HGOTO_ERROR(H5E_BTREE, H5E_CANTSPLIT, FAIL, "unable to split root node")
+    } /* end if */
+
+    /* Attempt to insert record into B-tree */
+    if(hdr->depth > 0) {
+        if(H5B2__insert_internal(hdr, dxpl_id, hdr->depth, NULL, &hdr->root, H5B2_POS_ROOT, udata) < 0)
+            HGOTO_ERROR(H5E_BTREE, H5E_CANTINSERT, FAIL, "unable to insert record into B-tree internal node")
+    } /* end if */
+    else {
+        if(H5B2__insert_leaf(hdr, dxpl_id, &hdr->root, H5B2_POS_ROOT, udata) < 0)
+            HGOTO_ERROR(H5E_BTREE, H5E_CANTINSERT, FAIL, "unable to insert record into B-tree leaf node")
+    } /* end else */
+
+    /* Mark B-tree header as dirty */
+    if(H5B2__hdr_dirty(hdr) < 0)
+        HGOTO_ERROR(H5E_BTREE, H5E_CANTMARKDIRTY, FAIL, "unable to mark B-tree header dirty")
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5B2__insert_hdr() */
+
+
+/*-------------------------------------------------------------------------
  * Function:	H5B2__insert_leaf
  *
  * Purpose:	Adds a new record to a B-tree leaf node.
@@ -1584,7 +1641,7 @@ H5B2__insert_leaf(H5B2_hdr_t *hdr, hid_t dxpl_id, H5B2_node_ptr_t *curr_node_ptr
         if(idx == 0) {
             if(H5B2_POS_LEFT == curr_pos || H5B2_POS_ROOT == curr_pos) {
                 if(hdr->min_native_rec == NULL)
-                    if(NULL == (hdr->min_native_rec = (uint8_t *)HDmalloc(hdr->cls->nrec_size)))
+                    if(NULL == (hdr->min_native_rec = H5MM_malloc(hdr->cls->nrec_size)))
                         HGOTO_ERROR(H5E_BTREE, H5E_CANTALLOC, FAIL, "memory allocation failed for v2 B-tree min record info")
                 HDmemcpy(hdr->min_native_rec, H5B2_LEAF_NREC(leaf, hdr, idx), hdr->cls->nrec_size);
             } /* end if */
@@ -1592,7 +1649,7 @@ H5B2__insert_leaf(H5B2_hdr_t *hdr, hid_t dxpl_id, H5B2_node_ptr_t *curr_node_ptr
         if(idx == (unsigned)(leaf->nrec - 1)) {
             if(H5B2_POS_RIGHT == curr_pos || H5B2_POS_ROOT == curr_pos) {
                 if(hdr->max_native_rec == NULL)
-                    if(NULL == (hdr->max_native_rec = (uint8_t *)HDmalloc(hdr->cls->nrec_size)))
+                    if(NULL == (hdr->max_native_rec = H5MM_malloc(hdr->cls->nrec_size)))
                         HGOTO_ERROR(H5E_BTREE, H5E_CANTALLOC, FAIL, "memory allocation failed for v2 B-tree max record info")
                 HDmemcpy(hdr->max_native_rec, H5B2_LEAF_NREC(leaf, hdr, idx), hdr->cls->nrec_size);
             } /* end if */
@@ -1644,6 +1701,9 @@ H5B2__insert_internal(H5B2_hdr_t *hdr, hid_t dxpl_id, uint16_t depth,
     if(NULL == (internal = H5B2__protect_internal(hdr, dxpl_id, curr_node_ptr->addr, curr_node_ptr->node_nrec, depth, H5AC__NO_FLAGS_SET)))
         HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to protect B-tree internal node")
 
+    /* Sanity check number of records */
+    HDassert(internal->nrec == curr_node_ptr->node_nrec);
+
     /* Split or redistribute child node pointers, if necessary */
     {
         int         cmp;        /* Comparison value of records */
@@ -1755,6 +1815,348 @@ done:
 
 
 /*-------------------------------------------------------------------------
+ * Function:	H5B2__update_leaf
+ *
+ * Purpose:	Insert or modify a record in a B-tree leaf node.
+ *		If the record exists already, it is modified as if H5B2_modify
+ *		was called).  If it doesn't exist, it is inserted as if
+ *		H5B2_insert was called.
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Quincey Koziol
+ *		koziol@hdfgroup.org
+ *		Dec 23 2015
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5B2__update_leaf(H5B2_hdr_t *hdr, hid_t dxpl_id, H5B2_node_ptr_t *curr_node_ptr,
+    H5B2_update_status_t *status, H5B2_nodepos_t curr_pos, void *udata,
+    H5B2_modify_t op, void *op_data)
+{
+    H5B2_leaf_t *leaf;                  /* Pointer to leaf node */
+    unsigned leaf_flags = H5AC__NO_FLAGS_SET;   /* Flags for unprotecting the leaf node */
+    int         cmp = -1;               /* Comparison value of records */
+    unsigned    idx;                    /* Location of record which matches key */
+    herr_t	ret_value = SUCCEED;    /* Return value */
+
+    FUNC_ENTER_PACKAGE
+
+    /* Check arguments. */
+    HDassert(hdr);
+    HDassert(curr_node_ptr);
+    HDassert(H5F_addr_defined(curr_node_ptr->addr));
+
+    /* Lock current B-tree node */
+    if(NULL == (leaf = H5B2__protect_leaf(hdr, dxpl_id, curr_node_ptr->addr, curr_node_ptr->node_nrec, H5AC__NO_FLAGS_SET)))
+        HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to protect B-tree leaf node")
+
+    /* Sanity check number of records */
+    HDassert(curr_node_ptr->all_nrec == curr_node_ptr->node_nrec);
+    HDassert(leaf->nrec == curr_node_ptr->node_nrec);
+
+    /* Check for inserting into empty leaf */
+    if(leaf->nrec == 0)
+        idx = 0;
+    else {
+        /* Find correct location to insert this record */
+        cmp = H5B2__locate_record(hdr->cls, leaf->nrec, hdr->nat_off, leaf->leaf_native, udata, &idx);
+
+        /* Check for inserting a record */
+        if(0 != cmp) {
+            /* Check if the leaf node is full */
+            if(curr_node_ptr->node_nrec == hdr->node_info[0].split_nrec) {
+                /* Indicate that the leaf is full, but we need to insert */
+                *status = H5B2_UPDATE_INSERT_CHILD_FULL;
+
+                /* Let calling routine handle insertion */
+                HGOTO_DONE(SUCCEED)
+            } /* end if */
+
+            /* Adjust index to leave room for record to insert */
+            if(cmp > 0)
+                idx++;
+
+            /* Make room for new record */
+            if(idx < leaf->nrec)
+                HDmemmove(H5B2_LEAF_NREC(leaf, hdr, idx + 1), H5B2_LEAF_NREC(leaf, hdr, idx), hdr->cls->nrec_size * (leaf->nrec - idx));
+        } /* end if */
+    } /* end else */
+
+    /* Check for modifying existing record */
+    if(0 == cmp) {
+        hbool_t changed = FALSE;        /* Whether the 'modify' callback changed the record */
+
+        /* Make callback for current record */
+        if((op)(H5B2_LEAF_NREC(leaf, hdr, idx), op_data, &changed) < 0) {
+            /* Make certain that the callback didn't modify the value if it failed */
+            HDassert(changed == FALSE);
+
+            HGOTO_ERROR(H5E_BTREE, H5E_CANTMODIFY, FAIL, "'modify' callback failed for B-tree update operation")
+        } /* end if */
+
+        /* Mark the node as dirty if it changed */
+        leaf_flags |= (changed ? H5AC__DIRTIED_FLAG : 0);
+
+        /* Indicate that the record was modified */
+        *status = H5B2_UPDATE_MODIFY_DONE;
+    } /* end if */
+    else {
+        /* Must have a leaf node with enough space to insert a record now */
+        HDassert(curr_node_ptr->node_nrec < hdr->node_info[0].max_nrec);
+
+        /* Make callback to store record in native form */
+        if((hdr->cls->store)(H5B2_LEAF_NREC(leaf, hdr, idx), udata) < 0)
+            HGOTO_ERROR(H5E_BTREE, H5E_CANTINSERT, FAIL, "unable to insert record into leaf node")
+
+        /* Mark the node as dirty if it changed */
+        leaf_flags |= H5AC__DIRTIED_FLAG;
+
+        /* Indicate that the record was inserted */
+        *status = H5B2_UPDATE_INSERT_DONE;
+
+        /* Update record count for node pointer to current node */
+        curr_node_ptr->all_nrec++;
+        curr_node_ptr->node_nrec++;
+
+        /* Update record count for current node */
+        leaf->nrec++;
+    } /* end else */
+
+    /* Check for new record being the min or max for the tree */
+    /* (Don't use 'else' for the idx check, to allow for root leaf node) */
+    if(H5B2_POS_MIDDLE != curr_pos) {
+        if(idx == 0) {
+            if(H5B2_POS_LEFT == curr_pos || H5B2_POS_ROOT == curr_pos) {
+                if(hdr->min_native_rec == NULL)
+                    if(NULL == (hdr->min_native_rec = H5MM_malloc(hdr->cls->nrec_size)))
+                        HGOTO_ERROR(H5E_BTREE, H5E_CANTALLOC, FAIL, "memory allocation failed for v2 B-tree min record info")
+                HDmemcpy(hdr->min_native_rec, H5B2_LEAF_NREC(leaf, hdr, idx), hdr->cls->nrec_size);
+            } /* end if */
+        } /* end if */
+        if(idx == (unsigned)(leaf->nrec - 1)) {
+            if(H5B2_POS_RIGHT == curr_pos || H5B2_POS_ROOT == curr_pos) {
+                if(hdr->max_native_rec == NULL)
+                    if(NULL == (hdr->max_native_rec = H5MM_malloc(hdr->cls->nrec_size)))
+                        HGOTO_ERROR(H5E_BTREE, H5E_CANTALLOC, FAIL, "memory allocation failed for v2 B-tree max record info")
+                HDmemcpy(hdr->max_native_rec, H5B2_LEAF_NREC(leaf, hdr, idx), hdr->cls->nrec_size);
+            } /* end if */
+        } /* end if */
+    } /* end if */
+
+done:
+    /* Release the B-tree leaf node */
+    if(leaf && H5AC_unprotect(hdr->f, dxpl_id, H5AC_BT2_LEAF, curr_node_ptr->addr, leaf, leaf_flags) < 0)
+        HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release leaf B-tree node")
+
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5B2__update_leaf() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5B2__update_internal
+ *
+ * Purpose:	Insert or modify a record in a B-tree leaf node.
+ *		If the record exists already, it is modified as if H5B2_modify
+ *		was called).  If it doesn't exist, it is inserted as if
+ *		H5B2_insert was called.
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Quincey Koziol
+ *		koziol@hdfgroup.org
+ *		Dec 24 2015
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5B2__update_internal(H5B2_hdr_t *hdr, hid_t dxpl_id, uint16_t depth,
+    unsigned *parent_cache_info_flags_ptr, H5B2_node_ptr_t *curr_node_ptr,
+    H5B2_update_status_t *status, H5B2_nodepos_t curr_pos, void *udata,
+    H5B2_modify_t op, void *op_data)
+{
+    H5B2_internal_t *internal = NULL;   /* Pointer to internal node */
+    unsigned internal_flags = H5AC__NO_FLAGS_SET;
+    int         cmp;                    /* Comparison value of records */
+    unsigned    idx;                    /* Location of record which matches key */
+    H5B2_nodepos_t next_pos = H5B2_POS_MIDDLE;    /* Position of node */
+    herr_t	ret_value = SUCCEED;    /* Return value */
+
+    FUNC_ENTER_PACKAGE
+
+    /* Check arguments. */
+    HDassert(hdr);
+    HDassert(depth > 0);
+    HDassert(curr_node_ptr);
+    HDassert(H5F_addr_defined(curr_node_ptr->addr));
+
+    /* Lock current B-tree node */
+    if(NULL == (internal = H5B2__protect_internal(hdr, dxpl_id, curr_node_ptr->addr, curr_node_ptr->node_nrec, depth, H5AC__NO_FLAGS_SET)))
+        HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to protect B-tree internal node")
+
+    /* Sanity check number of records */
+    HDassert(internal->nrec == curr_node_ptr->node_nrec);
+
+    /* Locate node pointer for child */
+    cmp = H5B2__locate_record(hdr->cls, internal->nrec, hdr->nat_off, internal->int_native, udata, &idx);
+
+    /* Check for modifying existing record */
+    if(0 == cmp) {
+        hbool_t changed = FALSE;        /* Whether the 'modify' callback changed the record */
+
+        /* Make callback for current record */
+        if((op)(H5B2_INT_NREC(internal, hdr, idx), op_data, &changed) < 0) {
+            /* Make certain that the callback didn't modify the value if it failed */
+            HDassert(changed == FALSE);
+
+            HGOTO_ERROR(H5E_BTREE, H5E_CANTMODIFY, FAIL, "'modify' callback failed for B-tree update operation")
+        } /* end if */
+
+        /* Mark the node as dirty if it changed */
+        internal_flags |= (changed ? H5AC__DIRTIED_FLAG : 0);
+
+        /* Indicate that the record was modified */
+        *status = H5B2_UPDATE_MODIFY_DONE;
+    } /* end if */
+    else {
+        /* Adjust index to leave room for node to insert */
+        if(cmp > 0)
+            idx++;
+
+        /* Check if this node is left/right-most */
+        if(H5B2_POS_MIDDLE != curr_pos) {
+            if(idx == 0) {
+                if(H5B2_POS_LEFT == curr_pos || H5B2_POS_ROOT == curr_pos)
+                    next_pos = H5B2_POS_LEFT;
+            } /* end if */
+            else if(idx == internal->nrec) {
+                if(H5B2_POS_RIGHT == curr_pos || H5B2_POS_ROOT == curr_pos)
+                    next_pos = H5B2_POS_RIGHT;
+            } /* end else */
+        } /* end if */
+
+        /* Attempt to update record in child */
+        if(depth > 1) {
+            if(H5B2__update_internal(hdr, dxpl_id, (uint16_t)(depth - 1), &internal_flags, &internal->node_ptrs[idx], status, next_pos, udata, op, op_data) < 0)
+                HGOTO_ERROR(H5E_BTREE, H5E_CANTUPDATE, FAIL, "unable to update record in internal B-tree node")
+        } /* end if */
+        else {
+            if(H5B2__update_leaf(hdr, dxpl_id, &internal->node_ptrs[idx], status, next_pos, udata, op, op_data) < 0)
+                HGOTO_ERROR(H5E_BTREE, H5E_CANTUPDATE, FAIL, "unable to update record in leaf B-tree node")
+        } /* end else */
+
+        /* Take actions based on child's status report */
+        switch(*status) {
+            case H5B2_UPDATE_MODIFY_DONE:
+                /* No action */
+                break;
+
+            case H5B2_UPDATE_INSERT_DONE:
+                /* Mark node as dirty */
+                internal_flags |= H5AC__DIRTIED_FLAG;
+
+                /* Update total record count for node pointer to current node */
+                curr_node_ptr->all_nrec++;
+                break;
+
+            case H5B2_UPDATE_INSERT_CHILD_FULL:
+                /* Split/redistribute this node */
+                if(internal->nrec == hdr->node_info[depth].split_nrec) {
+                    hbool_t could_split = FALSE;        /* Whether the child node could split */
+
+#ifdef QAK
+HDfprintf(stderr, "%s: idx = %u, internal->nrec = %u\n", FUNC, idx, internal->nrec);
+HDfprintf(stderr, "%s: hdr->node_info[%u].split_nrec = %u\n", FUNC, (unsigned)depth, (unsigned)hdr->node_info[depth].split_nrec);
+HDfprintf(stderr, "%s: hdr->node_info[%u].split_nrec = %u\n", FUNC, (unsigned)(depth - 1), (unsigned)hdr->node_info[depth - 1].split_nrec);
+#endif /* QAK */
+                    if(idx == 0) {      /* Left-most child */
+#ifdef QAK
+HDfprintf(stderr, "%s: Left-most child\n", FUNC);
+HDfprintf(stderr, "%s: internal->node_ptrs[%u].node_nrec = %u\n", FUNC, (unsigned)idx, (unsigned)internal->node_ptrs[idx].node_nrec);
+HDfprintf(stderr, "%s: internal->node_ptrs[%u].node_nrec = %u\n", FUNC, (unsigned)(idx + 1), (unsigned)internal->node_ptrs[idx + 1].node_nrec);
+#endif /* QAK */
+                        /* Check for left-most child and its neighbor being close to full */
+                        if((internal->node_ptrs[idx].node_nrec + internal->node_ptrs[idx + 1].node_nrec)
+                                >= ((hdr->node_info[depth - 1].split_nrec * 2) - 1))
+                            could_split = TRUE;
+                    } /* end if */
+                    else if(idx == internal->nrec) { /* Right-most child */
+#ifdef QAK
+HDfprintf(stderr, "%s: Right-most child\n", FUNC);
+HDfprintf(stderr, "%s: internal->node_ptrs[%u].node_nrec = %u\n", FUNC, (unsigned)(idx - 1), (unsigned)internal->node_ptrs[idx - 1].node_nrec);
+HDfprintf(stderr, "%s: internal->node_ptrs[%u].node_nrec = %u\n", FUNC, (unsigned)idx, (unsigned)internal->node_ptrs[idx].node_nrec);
+#endif /* QAK */
+                        /* Check for right-most child and its neighbor being close to full */
+                        if((internal->node_ptrs[idx - 1].node_nrec + internal->node_ptrs[idx].node_nrec)
+                                >= ((hdr->node_info[depth - 1].split_nrec * 2) - 1))
+                            could_split = TRUE;
+                    } /* end else-if */
+                    else {              /* Middle child */
+#ifdef QAK
+HDfprintf(stderr, "%s: Middle child\n", FUNC);
+HDfprintf(stderr, "%s: internal->node_ptrs[%u].node_nrec = %u\n", FUNC, (unsigned)(idx - 1), (unsigned)internal->node_ptrs[idx - 1].node_nrec);
+HDfprintf(stderr, "%s: internal->node_ptrs[%u].node_nrec = %u\n", FUNC, (unsigned)idx, (unsigned)internal->node_ptrs[idx].node_nrec);
+HDfprintf(stderr, "%s: internal->node_ptrs[%u].node_nrec = %u\n", FUNC, (unsigned)(idx + 1), (unsigned)internal->node_ptrs[idx + 1].node_nrec);
+#endif /* QAK */
+                        /* Check for middle child and its left neighbor being close to full */
+                        if((internal->node_ptrs[idx - 1].node_nrec + internal->node_ptrs[idx].node_nrec)
+                                >= ((hdr->node_info[depth - 1].split_nrec * 2) - 1))
+                            could_split = TRUE;
+                        /* Check for middle child and its right neighbor being close to full */
+                        else if((internal->node_ptrs[idx].node_nrec + internal->node_ptrs[idx + 1].node_nrec)
+                                >= ((hdr->node_info[depth - 1].split_nrec * 2) - 1))
+                            could_split = TRUE;
+                    } /* end if */
+
+                    /* If this node is full and the child node insertion could
+                     *  cause a split, punt back up to caller, leaving the
+                     *  "insert child full" status.
+                     */
+                    if(could_split) {
+                        /* Release the internal B-tree node */
+                        if(H5AC_unprotect(hdr->f, dxpl_id, H5AC_BT2_INT, curr_node_ptr->addr, internal, internal_flags) < 0)
+                            HGOTO_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release internal B-tree node")
+                        internal = NULL;
+
+#ifdef QAK
+HDfprintf(stderr, "%s: Punting back to caller\n", FUNC);
+#endif /* QAK */
+                        /* Punt back to caller */
+                        HGOTO_DONE(SUCCEED);
+                    } /* end if */
+                } /* end if */
+
+                /* Release the internal B-tree node */
+                if(H5AC_unprotect(hdr->f, dxpl_id, H5AC_BT2_INT, curr_node_ptr->addr, internal, internal_flags) < 0)
+                    HGOTO_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release internal B-tree node")
+                internal = NULL;
+
+                /* Indicate that the record was inserted */
+                *status = H5B2_UPDATE_INSERT_DONE;
+
+                /* Dodge sideways into inserting a record into this node */
+                if(H5B2__insert_internal(hdr, dxpl_id, depth, parent_cache_info_flags_ptr, curr_node_ptr, curr_pos, udata) < 0)
+                    HGOTO_ERROR(H5E_BTREE, H5E_CANTINSERT, FAIL, "unable to insert record into internal B-tree node")
+                break;
+
+            case H5B2_UPDATE_UNKNOWN:
+            default:
+                HDassert(0 && "Invalid update status");
+                HGOTO_ERROR(H5E_BTREE, H5E_CANTUPDATE, FAIL, "invalid update status")
+        } /* end switch */
+    } /* end else */
+
+done:
+    /* Release the internal B-tree node */
+    if(internal && H5AC_unprotect(hdr->f, dxpl_id, H5AC_BT2_INT, curr_node_ptr->addr, internal, internal_flags) < 0)
+        HDONE_ERROR(H5E_BTREE, H5E_CANTUNPROTECT, FAIL, "unable to release internal B-tree node")
+
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5B2__update_internal() */
+
+
+/*-------------------------------------------------------------------------
  * Function:	H5B2__create_leaf
  *
  * Purpose:	Creates empty leaf node of a B-tree and update node pointer
@@ -2151,18 +2553,14 @@ H5B2__remove_leaf(H5B2_hdr_t *hdr, hid_t dxpl_id, H5B2_node_ptr_t *curr_node_ptr
         /* (Don't use 'else' for the idx check, to allow for root leaf node) */
         if(idx == 0) {
             if(H5B2_POS_LEFT == curr_pos || H5B2_POS_ROOT == curr_pos) {
-                if(hdr->min_native_rec) {
-                    HDfree(hdr->min_native_rec);
-                    hdr->min_native_rec = NULL;
-                } /* end if */
+                if(hdr->min_native_rec)
+                    hdr->min_native_rec = H5MM_xfree(hdr->min_native_rec);
             } /* end if */
         } /* end if */
         if(idx == (unsigned)(leaf->nrec - 1)) {
             if(H5B2_POS_RIGHT == curr_pos || H5B2_POS_ROOT == curr_pos) {
-                if(hdr->max_native_rec) {
-                    HDfree(hdr->max_native_rec);
-                    hdr->max_native_rec = NULL;
-                } /* end if */
+                if(hdr->max_native_rec)
+                    hdr->max_native_rec = H5MM_xfree(hdr->max_native_rec);
             } /* end if */
         } /* end if */
     } /* end if */
@@ -2466,18 +2864,14 @@ H5B2__remove_leaf_by_idx(H5B2_hdr_t *hdr, hid_t dxpl_id,
         /* (Don't use 'else' for the idx check, to allow for root leaf node) */
         if(idx == 0) {
             if(H5B2_POS_LEFT == curr_pos || H5B2_POS_ROOT == curr_pos) {
-                if(hdr->min_native_rec) {
-                    HDfree(hdr->min_native_rec);
-                    hdr->min_native_rec = NULL;
-                } /* end if */
+                if(hdr->min_native_rec)
+                    hdr->min_native_rec = H5MM_xfree(hdr->min_native_rec);
             } /* end if */
         } /* end if */
         if(idx == (unsigned)(leaf->nrec - 1)) {
             if(H5B2_POS_RIGHT == curr_pos || H5B2_POS_ROOT == curr_pos) {
-                if(hdr->max_native_rec) {
-                    HDfree(hdr->max_native_rec);
-                    hdr->max_native_rec = NULL;
-                } /* end if */
+                if(hdr->max_native_rec)
+                    hdr->max_native_rec = H5MM_xfree(hdr->max_native_rec);
             } /* end if */
         } /* end if */
     } /* end if */
diff --git a/src/H5B2pkg.h b/src/H5B2pkg.h
index d661efa..2b2c145 100644
--- a/src/H5B2pkg.h
+++ b/src/H5B2pkg.h
@@ -182,8 +182,8 @@ typedef struct H5B2_hdr_t {
     uint8_t	*page;	        /* Common disk page for I/O */
     size_t      *nat_off;       /* Array of offsets of native records */
     H5B2_node_info_t *node_info; /* Table of node info structs for current depth of B-tree */
-    uint8_t     *min_native_rec;   /* Pointer to minimum native record                  */
-    uint8_t     *max_native_rec;   /* Pointer to maximum native record                  */
+    void        *min_native_rec; /* Pointer to minimum native record                  */
+    void        *max_native_rec; /* Pointer to maximum native record                  */
 
     /* Client information (not stored) */
     const H5B2_class_t *cls;	/* Class of B-tree client */
@@ -228,6 +228,14 @@ typedef enum H5B2_nodepos_t {
     H5B2_POS_MIDDLE             /* Node is neither right or left-most in tree */
 } H5B2_nodepos_t;
 
+/* Update status */
+typedef enum H5B2_update_status_t {
+    H5B2_UPDATE_UNKNOWN,            /* Unknown update status (initial state) */
+    H5B2_UPDATE_MODIFY_DONE,        /* Update successfully modified existing record */
+    H5B2_UPDATE_INSERT_DONE,        /* Update inserted record successfully */
+    H5B2_UPDATE_INSERT_CHILD_FULL   /* Update will insert record, but child is full */
+} H5B2_update_status_t;
+
 /* Callback info for loading a free space header into the cache */
 typedef struct H5B2_hdr_cache_ud_t {
     H5F_t *f;                   /* File that v2 b-tree header is within */
@@ -252,7 +260,7 @@ typedef struct H5B2_leaf_cache_ud_t {
 
 #ifdef H5B2_TESTING
 /* Node information for testing */
-typedef struct {
+typedef struct H5B2_node_info_test_t {
     unsigned depth;             /* Depth of node */
     unsigned nrec;              /* Number of records in node */
 } H5B2_node_info_test_t;
@@ -281,6 +289,13 @@ H5FL_EXTERN(H5B2_leaf_t);
 /* Internal v2 B-tree testing class */
 #ifdef H5B2_TESTING
 H5_DLLVAR const H5B2_class_t H5B2_TEST[1];
+H5_DLLVAR const H5B2_class_t H5B2_TEST2[1];
+
+/* B-tree record for testing H5B2_TEST2 class */
+typedef struct H5B2_test_rec_t {
+    hsize_t key;        /* Key for record */
+    hsize_t val;        /* Value for record */
+} H5B2_test_rec_t;
 #endif /* H5B2_TESTING */
 
 /* Array of v2 B-tree client ID -> client class mappings */
@@ -302,6 +317,10 @@ H5_DLL herr_t H5B2__hdr_decr(H5B2_hdr_t *hdr);
 H5_DLL herr_t H5B2__hdr_fuse_incr(H5B2_hdr_t *hdr);
 H5_DLL size_t H5B2__hdr_fuse_decr(H5B2_hdr_t *hdr);
 H5_DLL herr_t H5B2__hdr_dirty(H5B2_hdr_t *hdr);
+H5_DLL H5B2_hdr_t *H5B2__hdr_protect(H5F_t *f, hid_t dxpl_id, haddr_t hdr_addr,
+    void *ctx_udata, unsigned flags);
+H5_DLL herr_t H5B2__hdr_unprotect(H5B2_hdr_t *hdr, hid_t dxpl_id,
+    unsigned cache_flags);
 H5_DLL herr_t H5B2__hdr_delete(H5B2_hdr_t *hdr, hid_t dxpl_id);
 
 /* Routines for operating on leaf nodes */
@@ -323,12 +342,22 @@ H5_DLL herr_t H5B2__leaf_free(H5B2_leaf_t *l);
 H5_DLL herr_t H5B2__internal_free(H5B2_internal_t *i);
 
 /* Routines for inserting records */
+H5_DLL herr_t H5B2__insert_hdr(H5B2_hdr_t *hdr, hid_t dxpl_id, void *udata);
 H5_DLL herr_t H5B2__insert_internal(H5B2_hdr_t *hdr, hid_t dxpl_id,
     uint16_t depth, unsigned *parent_cache_info_flags_ptr,
     H5B2_node_ptr_t *curr_node_ptr, H5B2_nodepos_t curr_pos, void *udata);
 H5_DLL herr_t H5B2__insert_leaf(H5B2_hdr_t *hdr, hid_t dxpl_id,
     H5B2_node_ptr_t *curr_node_ptr, H5B2_nodepos_t curr_pos, void *udata);
 
+/* Routines for update records */
+H5_DLL herr_t H5B2__update_internal(H5B2_hdr_t *hdr, hid_t dxpl_id,
+    uint16_t depth, unsigned *parent_cache_info_flags_ptr,
+    H5B2_node_ptr_t *curr_node_ptr, H5B2_update_status_t *status,
+    H5B2_nodepos_t curr_pos, void *udata, H5B2_modify_t op, void *op_data);
+H5_DLL herr_t H5B2__update_leaf(H5B2_hdr_t *hdr, hid_t dxpl_id,
+    H5B2_node_ptr_t *curr_node_ptr, H5B2_update_status_t *status,
+    H5B2_nodepos_t curr_pos, void *udata, H5B2_modify_t op, void *op_data);
+
 /* Routines for iterating over nodes/records */
 H5_DLL herr_t H5B2__iterate_node(H5B2_hdr_t *hdr, hid_t dxpl_id, uint16_t depth,
     const H5B2_node_ptr_t *curr_node, H5B2_operator_t op, void *op_data);
diff --git a/src/H5B2private.h b/src/H5B2private.h
index 9e3c2d7..ff94680 100644
--- a/src/H5B2private.h
+++ b/src/H5B2private.h
@@ -54,6 +54,7 @@ typedef enum H5B2_subid_t {
     H5B2_SOHM_INDEX_ID,         /* B-tree is an index for shared object header messages */
     H5B2_ATTR_DENSE_NAME_ID,    /* B-tree is for indexing 'name' field for "dense" attribute storage on objects */
     H5B2_ATTR_DENSE_CORDER_ID,  /* B-tree is for indexing 'creation order' field for "dense" attribute storage on objects */
+    H5B2_TEST2_ID,		/* Another B-tree is for testing (do not use for actual data) */
     H5B2_NUM_BTREE_ID           /* Number of B-tree IDs (must be last)  */
 } H5B2_subid_t;
 
@@ -94,8 +95,6 @@ struct H5B2_class_t {
     herr_t (*decode)(const uint8_t *raw, void *record, void *ctx);  	/* Decode record from disk storage form to native form */
     herr_t (*debug)(FILE *stream, int indent, int fwidth,    	/* Print a record for debugging */
         const void *record,  const void *ctx);
-    void *(*crt_dbg_ctx)(H5F_t *f, hid_t dxpl_id, haddr_t obj_addr); 	/* Create debugging context */
-    herr_t (*dst_dbg_ctx)(void *dbg_ctx);       /* Destroy debugging context */
 };
 
 /* v2 B-tree creation parameters */
@@ -140,6 +139,8 @@ H5_DLL herr_t H5B2_neighbor(H5B2_t *bt2, hid_t dxpl_id, H5B2_compare_t range,
     void *udata, H5B2_found_t op, void *op_data);
 H5_DLL herr_t H5B2_modify(H5B2_t *bt2, hid_t dxpl_id, void *udata,
     H5B2_modify_t op, void *op_data);
+H5_DLL herr_t H5B2_update(H5B2_t *bt2, hid_t dxpl_id, void *udata,
+    H5B2_modify_t op, void *op_data);
 H5_DLL herr_t H5B2_remove(H5B2_t *b2, hid_t dxpl_id, void *udata,
     H5B2_remove_t op, void *op_data);
 H5_DLL herr_t H5B2_remove_by_idx(H5B2_t *bt2, hid_t dxpl_id,
diff --git a/src/H5B2test.c b/src/H5B2test.c
index 87fddf7..e0c96fb 100644
--- a/src/H5B2test.c
+++ b/src/H5B2test.c
@@ -61,6 +61,7 @@ typedef struct H5B2_test_ctx_t {
 /* Local Prototypes */
 /********************/
 
+/* v2 B-tree driver callbacks for 'test' B-trees */
 static void *H5B2__test_crt_context(void *udata);
 static herr_t H5B2__test_dst_context(void *ctx);
 static herr_t H5B2__test_store(void *nrecord, const void *udata);
@@ -69,13 +70,21 @@ static herr_t H5B2__test_encode(uint8_t *raw, const void *nrecord, void *ctx);
 static herr_t H5B2__test_decode(const uint8_t *raw, void *nrecord, void *ctx);
 static herr_t H5B2__test_debug(FILE *stream, int indent, int fwidth,
     const void *record, const void *_udata);
-static void *H5B2__test_crt_dbg_context(H5F_t *f, hid_t dxpl_id, haddr_t addr);
+
+/* v2 B-tree driver callbacks for 'test2' B-trees */
+static herr_t H5B2__test2_store(void *nrecord, const void *udata);
+static herr_t H5B2__test2_compare(const void *rec1, const void *rec2);
+static herr_t H5B2__test2_encode(uint8_t *raw, const void *nrecord, void *ctx);
+static herr_t H5B2__test2_decode(const uint8_t *raw, void *nrecord, void *ctx);
+static herr_t H5B2__test2_debug(FILE *stream, int indent, int fwidth,
+    const void *record, const void *_udata);
 
 
 /*********************/
 /* Package Variables */
 /*********************/
 
+/* Class structure for testing simple B-tree records */
 const H5B2_class_t H5B2_TEST[1]={{   /* B-tree class information */
     H5B2_TEST_ID,               /* Type of B-tree */
     "H5B2_TEST_ID",             /* Name of B-tree class */
@@ -86,9 +95,21 @@ const H5B2_class_t H5B2_TEST[1]={{   /* B-tree class information */
     H5B2__test_compare,          /* Record comparison callback */
     H5B2__test_encode,           /* Record encoding callback */
     H5B2__test_decode,           /* Record decoding callback */
-    H5B2__test_debug,            /* Record debugging callback */
-    H5B2__test_crt_dbg_context,  /* Create debugging context */
-    H5B2__test_dst_context       /* Destroy debugging context */
+    H5B2__test_debug             /* Record debugging callback */
+}};
+
+/* Class structure for testing key/value B-tree records */
+const H5B2_class_t H5B2_TEST2[1]={{   /* B-tree class information */
+    H5B2_TEST2_ID,               /* Type of B-tree */
+    "H5B2_TEST2_ID",             /* Name of B-tree class */
+    sizeof(H5B2_test_rec_t),     /* Size of native record */
+    H5B2__test_crt_context,      /* Create client callback context */
+    H5B2__test_dst_context,      /* Destroy client callback context */
+    H5B2__test2_store,           /* Record storage callback */
+    H5B2__test2_compare,         /* Record comparison callback */
+    H5B2__test2_encode,          /* Record encoding callback */
+    H5B2__test2_decode,          /* Record decoding callback */
+    H5B2__test2_debug            /* Record debugging callback */
 }};
 
 
@@ -310,42 +331,139 @@ H5B2__test_debug(FILE *stream, int indent, int fwidth, const void *record,
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5B2__test_crt_dbg_context
+ * Function:	H5B2__test2_store
  *
- * Purpose:	Create context for debugging callback
+ * Purpose:	Store native information into record for B-tree
  *
- * Return:	Success:	non-NULL
- *		Failure:	NULL
+ * Return:	Success:	non-negative
+ *		Failure:	negative
  *
  * Programmer:	Quincey Koziol
- *              Tuesday, December 1, 2009
+ *              Friday, December 25, 2015
  *
  *-------------------------------------------------------------------------
  */
-static void *
-H5B2__test_crt_dbg_context(H5F_t *f, hid_t H5_ATTR_UNUSED dxpl_id, haddr_t H5_ATTR_UNUSED addr)
+static herr_t
+H5B2__test2_store(void *nrecord, const void *udata)
 {
-    H5B2_test_ctx_t *ctx;       /* Callback context structure */
-    void *ret_value = NULL;     /* Return value */
+    FUNC_ENTER_STATIC_NOERR
 
-    FUNC_ENTER_STATIC
+    *(H5B2_test_rec_t *)nrecord = *(const H5B2_test_rec_t *)udata;
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* H5B2__test2_store() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5B2__test2_compare
+ *
+ * Purpose:	Compare two native information records, according to some key
+ *
+ * Return:	<0 if rec1 < rec2
+ *              =0 if rec1 == rec2
+ *              >0 if rec1 > rec2
+ *
+ * Programmer:	Quincey Koziol
+ *              Friday, December 25, 2015
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5B2__test2_compare(const void *rec1, const void *rec2)
+{
+    FUNC_ENTER_STATIC_NOERR
+
+    FUNC_LEAVE_NOAPI((herr_t)(((const H5B2_test_rec_t *)rec1)->key - ((const H5B2_test_rec_t *)rec2)->key))
+} /* H5B2__test2_compare() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5B2__test2_encode
+ *
+ * Purpose:	Encode native information into raw form for storing on disk
+ *
+ * Return:	Success:	non-negative
+ *		Failure:	negative
+ *
+ * Programmer:	Quincey Koziol
+ *              Friday, December 25, 2015
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5B2__test2_encode(uint8_t *raw, const void *nrecord, void *_ctx)
+{
+    H5B2_test_ctx_t *ctx = (H5B2_test_ctx_t *)_ctx;       /* Callback context structure */
+
+    FUNC_ENTER_STATIC_NOERR
 
     /* Sanity check */
-    HDassert(f);
+    HDassert(ctx);
 
-    /* Allocate callback context */
-    if(NULL == (ctx = H5FL_MALLOC(H5B2_test_ctx_t)))
-        HGOTO_ERROR(H5E_BTREE, H5E_CANTALLOC, NULL, "can't allocate callback context")
+    H5F_ENCODE_LENGTH_LEN(raw, ((const H5B2_test_rec_t *)nrecord)->key, ctx->sizeof_size);
+    H5F_ENCODE_LENGTH_LEN(raw, ((const H5B2_test_rec_t *)nrecord)->val, ctx->sizeof_size);
 
-    /* Determine the size of addresses & lengths in the file */
-    ctx->sizeof_size = H5F_SIZEOF_SIZE(f);
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* H5B2__test2_encode() */
 
-    /* Set return value */
-    ret_value = ctx;
+
+/*-------------------------------------------------------------------------
+ * Function:	H5B2__test2_decode
+ *
+ * Purpose:	Decode raw disk form of record into native form
+ *
+ * Return:	Success:	non-negative
+ *		Failure:	negative
+ *
+ * Programmer:	Quincey Koziol
+ *              Friday, December 25, 2015
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5B2__test2_decode(const uint8_t *raw, void *nrecord, void *_ctx)
+{
+    H5B2_test_ctx_t *ctx = (H5B2_test_ctx_t *)_ctx;       /* Callback context structure */
 
-done:
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* H5B2__test_crt_dbg_context() */
+    FUNC_ENTER_STATIC_NOERR
+
+    /* Sanity check */
+    HDassert(ctx);
+
+    H5F_DECODE_LENGTH_LEN(raw, ((H5B2_test_rec_t *)nrecord)->key, ctx->sizeof_size);
+    H5F_DECODE_LENGTH_LEN(raw, ((H5B2_test_rec_t *)nrecord)->val, ctx->sizeof_size);
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* H5B2__test2_decode() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5B2__test2_debug
+ *
+ * Purpose:	Debug native form of record
+ *
+ * Return:	Success:	non-negative
+ *		Failure:	negative
+ *
+ * Programmer:	Quincey Koziol
+ *              Friday, December 25, 2015
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5B2__test2_debug(FILE *stream, int indent, int fwidth, const void *record,
+    const void H5_ATTR_UNUSED *_udata)
+{
+    FUNC_ENTER_STATIC_NOERR
+
+    HDassert(record);
+
+    HDfprintf(stream, "%*s%-*s (%Hu, %Hu)\n", indent, "", fwidth, "Record:",
+        ((const H5B2_test_rec_t *)record)->key,
+        ((const H5B2_test_rec_t *)record)->val);
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* H5B2__test2_debug() */
 
 
 /*-------------------------------------------------------------------------
diff --git a/src/H5C.c b/src/H5C.c
index 15ff757..8536ab0 100644
--- a/src/H5C.c
+++ b/src/H5C.c
@@ -6992,7 +6992,7 @@ H5C_flush_invalidate_ring(const H5F_t * f, hid_t dxpl_id, H5C_ring_t ring,
 
                     /* Get cache entry for this node */
                     next_entry_ptr = (H5C_cache_entry_t *)H5SL_item(node_ptr);
-                    if ( NULL == next_entry_ptr )
+                    if(NULL == next_entry_ptr)
                         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "next_entry_ptr == NULL ?!?!")
 
                     HDassert(next_entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
@@ -7430,8 +7430,8 @@ H5C_flush_ring(H5F_t *f, hid_t dxpl_id, H5C_ring_t ring,  unsigned flags)
 
 #if H5C_DO_EXTREME_SANITY_CHECKS
     if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
-            (H5C_validate_pinned_entry_list(cache_ptr) < 0  ||
-            (H5C_validate_lru_list(cache_ptr) < 0)) {
+            (H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_lru_list(cache_ptr) < 0))
         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry.\n");
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
@@ -7794,7 +7794,7 @@ done:
  *
  *		Refactored function to delay all modifications of the 
  *		metadata cache data structures until after any calls 
- *		to the pre-serialize or serialize callbacks.  
+ *		to the pre-serialize or serialize callbacks.
  *
  *		Need to do this, as some pre-serialize or serialize 
  *		calls result in calls to the metadata cache and 
@@ -7862,7 +7862,7 @@ H5C__flush_single_entry(const H5F_t *f, hid_t dxpl_id, H5C_cache_entry_t *entry_
     HDassert(FALSE == entry_ptr->coll_access);
 #endif
 
-    /* we will write the entry to disk if it exists, is dirty, and if the 
+    /* we will write the entry to disk if it exists, is dirty, and if the
      * clear only flag is not set.
      */
     if(entry_ptr->is_dirty && !clear_only)
@@ -8270,7 +8270,7 @@ H5C__flush_single_entry(const H5F_t *f, hid_t dxpl_id, H5C_cache_entry_t *entry_
 
         /* only log a flush if we actually wrote to disk */
         H5C__UPDATE_STATS_FOR_FLUSH(cache_ptr, entry_ptr)
-    }
+    } /* end else if */
 
     if(destroy) {
         if(take_ownership)
@@ -8279,7 +8279,7 @@ H5C__flush_single_entry(const H5F_t *f, hid_t dxpl_id, H5C_cache_entry_t *entry_
             HDassert(destroy_entry);
 
         H5C__UPDATE_STATS_FOR_EVICTION(cache_ptr, entry_ptr, take_ownership)
-    }
+    } /* end if */
 
     /* If the entry's type has a 'notify' callback and the entry is about
      * to be removed from the cache, send a 'before eviction' notice while
@@ -8527,12 +8527,12 @@ H5C_load_entry(H5F_t *             f,
 
     /* verify absence of prohibited or unsupported type flag combinations */
     HDassert(!(type->flags & H5C__CLASS_NO_IO_FLAG));
- 
+
     /* for now, we do not combine the speculative load and compressed flags */
     HDassert(!((type->flags & H5C__CLASS_SPECULATIVE_LOAD_FLAG) &&
                (type->flags & H5C__CLASS_COMPRESSED_FLAG)));
 
-    /* Can't see how skip reads could be usefully combined with 
+    /* Can't see how skip reads could be usefully combined with
      * either the speculative read or compressed flags.  Hence disallow.
      */
     HDassert(!((type->flags & H5C__CLASS_SKIP_READS) &&
@@ -8654,12 +8654,10 @@ H5C_load_entry(H5F_t *             f,
     }
     /* Allocate the buffer for reading the on-disk entry image */
     if(NULL == (image = H5MM_malloc(len + H5C_IMAGE_EXTRA_SPACE)))
-
-        HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, NULL, \
-                    "memory allocation failed for on disk image buffer.")
+        HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, NULL, "memory allocation failed for on disk image buffer.")
 
 #if H5C_DO_MEMORY_SANITY_CHECKS
-    HDmemcpy(((uint8_t *)image) + len, H5C_IMAGE_SANITY_VALUE, H5C_IMAGE_EXTRA_SPACE);
+    HDmemcpy(image + len, H5C_IMAGE_SANITY_VALUE, H5C_IMAGE_EXTRA_SPACE);
 #endif /* H5C_DO_MEMORY_SANITY_CHECKS */
 
 #ifdef H5_HAVE_PARALLEL
@@ -8721,12 +8719,9 @@ H5C_load_entry(H5F_t *             f,
 
         /* Get the actual image size for the thing */
         if(type->image_len(thing, &new_len, &compressed, &compressed_size) < 0)
-
-	    HGOTO_ERROR(H5E_CACHE, H5E_CANTGET, NULL, \
-                        "can't retrieve image length")
+	    HGOTO_ERROR(H5E_CACHE, H5E_CANTGET, NULL, "can't retrieve image length")
 
 	if(new_len == 0)
-
 	    HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, NULL, "image length is 0")
 
         HDassert(((type->flags & H5C__CLASS_COMPRESSED_FLAG) != 0) ||
@@ -8770,15 +8765,13 @@ H5C_load_entry(H5F_t *             f,
                 if(NULL == (new_image = H5MM_realloc(image, 
                                             new_len + H5C_IMAGE_EXTRA_SPACE)))
 
-                    HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, NULL, \
-                               "image null after H5MM_realloc()")
+                    HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, NULL, "image null after H5MM_realloc()")
 
                 image = new_image;
 
 #if H5C_DO_MEMORY_SANITY_CHECKS
 
-                HDmemcpy(((uint8_t *)image) + new_len, 
-                         H5C_IMAGE_SANITY_VALUE, H5C_IMAGE_EXTRA_SPACE);
+                HDmemcpy(((uint8_t *)image) + new_len, H5C_IMAGE_SANITY_VALUE, H5C_IMAGE_EXTRA_SPACE);
 
 #endif /* H5C_DO_MEMORY_SANITY_CHECKS */
 
@@ -8799,8 +8792,7 @@ H5C_load_entry(H5F_t *             f,
 
                     if ( type->free_icr(thing) < 0 )
 
-                        HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, NULL, \
-                                    "free_icr callback failed")
+                        HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, NULL, "free_icr callback failed")
 
 #ifdef H5_HAVE_PARALLEL
                     if(!coll_access || 0 == mpi_rank) {
@@ -8881,7 +8873,7 @@ H5C_load_entry(H5F_t *             f,
      *
      * 	HDassert( ( dirty == FALSE ) || ( type->id == 5 || type->id == 6 ) );
      *
-     * note that type ids 5 & 6 are associated with object headers in the 
+     * note that type ids 5 & 6 are associated with object headers in the
      * metadata cache.
      *
      * When we get to using H5C for other purposes, we may wish to
@@ -9089,8 +9081,8 @@ H5C_make_space_in_cache(H5F_t *	f,
                 ( entry_ptr != NULL )
               )
         {
-            HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
-            HDassert( ! (entry_ptr->is_protected) );
+	    HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
+            HDassert( !(entry_ptr->is_protected) );
             HDassert( ! (entry_ptr->is_read_only) );
             HDassert( (entry_ptr->ro_ref_count) == 0 );
 
@@ -9122,8 +9114,8 @@ H5C_make_space_in_cache(H5F_t *	f,
                      * last_entry_removed_ptr prior to the call to 
                      * H5C__flush_single_entry() so that we can spot 
                      * unexpected removals of entries from the cache,
-                     * and set the restart_scan flag if proceeding 
-                     * would be likely to cause us to scan an entry 
+                     * and set the restart_scan flag if proceeding
+                     * would be likely to cause us to scan an entry
                      * that is no longer in the cache.
                      */
                     cache_ptr->entries_removed_counter = 0;
@@ -9186,15 +9178,15 @@ H5C_make_space_in_cache(H5F_t *	f,
 
 		if ( didnt_flush_entry ) {
 
-		    /* epoch markers don't get flushed, and we don't touch 
+		    /* epoch markers don't get flushed, and we don't touch
                      * entries that are in the process of being flushed.
-                     * Hence no need for sanity checks, as we haven't 
-                     * flushed anything.  Thus just set entry_ptr to prev_ptr 
+                     * Hence no need for sanity checks, as we haven't
+                     * flushed anything.  Thus just set entry_ptr to prev_ptr
                      * and go on.
 		     */
                     entry_ptr = prev_ptr;
 
-		} else if ( ( restart_scan ) 
+		} else if ( ( restart_scan )
                             ||
                             ( prev_ptr->is_dirty != prev_is_dirty )
 		            ||
@@ -9370,10 +9362,8 @@ H5C_validate_lru_list(H5C_t * cache_ptr)
         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Check 1 failed")
     }
 
-    if ( ( cache_ptr->LRU_list_len < 0 ) || ( cache_ptr->LRU_list_size < 0 ) ) {
-
+    if(cache_ptr->LRU_list_len < 0)
         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Check 2 failed")
-    }
 
     if ( ( cache_ptr->LRU_list_len == 1 )
          &&
@@ -9500,10 +9490,8 @@ H5C_validate_pinned_entry_list(H5C_t * cache_ptr)
         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Check 1 failed")
     }
 
-    if ( ( cache_ptr->pel_len < 0 ) || ( cache_ptr->pel_size < 0 ) ) {
-
+    if(cache_ptr->pel_len < 0)
         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Check 2 failed")
-    }
 
     if ( ( cache_ptr->pel_len == 1 )
          &&
@@ -9623,21 +9611,12 @@ H5C_validate_protected_entry_list(H5C_t * cache_ptr)
     HDassert( cache_ptr );
     HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
 
-    if ( ( ( cache_ptr->pl_head_ptr == NULL )
-           ||
-           ( cache_ptr->pl_tail_ptr == NULL )
-         )
-         &&
-         ( cache_ptr->pl_head_ptr != cache_ptr->pl_tail_ptr )
-       ) {
-
+    if(((cache_ptr->pl_head_ptr == NULL) || (cache_ptr->pl_tail_ptr == NULL))
+             && (cache_ptr->pl_head_ptr != cache_ptr->pl_tail_ptr))
         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Check 1 failed")
-    }
-
-    if ( ( cache_ptr->pl_len < 0 ) || ( cache_ptr->pl_size < 0 ) ) {
 
+    if(cache_ptr->pl_len < 0)
         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Check 2 failed")
-    }
 
     if ( ( cache_ptr->pl_len == 1 )
          &&
@@ -9968,7 +9947,7 @@ done:
  * Function:    H5C_ignore_tags
  *
  * Purpose:     Override all assertion frameworks associated with making
- *              sure proper tags are applied to metadata. 
+ *              sure proper tags are applied to cache entries. 
  *
  *              NOTE: This should really only be used in tests that need 
  *              to access internal functions without going through 
@@ -10080,7 +10059,7 @@ done:
  * Return:      FAIL if error is detected, SUCCEED otherwise.
  *
  * Programmer:  Mike McGreevy
- *              November 3, 2009
+ *              August 19, 2010
  *
  *-------------------------------------------------------------------------
  */
@@ -10123,7 +10102,7 @@ done:
  * Return:      FAIL if error is detected, SUCCEED otherwise.
  *
  * Programmer:  Mike McGreevy
- *              November 3, 2009
+ *              September 9, 2010
  *
  *-------------------------------------------------------------------------
  */
@@ -10169,7 +10148,7 @@ H5C_mark_tagged_entries(H5C_t * cache_ptr, haddr_t tag)
  * Return:      FAIL if error is detected, SUCCEED otherwise.
  *
  * Programmer:  Mike McGreevy
- *              November 3, 2009
+ *              November 3, 2010
  *
  *-------------------------------------------------------------------------
  */
diff --git a/src/H5Dbtree.c b/src/H5Dbtree.c
index 30c3a28..85238da 100644
--- a/src/H5Dbtree.c
+++ b/src/H5Dbtree.c
@@ -127,7 +127,7 @@ static herr_t H5D__btree_idx_init(const H5D_chk_idx_info_t *idx_info,
 static herr_t H5D__btree_idx_create(const H5D_chk_idx_info_t *idx_info);
 static hbool_t H5D__btree_idx_is_space_alloc(const H5O_storage_chunk_t *storage);
 static herr_t H5D__btree_idx_insert(const H5D_chk_idx_info_t *idx_info,
-    H5D_chunk_ud_t *udata);
+    H5D_chunk_ud_t *udata, const H5D_t *dset);
 static herr_t H5D__btree_idx_get_addr(const H5D_chk_idx_info_t *idx_info,
     H5D_chunk_ud_t *udata);
 static int H5D__btree_idx_iterate(const H5D_chk_idx_info_t *idx_info,
@@ -218,7 +218,6 @@ H5FL_DEFINE_STATIC(H5O_layout_chunk_t);
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static H5UC_t *
 H5D__btree_get_shared(const H5F_t H5_ATTR_UNUSED *f, const void *_udata)
 {
@@ -439,7 +438,6 @@ H5D__btree_cmp3(void *_lt_key, void *_udata, void *_rt_key)
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static htri_t
 H5D__btree_found(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id, haddr_t addr, const void *_lt_key,
 		 void *_udata)
@@ -539,7 +537,6 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static H5B_ins_t
 H5D__btree_insert(H5F_t *f, hid_t H5_ATTR_UNUSED dxpl_id, haddr_t addr, void *_lt_key,
 		  hbool_t *lt_key_changed,
@@ -633,7 +630,6 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static H5B_ins_t
 H5D__btree_remove(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key /*in,out */ ,
 	hbool_t *lt_key_changed /*out */ ,
@@ -761,7 +757,6 @@ H5D__btree_encode_key(const H5B_shared_t *shared, uint8_t *raw, const void *_key
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5D__btree_debug_key(FILE *stream, int indent, int fwidth, const void *_key,
     const void *_udata)
@@ -991,7 +986,8 @@ H5D__btree_idx_is_space_alloc(const H5O_storage_chunk_t *storage)
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5D__btree_idx_insert(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *udata)
+H5D__btree_idx_insert(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *udata,
+    const H5D_t H5_ATTR_UNUSED *dset)
 {
     herr_t	ret_value = SUCCEED;    /* Return value */
 
@@ -1071,7 +1067,6 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static int
 H5D__btree_idx_iterate_cb(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id,
     const void *_lt_key, haddr_t addr, const void H5_ATTR_UNUSED *_rt_key,
diff --git a/src/H5Dchunk.c b/src/H5Dchunk.c
index e935f93..8194cf4 100644
--- a/src/H5Dchunk.c
+++ b/src/H5Dchunk.c
@@ -73,6 +73,10 @@
 #define H5D_CHUNK_GET_NODE_INFO(map, node)  (map->use_single ? map->single_chunk_info : (H5D_chunk_info_t *)H5SL_item(node))
 #define H5D_CHUNK_GET_NEXT_NODE(map, node)  (map->use_single ? (H5SL_node_t *)NULL : H5SL_next(node))
 
+/* Sanity check on chunk index types: commonly used by a lot of routines in this file */
+#define H5D_CHUNK_STORAGE_INDEX_CHK(storage)                                                    \
+    HDassert((H5D_CHUNK_IDX_BTREE == storage->idx_type && H5D_COPS_BTREE == storage->ops));
+
 /*
  * Feature: If this constant is defined then every cache preemption and load
  *	    causes a character to be printed on the standard error stream:
@@ -104,6 +108,25 @@
 /* Local Typedefs */
 /******************/
 
+/* Raw data chunks are cached.  Each entry in the cache is: */
+typedef struct H5D_rdcc_ent_t {
+    hbool_t	locked;		/*entry is locked in cache		*/
+    hbool_t	dirty;		/*needs to be written to disk?		*/
+    hbool_t     deleted;        /*chunk about to be deleted		*/
+    hsize_t 	scaled[H5O_LAYOUT_NDIMS]; /*scaled chunk 'name' (coordinates) */
+    uint32_t	rd_count;	/*bytes remaining to be read		*/
+    uint32_t	wr_count;	/*bytes remaining to be written		*/
+    H5F_block_t chunk_block;    /*offset/length of chunk in file        */
+    hsize_t     chunk_idx;  	/*index of chunk in dataset             */
+    uint8_t	*chunk;		/*the unfiltered chunk data		*/
+    unsigned	idx;		/*index in hash table			*/
+    struct H5D_rdcc_ent_t *next;/*next item in doubly-linked list	*/
+    struct H5D_rdcc_ent_t *prev;/*previous item in doubly-linked list	*/
+    struct H5D_rdcc_ent_t *tmp_next;/*next item in temporary doubly-linked list */
+    struct H5D_rdcc_ent_t *tmp_prev;/*previous item in temporary doubly-linked list */
+} H5D_rdcc_ent_t;
+typedef H5D_rdcc_ent_t *H5D_rdcc_ent_ptr_t; /* For free lists */
+
 /* Callback info for iteration to prune chunks */
 typedef struct H5D_chunk_it_ud1_t {
     H5D_chunk_common_ud_t common;       /* Common info for B-tree user data (must be first) */
@@ -216,7 +239,7 @@ H5D__nonexistent_readvv(const H5D_io_info_t *io_info,
 
 /* Helper routines */
 static herr_t H5D__chunk_set_info_real(H5O_layout_chunk_t *layout, unsigned ndims,
-    const hsize_t *curr_dims);
+    const hsize_t *curr_dims, const hsize_t *max_dims);
 static void *H5D__chunk_mem_alloc(size_t size, const H5O_pline_t *pline);
 static void *H5D__chunk_mem_xfree(void *chk, const H5O_pline_t *pline);
 static void *H5D__chunk_mem_realloc(void *chk, size_t size,
@@ -241,11 +264,17 @@ static herr_t H5D__chunk_flush_entry(const H5D_t *dset, hid_t dxpl_id,
     const H5D_dxpl_cache_t *dxpl_cache, H5D_rdcc_ent_t *ent, hbool_t reset);
 static herr_t H5D__chunk_cache_evict(const H5D_t *dset, hid_t dxpl_id,
     const H5D_dxpl_cache_t *dxpl_cache, H5D_rdcc_ent_t *ent, hbool_t flush);
+static void *H5D__chunk_lock(const H5D_io_info_t *io_info,
+    H5D_chunk_ud_t *udata, hbool_t relax);
+static herr_t H5D__chunk_unlock(const H5D_io_info_t *io_info,
+    const H5D_chunk_ud_t *udata, hbool_t dirty, void *chunk,
+    uint32_t naccessed);
 static herr_t H5D__chunk_cache_prune(const H5D_t *dset, hid_t dxpl_id,
     const H5D_dxpl_cache_t *dxpl_cache, size_t size);
 static herr_t H5D__chunk_prune_fill(H5D_chunk_it_ud1_t *udata);
 static herr_t H5D__chunk_file_alloc(const H5D_chk_idx_info_t *idx_info,
-    const H5F_block_t *old_chunk, H5F_block_t *new_chunk, hbool_t *need_insert);
+    const H5F_block_t *old_chunk, H5F_block_t *new_chunk, hbool_t *need_insert,
+    hsize_t scaled[]);
 #ifdef H5_HAVE_PARALLEL
 static herr_t H5D__chunk_collective_fill(const H5D_t *dset, hid_t dxpl_id,
     H5D_chunk_coll_info_t *chunk_info, size_t chunk_size, const void *fill_buf);
@@ -378,7 +407,7 @@ H5D__chunk_direct_write(const H5D_t *dset, hid_t dxpl_id, uint32_t filters,
     /* Create the chunk it if it doesn't exist, or reallocate the chunk
      *  if its size changed.
      */
-    if(H5D__chunk_file_alloc(&idx_info, &old_chunk, &udata.chunk_block, &need_insert) < 0)
+    if(H5D__chunk_file_alloc(&idx_info, &old_chunk, &udata.chunk_block, &need_insert, scaled) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "unable to allocate chunk")
 
     /* Make sure the address of the chunk is returned. */
@@ -409,7 +438,7 @@ H5D__chunk_direct_write(const H5D_t *dset, hid_t dxpl_id, uint32_t filters,
         /* Set the chunk's filter mask to the new settings */
         udata.filter_mask = filters;
 
-        if((layout->storage.u.chunk.ops->insert)(&idx_info, &udata) < 0)
+        if((layout->storage.u.chunk.ops->insert)(&idx_info, &udata, NULL) < 0)
             HGOTO_ERROR(H5E_DATASET, H5E_CANTINSERT, FAIL, "unable to insert chunk addr into index")
     } /* end if */
 
@@ -431,7 +460,8 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5D__chunk_set_info_real(H5O_layout_chunk_t *layout, unsigned ndims, const hsize_t *curr_dims)
+H5D__chunk_set_info_real(H5O_layout_chunk_t *layout, unsigned ndims,
+    const hsize_t *curr_dims, const hsize_t *max_dims)
 {
     unsigned u;                 /* Local index variable */
     herr_t ret_value = SUCCEED; /* Return value */
@@ -444,17 +474,21 @@ H5D__chunk_set_info_real(H5O_layout_chunk_t *layout, unsigned ndims, const hsize
     HDassert(curr_dims);
 
     /* Compute the # of chunks in dataset dimensions */
-    for(u = 0, layout->nchunks = 1; u < ndims; u++) {
+    for(u = 0, layout->nchunks = 1, layout->max_nchunks = 1; u < ndims; u++) {
         /* Round up to the next integer # of chunks, to accomodate partial chunks */
 	layout->chunks[u] = ((curr_dims[u] + layout->dim[u]) - 1) / layout->dim[u];
+	layout->max_chunks[u] = ((max_dims[u] + layout->dim[u]) - 1) / layout->dim[u];
 
         /* Accumulate the # of chunks */
 	layout->nchunks *= layout->chunks[u];
+	layout->max_nchunks *= layout->max_chunks[u];
     } /* end for */
 
     /* Get the "down" sizes for each dimension */
     if(H5VM_array_down(ndims, layout->chunks, layout->down_chunks) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't compute 'down' chunk size value")
+    if(H5VM_array_down(ndims, layout->max_chunks, layout->max_down_chunks) < 0)
+	HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't compute 'down' chunk size value")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -484,7 +518,7 @@ H5D__chunk_set_info(const H5D_t *dset)
     HDassert(dset);
 
     /* Set the base layout information */
-    if(H5D__chunk_set_info_real(&dset->shared->layout.u.chunk, dset->shared->ndims, dset->shared->curr_dims) < 0)
+    if(H5D__chunk_set_info_real(&dset->shared->layout.u.chunk, dset->shared->ndims, dset->shared->curr_dims, dset->shared->max_dims) < 0)
 	HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't set layout's chunk info")
 
     /* Call the index's "resize" callback */
@@ -597,6 +631,7 @@ H5D__chunk_init(H5F_t *f, hid_t dxpl_id, const H5D_t *dset, hid_t dapl_id)
     H5D_chk_idx_info_t idx_info;        /* Chunked index info */
     H5D_rdcc_t	*rdcc = &(dset->shared->cache.chunk);   /* Convenience pointer to dataset's chunk cache */
     H5P_genplist_t *dapl;               /* Data access property list object pointer */
+    H5O_storage_chunk_t *sc = &(dset->shared->layout.storage.u.chunk);
     herr_t      ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_STATIC
@@ -604,6 +639,7 @@ H5D__chunk_init(H5F_t *f, hid_t dxpl_id, const H5D_t *dset, hid_t dapl_id)
     /* Sanity check */
     HDassert(f);
     HDassert(dset);
+    H5D_CHUNK_STORAGE_INDEX_CHK(sc);
 
     if(NULL == (dapl = (H5P_genplist_t *)H5I_object(dapl_id)))
         HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "can't find object for fapl ID")
@@ -687,12 +723,14 @@ done:
 hbool_t
 H5D__chunk_is_space_alloc(const H5O_storage_t *storage)
 {
+    const H5O_storage_chunk_t *sc = &(storage->u.chunk);
     hbool_t ret_value = FALSE;          /* Return value */
 
     FUNC_ENTER_PACKAGE_NOERR
 
     /* Sanity checks */
     HDassert(storage);
+    H5D_CHUNK_STORAGE_INDEX_CHK(sc);
 
     /* Query index layer */
     ret_value = (storage->u.chunk.ops->is_space_alloc)(&storage->u.chunk);
@@ -1021,9 +1059,8 @@ H5D__chunk_mem_alloc(size_t size, const H5O_pline_t *pline)
     FUNC_ENTER_STATIC_NOERR
 
     HDassert(size);
-    HDassert(pline);
 
-    if(pline->nused > 0)
+    if(pline && pline->nused)
         ret_value = H5MM_malloc(size);
     else
         ret_value = H5FL_BLK_MALLOC(chunk, size);
@@ -1051,10 +1088,8 @@ H5D__chunk_mem_xfree(void *chk, const H5O_pline_t *pline)
 {
     FUNC_ENTER_STATIC_NOERR
 
-    HDassert(pline);
-
     if(chk) {
-        if(pline->nused > 0)
+        if(pline && pline->nused)
             H5MM_xfree(chk);
         else
             chk = H5FL_BLK_FREE(chunk, chk);
@@ -1344,6 +1379,9 @@ H5D__create_chunk_file_map_hyper(H5D_chunk_map_t *fm, const H5D_io_info_t
 	    HDmemcpy(new_chunk_info->scaled, scaled, sizeof(hsize_t) * fm->f_ndims);
             new_chunk_info->scaled[fm->f_ndims] = 0;
 
+            /* Copy the chunk's scaled coordinates */
+	    HDmemcpy(new_chunk_info->scaled, scaled, sizeof(hsize_t) * fm->f_ndims);
+
             /* Insert the new chunk into the skip list */
             if(H5SL_insert(fm->sel_chunks, new_chunk_info, &new_chunk_info->index) < 0) {
                 H5D__free_chunk_info(new_chunk_info, NULL, NULL);
@@ -1601,6 +1639,7 @@ H5D__chunk_file_cb(void H5_ATTR_UNUSED *elem, const H5T_t H5_ATTR_UNUSED *type,
             /* Set the chunk's scaled coordinates */
             HDmemcpy(chunk_info->scaled, scaled, sizeof(hsize_t) * fm->f_ndims);
             chunk_info->scaled[fm->f_ndims] = 0;
+            HDmemcpy(chunk_info->scaled, scaled, sizeof(hsize_t) * fm->f_ndims);
 
             /* Insert the new chunk into the skip list */
             if(H5SL_insert(fm->sel_chunks,chunk_info,&chunk_info->index) < 0) {
@@ -1649,7 +1688,6 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5D__chunk_mem_cb(void H5_ATTR_UNUSED *elem, const H5T_t H5_ATTR_UNUSED *type, unsigned ndims, const hsize_t *coords, void *_fm)
 {
@@ -1735,6 +1773,7 @@ H5D__chunk_cacheable(const H5D_io_info_t *io_info, haddr_t caddr, hbool_t write_
 
     FUNC_ENTER_PACKAGE
 
+    /* Sanity check */
     HDassert(io_info);
     HDassert(dataset);
 
@@ -1887,6 +1926,9 @@ H5D__chunk_read(H5D_io_info_t *io_info, const H5D_type_info_t *type_info,
             void *chunk = NULL;             /* Pointer to locked chunk buffer */
             htri_t cacheable;               /* Whether the chunk is cacheable */
 
+	    /* Set chunk's [scaled] coordinates */
+	    io_info->store->chunk.scaled = chunk_info->scaled;
+
             /* Determine if we should use the chunk cache */
             if((cacheable = H5D__chunk_cacheable(io_info, udata.chunk_block.offset, FALSE)) < 0)
                 HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't tell if chunk is cacheable")
@@ -1897,9 +1939,6 @@ H5D__chunk_read(H5D_io_info_t *io_info, const H5D_type_info_t *type_info,
                 H5_CHECK_OVERFLOW(type_info->src_type_size, /*From:*/ size_t, /*To:*/ uint32_t);
                 src_accessed_bytes = chunk_info->chunk_points * (uint32_t)type_info->src_type_size;
 
-                /* Set chunk's [scaled] coordinates */
-                io_info->store->chunk.scaled = chunk_info->scaled;
-
                 /* Lock the chunk into the cache */
                 if(NULL == (chunk = H5D__chunk_lock(io_info, &udata, FALSE)))
                     HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "unable to read raw data chunk")
@@ -2013,6 +2052,9 @@ H5D__chunk_write(H5D_io_info_t *io_info, const H5D_type_info_t *type_info,
         HDassert((H5F_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length > 0) || 
                 (!H5F_addr_defined(udata.chunk_block.offset) && udata.chunk_block.length == 0));
 
+	/* Set chunk's [scaled] coordinates */
+	io_info->store->chunk.scaled = chunk_info->scaled;
+
         /* Determine if we should use the chunk cache */
         if((cacheable = H5D__chunk_cacheable(io_info, udata.chunk_block.offset, TRUE)) < 0)
             HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't tell if chunk is cacheable")
@@ -2031,9 +2073,6 @@ H5D__chunk_write(H5D_io_info_t *io_info, const H5D_type_info_t *type_info,
 		    fm->fsel_type == H5S_SEL_POINTS)
                 entire_chunk = FALSE;
 
-            /* Set chunk's [scaled] coordinates */
-            io_info->store->chunk.scaled = chunk_info->scaled;
-
             /* Lock the chunk into the cache */
             if(NULL == (chunk = H5D__chunk_lock(io_info, &udata, entire_chunk)))
                 HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "unable to read raw data chunk")
@@ -2058,7 +2097,7 @@ H5D__chunk_write(H5D_io_info_t *io_info, const H5D_type_info_t *type_info,
                 udata.chunk_block.length = io_info->dset->shared->layout.u.chunk.size;
 
                 /* Allocate the chunk */
-		if(H5D__chunk_file_alloc(&idx_info, NULL, &udata.chunk_block, &need_insert) < 0)
+		if(H5D__chunk_file_alloc(&idx_info, NULL, &udata.chunk_block, &need_insert, chunk_info->scaled) < 0)
 		    HGOTO_ERROR(H5E_DATASET, H5E_CANTINSERT, FAIL, "unable to insert/resize chunk on chunk level")
 
                 /* Make sure the address of the chunk is returned. */
@@ -2091,7 +2130,7 @@ H5D__chunk_write(H5D_io_info_t *io_info, const H5D_type_info_t *type_info,
 	} /* end if */
 	else {
             if(need_insert && io_info->dset->shared->layout.storage.u.chunk.ops->insert)
-                if((io_info->dset->shared->layout.storage.u.chunk.ops->insert)(&idx_info, &udata) < 0)
+                if((io_info->dset->shared->layout.storage.u.chunk.ops->insert)(&idx_info, &udata, NULL) < 0)
                     HGOTO_ERROR(H5E_DATASET, H5E_CANTINSERT, FAIL, "unable to insert chunk addr into index")
 	} /* end else */
 
@@ -2223,12 +2262,14 @@ H5D__chunk_dest(H5D_t *dset, hid_t dxpl_id)
     H5D_rdcc_t	*rdcc = &(dset->shared->cache.chunk);   /* Dataset's chunk cache */
     H5D_rdcc_ent_t	*ent = NULL, *next = NULL;      /* Pointer to current & next cache entries */
     int		nerrors = 0;            /* Accumulated count of errors */
+    H5O_storage_chunk_t *sc = &(dset->shared->layout.storage.u.chunk);
     herr_t      ret_value = SUCCEED;       /* Return value */
 
     FUNC_ENTER_STATIC_TAG(dxpl_id, dset->oloc.addr, FAIL)
 
     /* Sanity checks */
     HDassert(dset);
+    H5D_CHUNK_STORAGE_INDEX_CHK(sc);
 
     /* Fill the DXPL cache values for later use */
     if(H5D__get_dxpl_cache(dxpl_id, &dxpl_cache) < 0)
@@ -2289,6 +2330,7 @@ H5D_chunk_idx_reset(H5O_storage_chunk_t *storage, hbool_t reset_addr)
     /* Sanity checks */
     HDassert(storage);
     HDassert(storage->ops);
+    H5D_CHUNK_STORAGE_INDEX_CHK(storage);
 
     /* Reset index structures */
     if((storage->ops->reset)(storage, reset_addr) < 0)
@@ -2353,6 +2395,7 @@ H5D__chunk_cinfo_cache_update(H5D_chunk_cached_t *last, const H5D_chunk_ud_t *ud
     HDmemcpy(last->scaled, udata->common.scaled, sizeof(hsize_t) * udata->common.layout->ndims);
     last->addr = udata->chunk_block.offset;
     H5_CHECKED_ASSIGN(last->nbytes, uint32_t, udata->chunk_block.length, hsize_t);
+    last->chunk_idx = udata->chunk_idx;
     last->filter_mask = udata->filter_mask;
 
     /* Indicate that the cached info is valid */
@@ -2399,6 +2442,7 @@ H5D__chunk_cinfo_cache_found(const H5D_chunk_cached_t *last, H5D_chunk_ud_t *uda
         /* Retrieve the information from the cache */
         udata->chunk_block.offset = last->addr;
         udata->chunk_block.length = last->nbytes;
+	udata->chunk_idx = last->chunk_idx;
         udata->filter_mask = last->filter_mask;
 
         /* Indicate that the data was found */
@@ -2429,6 +2473,7 @@ herr_t
 H5D__chunk_create(const H5D_t *dset /*in,out*/, hid_t dxpl_id)
 {
     H5D_chk_idx_info_t idx_info;        /* Chunked index info */
+    H5O_storage_chunk_t *sc = &(dset->shared->layout.storage.u.chunk);
     herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_PACKAGE
@@ -2437,6 +2482,8 @@ H5D__chunk_create(const H5D_t *dset /*in,out*/, hid_t dxpl_id)
     HDassert(dset);
     HDassert(H5D_CHUNKED == dset->shared->layout.type);
     HDassert(dset->shared->layout.u.chunk.ndims > 0 && dset->shared->layout.u.chunk.ndims <= H5O_LAYOUT_NDIMS);
+    H5D_CHUNK_STORAGE_INDEX_CHK(sc);
+
 #ifndef NDEBUG
 {
     unsigned u;                         /* Local index variable */
@@ -2527,21 +2574,24 @@ H5D__chunk_lookup(const H5D_t *dset, hid_t dxpl_id, const hsize_t *scaled,
     H5D_chunk_ud_t *udata)
 {
     H5D_rdcc_ent_t  *ent = NULL;        /* Cache entry */
-    hbool_t         found = FALSE;      /* In cache? */
-    unsigned        u;                  /* Counter */
-    herr_t	ret_value = SUCCEED;	/* Return value */
+    H5O_storage_chunk_t *sc = &(dset->shared->layout.storage.u.chunk);
+    unsigned idx;                       /* Index of chunk in cache, if present */
+    hbool_t found = FALSE;              /* In cache? */
+    herr_t ret_value = SUCCEED;	        /* Return value */
 
     FUNC_ENTER_PACKAGE
 
+    /* Sanity checks */
     HDassert(dset);
     HDassert(dset->shared->layout.u.chunk.ndims > 0);
+    H5D_CHUNK_STORAGE_INDEX_CHK(sc);
     HDassert(scaled);
     HDassert(udata);
 
     /* Initialize the query information about the chunk we are looking for */
     udata->common.layout = &(dset->shared->layout.u.chunk);
     udata->common.storage = &(dset->shared->layout.storage.u.chunk);
-    udata->common.scaled =  scaled;
+    udata->common.scaled = scaled;
 
     /* Reset information about the chunk we are looking for */
     udata->chunk_block.offset = HADDR_UNDEF;
@@ -2550,21 +2600,32 @@ H5D__chunk_lookup(const H5D_t *dset, hid_t dxpl_id, const hsize_t *scaled,
 
     /* Check for chunk in cache */
     if(dset->shared->cache.chunk.nslots > 0) {
-	udata->idx_hint = H5D__chunk_hash_val(dset->shared, scaled);
-        ent = dset->shared->cache.chunk.slot[udata->idx_hint];
+        /* Determine the chunk's location in the hash table */
+	idx = H5D__chunk_hash_val(dset->shared, scaled);
 
-        if(ent)
-            for(u = 0, found = TRUE; u < dset->shared->ndims; u++)
+        /* Get the chunk cache entry for that location */
+        ent = dset->shared->cache.chunk.slot[idx];
+        if(ent) {
+            unsigned u;                  /* Counter */
+
+            /* Speculatively set the 'found' flag */
+            found = TRUE;
+
+            /* Verify that the cache entry is the correct chunk */
+            for(u = 0; u < dset->shared->ndims; u++)
                 if(scaled[u] != ent->scaled[u]) {
                     found = FALSE;
                     break;
                 } /* end if */
+        } /* end if */
     } /* end if */
 
-    /* Find chunk addr */
+    /* Retrieve chunk addr */
     if(found) {
+        udata->idx_hint = idx;
         udata->chunk_block.offset = ent->chunk_block.offset;
         udata->chunk_block.length = ent->chunk_block.length;;
+	udata->chunk_idx = ent->chunk_idx;
     } /* end if */
     else {
         /* Invalidate idx_hint, to signal that the chunk is not in cache */
@@ -2636,12 +2697,14 @@ H5D__chunk_flush_entry(const H5D_t *dset, hid_t dxpl_id, const H5D_dxpl_cache_t
 {
     void	*buf = NULL;	        /* Temporary buffer		*/
     hbool_t	point_of_no_return = FALSE;
+    H5O_storage_chunk_t *sc = &(dset->shared->layout.storage.u.chunk);
     herr_t	ret_value = SUCCEED;	/* Return value			*/
 
     FUNC_ENTER_STATIC_TAG(dxpl_id, dset->oloc.addr, FAIL)
 
     HDassert(dset);
     HDassert(dset->shared);
+    H5D_CHUNK_STORAGE_INDEX_CHK(sc);
     HDassert(dxpl_cache);
     HDassert(ent);
     HDassert(!ent->locked);
@@ -2660,6 +2723,7 @@ H5D__chunk_flush_entry(const H5D_t *dset, hid_t dxpl_id, const H5D_dxpl_cache_t
         udata.chunk_block.offset = ent->chunk_block.offset;
         udata.chunk_block.length = dset->shared->layout.u.chunk.size;
         udata.filter_mask = 0;
+	udata.chunk_idx = ent->chunk_idx;
 
         /* Should the chunk be filtered before writing it to disk? */
         if(dset->shared->dcpl_cache.pline.nused) {
@@ -2719,7 +2783,7 @@ H5D__chunk_flush_entry(const H5D_t *dset, hid_t dxpl_id, const H5D_dxpl_cache_t
             /* Create the chunk it if it doesn't exist, or reallocate the chunk
              *  if its size changed.
              */
-	    if(H5D__chunk_file_alloc(&idx_info, &(ent->chunk_block), &udata.chunk_block, &need_insert) < 0)
+	    if(H5D__chunk_file_alloc(&idx_info, &(ent->chunk_block), &udata.chunk_block, &need_insert, ent->scaled) < 0)
 		HGOTO_ERROR(H5E_DATASET, H5E_CANTINSERT, FAIL, "unable to insert/resize chunk on chunk level")
 
             /* Update the chunk entry's info, in case it was allocated or relocated */
@@ -2735,7 +2799,7 @@ H5D__chunk_flush_entry(const H5D_t *dset, hid_t dxpl_id, const H5D_dxpl_cache_t
 
         /* Insert the chunk record into the index */
 	if(need_insert && dset->shared->layout.storage.u.chunk.ops->insert)
-            if((dset->shared->layout.storage.u.chunk.ops->insert)(&idx_info, &udata) < 0)
+            if((dset->shared->layout.storage.u.chunk.ops->insert)(&idx_info, &udata, dset) < 0)
                 HGOTO_ERROR(H5E_DATASET, H5E_CANTINSERT, FAIL, "unable to insert chunk addr into index")
 
         /* Cache the chunk's info, in case it's accessed again shortly */
@@ -2826,8 +2890,19 @@ H5D__chunk_cache_evict(const H5D_t *dset, hid_t dxpl_id, const H5D_dxpl_cache_t
 	rdcc->tail = ent->prev;
     ent->prev = ent->next = NULL;
 
-    /* Only clear hash table slot if chunk was not marked as deleted already */
-    if(!ent->deleted)
+    /* Unlink from temporary list */
+    if(ent->tmp_prev) {
+        HDassert(rdcc->tmp_head->tmp_next);
+        ent->tmp_prev->tmp_next = ent->tmp_next;
+        if(ent->tmp_next) {
+            ent->tmp_next->tmp_prev = ent->tmp_prev;
+            ent->tmp_next = NULL;
+        } /* end if */
+        ent->tmp_prev = NULL;
+    } /* end if */
+    else
+        /* Only clear hash table slot if the chunk was not on the temporary list
+         */
         rdcc->slot[ent->idx] = NULL;
 
     /* Remove from cache */
@@ -2978,7 +3053,7 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-void *
+static void *
 H5D__chunk_lock(const H5D_io_info_t *io_info, H5D_chunk_ud_t *udata,
     hbool_t relax)
 {
@@ -2994,7 +3069,7 @@ H5D__chunk_lock(const H5D_io_info_t *io_info, H5D_chunk_ud_t *udata,
     void		*chunk = NULL;		/*the file chunk	*/
     void		*ret_value = NULL;	/* Return value         */
 
-    FUNC_ENTER_PACKAGE
+    FUNC_ENTER_STATIC
 
     HDassert(io_info);
     HDassert(io_info->dxpl_cache);
@@ -3002,6 +3077,7 @@ H5D__chunk_lock(const H5D_io_info_t *io_info, H5D_chunk_ud_t *udata,
     HDassert(udata);
     HDassert(dset);
     HDassert(TRUE == H5P_isa_class(io_info->dxpl_id, H5P_DATASET_XFER));
+    HDassert(!rdcc->tmp_head);
 
     /* Get the chunk's size */
     HDassert(layout->u.chunk.size > 0);
@@ -3021,7 +3097,7 @@ H5D__chunk_lock(const H5D_io_info_t *io_info, H5D_chunk_ud_t *udata,
         unsigned		u;			/*counters		*/
 
         /* Make sure this is the right chunk */
-        for(u = 0; u < layout->u.chunk.ndims; u++)
+        for(u = 0; u < layout->u.chunk.ndims - 1; u++)
             HDassert(io_info->store->chunk.scaled[u] == ent->scaled[u]);
 }
 #endif /* NDEBUG */
@@ -3169,6 +3245,7 @@ H5D__chunk_lock(const H5D_io_info_t *io_info, H5D_chunk_ud_t *udata,
                 /* Initialize the new entry */
                 ent->chunk_block.offset = chunk_addr;
                 ent->chunk_block.length = chunk_alloc;
+		ent->chunk_idx = udata->chunk_idx;
                 HDmemcpy(ent->scaled, udata->common.scaled, sizeof(hsize_t) * layout->u.chunk.ndims);
                 H5_CHECKED_ASSIGN(ent->rd_count, uint32_t, chunk_size, size_t);
                 H5_CHECKED_ASSIGN(ent->wr_count, uint32_t, chunk_size, size_t);
@@ -3189,6 +3266,9 @@ H5D__chunk_lock(const H5D_io_info_t *io_info, H5D_chunk_ud_t *udata,
                 } /* end if */
                 else
                     rdcc->head = rdcc->tail = ent;
+		ent->tmp_next = NULL;
+		ent->tmp_prev = NULL;
+
             } /* end if */
             else
                 /* We did not add the chunk to cache */
@@ -3251,7 +3331,7 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-herr_t
+static herr_t
 H5D__chunk_unlock(const H5D_io_info_t *io_info, const H5D_chunk_ud_t *udata,
     hbool_t dirty, void *chunk, uint32_t naccessed)
 {
@@ -3259,8 +3339,9 @@ H5D__chunk_unlock(const H5D_io_info_t *io_info, const H5D_chunk_ud_t *udata,
     const H5D_rdcc_t	*rdcc = &(io_info->dset->shared->cache.chunk);
     herr_t              ret_value = SUCCEED;      /* Return value */
 
-    FUNC_ENTER_PACKAGE
+    FUNC_ENTER_STATIC
 
+    /* Sanity check */
     HDassert(io_info);
     HDassert(udata);
 
@@ -3268,8 +3349,6 @@ H5D__chunk_unlock(const H5D_io_info_t *io_info, const H5D_chunk_ud_t *udata,
         /*
          * It's not in the cache, probably because it's too big.  If it's
          * dirty then flush it to disk.  In any case, free the chunk.
-         * Note: we have to copy the layout and filter messages so we
-         *	 don't discard the `const' qualifier.
          */
         if(dirty) {
             H5D_rdcc_ent_t fake_ent;         /* "fake" chunk cache entry */
@@ -3277,7 +3356,9 @@ H5D__chunk_unlock(const H5D_io_info_t *io_info, const H5D_chunk_ud_t *udata,
             HDmemset(&fake_ent, 0, sizeof(fake_ent));
             fake_ent.dirty = TRUE;
 	    HDmemcpy(fake_ent.scaled, udata->common.scaled, sizeof(hsize_t) * layout->u.chunk.ndims);
+	    HDmemcpy(fake_ent.scaled, udata->common.scaled, sizeof(hsize_t) * layout->u.chunk.ndims);
             HDassert(layout->u.chunk.size > 0);
+	    fake_ent.chunk_idx = udata->chunk_idx;
             fake_ent.chunk_block.offset = udata->chunk_block.offset;
             fake_ent.chunk_block.length = udata->chunk_block.length;
             fake_ent.chunk = (uint8_t *)chunk;
@@ -3330,7 +3411,6 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static int
 H5D__chunk_allocated_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
 {
@@ -3367,12 +3447,14 @@ H5D__chunk_allocated(H5D_t *dset, hid_t dxpl_id, hsize_t *nbytes)
     H5D_dxpl_cache_t _dxpl_cache;       /* Data transfer property cache buffer */
     H5D_dxpl_cache_t *dxpl_cache = &_dxpl_cache;   /* Data transfer property cache */
     hsize_t chunk_bytes = 0;            /* Number of bytes allocated for chunks */
+    H5O_storage_chunk_t *sc = &(dset->shared->layout.storage.u.chunk);
     herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_PACKAGE
 
     HDassert(dset);
     HDassert(dset->shared);
+    H5D_CHUNK_STORAGE_INDEX_CHK(sc);
 
     /* Fill the DXPL cache values for later use */
     if(H5D__get_dxpl_cache(dxpl_id, &dxpl_cache) < 0)
@@ -3449,6 +3531,7 @@ H5D__chunk_allocate(const H5D_t *dset, hid_t dxpl_id, hbool_t full_overwrite,
     unsigned    op_dim;                 /* Current operating dimension */
     H5D_fill_buf_info_t fb_info;        /* Dataset's fill buffer info */
     hbool_t     fb_info_init = FALSE;   /* Whether the fill value buffer has been initialized */
+    const H5O_storage_chunk_t *sc = &(layout->storage.u.chunk);
     herr_t	ret_value = SUCCEED;	/* Return value */
 
     FUNC_ENTER_PACKAGE_TAG(dxpl_id, dset->oloc.addr, FAIL)
@@ -3456,6 +3539,7 @@ H5D__chunk_allocate(const H5D_t *dset, hid_t dxpl_id, hbool_t full_overwrite,
     /* Check args */
     HDassert(dset && H5D_CHUNKED == layout->type);
     HDassert(layout->u.chunk.ndims > 0 && layout->u.chunk.ndims <= H5O_LAYOUT_NDIMS);
+    H5D_CHUNK_STORAGE_INDEX_CHK(sc);
     HDassert(TRUE == H5P_isa_class(dxpl_id, H5P_DATASET_XFER));
 
     /* Retrieve the dataset dimensions */
@@ -3575,6 +3659,7 @@ H5D__chunk_allocate(const H5D_t *dset, hid_t dxpl_id, hbool_t full_overwrite,
      * Note that min_unalloc & max_unalloc are in scaled coordinates.
      *
      */
+    chunk_size = orig_chunk_size;
     for(op_dim = 0; op_dim < space_ndims; op_dim++) {
         H5D_chunk_ud_t udata;   /* User data for querying chunk info */
         int i;                  /* Local index variable */
@@ -3593,18 +3678,11 @@ H5D__chunk_allocate(const H5D_t *dset, hid_t dxpl_id, hbool_t full_overwrite,
         while(!carry) {
             hbool_t need_insert = FALSE;    /* Whether the chunk needs to be inserted into the index */
 
-            /* Reset size of chunk in bytes, in case filtered size changes */
-            chunk_size = orig_chunk_size;
-
+	    /* Look up this chunk */
+	    if(H5D__chunk_lookup(dset, dxpl_id, scaled, &udata) < 0)
+		HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "error looking up chunk address")
 #ifndef NDEBUG
             /* None of the chunks should be allocated */
-            {
-                /* Look up this chunk */
-                if(H5D__chunk_lookup(dset, dxpl_id, scaled, &udata) < 0)
-                    HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "error looking up chunk address")
-
-                HDassert(!H5F_addr_defined(udata.chunk_block.offset));
-            } /* end block */
 
             /* Make sure the chunk is really in the dataset and outside the
              * original dimensions */
@@ -3659,6 +3737,8 @@ H5D__chunk_allocate(const H5D_t *dset, hid_t dxpl_id, hbool_t full_overwrite,
                     /* Keep the number of bytes the chunk turned in to */
                     chunk_size = nbytes;
                 } /* end if */
+                else
+                    chunk_size = layout->u.chunk.size;
             } /* end if */
 
             /* Initialize the chunk information */
@@ -3670,7 +3750,7 @@ H5D__chunk_allocate(const H5D_t *dset, hid_t dxpl_id, hbool_t full_overwrite,
             udata.filter_mask = filter_mask;
 
             /* Allocate the chunk (with all processes) */
-	    if(H5D__chunk_file_alloc(&idx_info, NULL, &udata.chunk_block, &need_insert) < 0)
+	    if(H5D__chunk_file_alloc(&idx_info, NULL, &udata.chunk_block, &need_insert, scaled) < 0)
 		HGOTO_ERROR(H5E_DATASET, H5E_CANTINSERT, FAIL, "unable to insert/resize chunk on chunk level")
             HDassert(H5F_addr_defined(udata.chunk_block.offset));
 
@@ -3687,7 +3767,7 @@ H5D__chunk_allocate(const H5D_t *dset, hid_t dxpl_id, hbool_t full_overwrite,
                        write collectively at the end */
                     /* allocate/resize address array if no more space left */
                     if(0 == chunk_info.num_io % 1024)
-                        if(NULL == (chunk_info.addr = (haddr_t *)HDrealloc(chunk_info.addr, (chunk_info.num_io + 1024) * sizeof(haddr_t))))
+                        if(NULL == (chunk_info.addr = (haddr_t *)H5MM_realloc(chunk_info.addr, (chunk_info.num_io + 1024) * sizeof(haddr_t))))
                             HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "memory allocation failed for chunk addresses")
 
                     /* Store the chunk's address for later */
@@ -3707,11 +3787,8 @@ H5D__chunk_allocate(const H5D_t *dset, hid_t dxpl_id, hbool_t full_overwrite,
             } /* end if */
 
             /* Insert the chunk record into the index */
-            /* (Note that this isn't safe, from a SWMR perspective, unlike
-             *  serial operation. -QAK
-             */
 	    if(need_insert && ops->insert)
-                if((ops->insert)(&idx_info, &udata) < 0)
+                if((ops->insert)(&idx_info, &udata, dset) < 0)
                     HGOTO_ERROR(H5E_DATASET, H5E_CANTINSERT, FAIL, "unable to insert chunk addr into index")
 
             /* Increment indices and adjust the edge chunk state */
@@ -3757,7 +3834,7 @@ done:
 
 #ifdef H5_HAVE_PARALLEL
     if(using_mpi && chunk_info.addr)
-        HDfree(chunk_info.addr);
+        H5MM_free(chunk_info.addr);
 #endif
 
     FUNC_LEAVE_NOAPI_TAG(ret_value, FAIL)
@@ -4165,6 +4242,7 @@ H5D__chunk_prune_by_extent(H5D_t *dset, hid_t dxpl_id, const hsize_t *old_dim)
     hsize_t                 hyper_start[H5O_LAYOUT_NDIMS];  /* Starting location of hyperslab */
     uint32_t                elmts_per_chunk;    /* Elements in chunk */
     unsigned                u;	                /* Local index variable */
+    const H5O_storage_chunk_t *sc = &(layout->storage.u.chunk);
     herr_t                  ret_value = SUCCEED;       /* Return value */
 
     FUNC_ENTER_PACKAGE
@@ -4172,6 +4250,7 @@ H5D__chunk_prune_by_extent(H5D_t *dset, hid_t dxpl_id, const hsize_t *old_dim)
     /* Check args */
     HDassert(dset && H5D_CHUNKED == layout->type);
     HDassert(layout->u.chunk.ndims > 0 && layout->u.chunk.ndims <= H5O_LAYOUT_NDIMS);
+    H5D_CHUNK_STORAGE_INDEX_CHK(sc);
     HDassert(dxpl_cache);
 
     /* Fill the DXPL cache values for later use */
@@ -4310,6 +4389,8 @@ H5D__chunk_prune_by_extent(H5D_t *dset, hid_t dxpl_id, const hsize_t *old_dim)
         while(!carry) {
             int i;	                        /* Local index variable */
 
+            udata.common.scaled = scaled;
+
             if(0 == ndims_outside_fill) {
                 HDassert(fill_dim[op_dim]);
                 HDassert(scaled[op_dim] == min_mod_chunk_sc[op_dim]);
@@ -4348,7 +4429,7 @@ H5D__chunk_prune_by_extent(H5D_t *dset, hid_t dxpl_id, const hsize_t *old_dim)
                 /* Remove the chunk from disk, if present */
                 if(H5F_addr_defined(chk_udata.chunk_block.offset)) {
                     /* Update the offset in idx_udata */
-		    idx_udata.scaled = scaled;
+		    idx_udata.scaled = udata.common.scaled;
 
                     /* Remove the chunk from disk */
                     if((layout->storage.u.chunk.ops->remove)(&idx_info, &idx_udata) < 0)
@@ -4470,12 +4551,14 @@ H5D__chunk_addrmap(const H5D_io_info_t *io_info, haddr_t chunk_addr[])
     H5D_chk_idx_info_t idx_info;        /* Chunked index info */
     const H5D_t *dset = io_info->dset;  /* Local pointer to dataset info */
     H5D_chunk_it_ud2_t udata;          	/* User data for iteration callback */
+    H5O_storage_chunk_t *sc = &(dset->shared->layout.storage.u.chunk);
     herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_PACKAGE
 
     HDassert(dset);
     HDassert(dset->shared);
+    H5D_CHUNK_STORAGE_INDEX_CHK(sc);
     HDassert(chunk_addr);
 
     /* Set up user data for B-tree callback */
@@ -4523,6 +4606,7 @@ H5D__chunk_delete(H5F_t *f, hid_t dxpl_id, H5O_t *oh, H5O_storage_t *storage)
     H5O_pline_t pline;                  /* I/O pipeline message */
     hbool_t pline_read = FALSE;         /* Whether the I/O pipeline message was read from the file */
     htri_t	exists;                 /* Flag if header message of interest exists */
+    H5O_storage_chunk_t *sc = &(storage->u.chunk);
     herr_t      ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_PACKAGE
@@ -4531,6 +4615,7 @@ H5D__chunk_delete(H5F_t *f, hid_t dxpl_id, H5O_t *oh, H5O_storage_t *storage)
     HDassert(f);
     HDassert(oh);
     HDassert(storage);
+    H5D_CHUNK_STORAGE_INDEX_CHK(sc);
 
     /* Check for I/O pipeline message */
     if((exists = H5O_msg_exists_oh(oh, H5O_PLINE_ID)) < 0)
@@ -4597,6 +4682,8 @@ H5D__chunk_update_cache(H5D_t *dset, hid_t dxpl_id)
 {
     H5D_rdcc_t         *rdcc = &(dset->shared->cache.chunk);	/*raw data chunk cache */
     H5D_rdcc_ent_t     *ent, *next;	/*cache entry  */
+    H5D_rdcc_ent_t     tmp_head;        /* Sentinel entry for temporary entry list */
+    H5D_rdcc_ent_t     *tmp_tail;       /* Tail pointer for temporary entry list */
     H5D_dxpl_cache_t _dxpl_cache;       /* Data transfer property cache buffer */
     H5D_dxpl_cache_t *dxpl_cache = &_dxpl_cache;   /* Data transfer property cache */
     herr_t              ret_value = SUCCEED;      /* Return value */
@@ -4614,6 +4701,11 @@ H5D__chunk_update_cache(H5D_t *dset, hid_t dxpl_id)
     if(H5D__get_dxpl_cache(dxpl_id, &dxpl_cache) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't fill dxpl cache")
 
+    /* Add temporary entry list to rdcc */
+    (void)HDmemset(&tmp_head, 0, sizeof(tmp_head));
+    rdcc->tmp_head = &tmp_head;
+    tmp_tail = &tmp_head;
+
     /* Recompute the index for each cached chunk that is in a dataset */
     for(ent = rdcc->head; ent; ent = next) {
         unsigned	    old_idx;	/* Previous index number	*/
@@ -4634,37 +4726,58 @@ H5D__chunk_update_cache(H5D_t *dset, hid_t dxpl_id)
                 HDassert(old_ent->locked == FALSE);
                 HDassert(old_ent->deleted == FALSE);
 
-                /* Mark the old entry as deleted, but do not evict (yet).
-                 * Make sure we do not make any calls to the index
+                /* Insert the old entry into the temporary list, but do not
+                 * evict (yet).  Make sure we do not make any calls to the index
                  * until all chunks have updated indices! */
-                old_ent->deleted = TRUE;
+                HDassert(!old_ent->tmp_next);
+                HDassert(!old_ent->tmp_prev);
+                tmp_tail->tmp_next = old_ent;
+                old_ent->tmp_prev = tmp_tail;
+                tmp_tail = old_ent;
             } /* end if */
 
             /* Insert this chunk into correct location in hash table */
             rdcc->slot[ent->idx] = ent;
 
-            /* If this chunk was previously marked as deleted and therefore
-             * not in the hash table, reset the deleted flag.
+            /* If this chunk was previously on the temporary list and therefore
+             * not in the hash table, remove it from the temporary list.
              * Otherwise clear the old hash table slot. */
-            if(ent->deleted)
-                ent->deleted = FALSE;
+            if(ent->tmp_prev) {
+                HDassert(tmp_head.tmp_next);
+                HDassert(tmp_tail != &tmp_head);
+                ent->tmp_prev->tmp_next = ent->tmp_next;
+                if(ent->tmp_next) {
+                    ent->tmp_next->tmp_prev = ent->tmp_prev;
+                    ent->tmp_next = NULL;
+                } /* end if */
+                else {
+                    HDassert(tmp_tail == ent);
+                    tmp_tail = ent->tmp_prev;
+                } /* end else */
+                ent->tmp_prev = NULL;
+            } /* end if */
             else
                 rdcc->slot[old_idx] = NULL;
         } /* end if */
     } /* end for */
 
-    /* Evict chunks that are still marked as deleted */
-    for(ent = rdcc->head; ent; ent = next) {
-        /* Get the pointer to the next cache entry */
-        next = ent->next;
+    /* tmp_tail is no longer needed, and will be invalidated by
+     * H5D_chunk_cache_evict anyways. */
+    tmp_tail = NULL;
+
+    /* Evict chunks that are still on the temporary list */
+    while(tmp_head.tmp_next) {
+        ent = tmp_head.tmp_next;
 
         /* Remove the old entry from the cache */
-        if(ent->deleted)
-            if(H5D__chunk_cache_evict(dset, dxpl_id, dxpl_cache, ent, TRUE) < 0)
-                HGOTO_ERROR(H5E_IO, H5E_CANTFLUSH, FAIL, "unable to flush one or more raw data chunks")
-    } /* end for */
+        if(H5D__chunk_cache_evict(dset, dxpl_id, dxpl_cache, ent, TRUE) < 0)
+            HGOTO_ERROR(H5E_IO, H5E_CANTFLUSH, FAIL, "unable to flush one or more raw data chunks")
+    } /* end while */
 
 done:
+    /* Remove temporary list from rdcc */
+    rdcc->tmp_head = NULL;
+
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5D__chunk_update_cache() */
 
@@ -4829,8 +4942,11 @@ H5D__chunk_copy_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
 	udata->buf_size = buf_size;
     } /* end if */
 
+    udata_dst.chunk_idx = H5VM_array_offset_pre(udata_dst.common.layout->ndims - 1, 
+			    udata_dst.common.layout->down_chunks, udata_dst.common.scaled);
+
     /* Allocate chunk in the file */
-    if(H5D__chunk_file_alloc(udata->idx_info_dst, NULL, &udata_dst.chunk_block, &need_insert) < 0)
+    if(H5D__chunk_file_alloc(udata->idx_info_dst, NULL, &udata_dst.chunk_block, &need_insert, udata_dst.common.scaled) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTINSERT, FAIL, "unable to insert/resize chunk on chunk level")
 
     /* Write chunk data to destination file */
@@ -4843,7 +4959,7 @@ H5D__chunk_copy_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
 
     /* Insert chunk record into index */
     if(need_insert && udata->idx_info_dst->storage->ops->insert)
-        if((udata->idx_info_dst->storage->ops->insert)(udata->idx_info_dst, &udata_dst) < 0)
+        if((udata->idx_info_dst->storage->ops->insert)(udata->idx_info_dst, &udata_dst, NULL) < 0)
             HGOTO_ERROR_TAG(H5E_DATASET, H5E_CANTINSERT, H5_ITER_ERROR, "unable to insert chunk addr into index")
 
     /* Reset metadata tag in dxpl_id */
@@ -4876,6 +4992,9 @@ H5D__chunk_copy(H5F_t *f_src, H5O_storage_chunk_t *storage_src,
     H5D_chunk_it_ud3_t udata;           /* User data for iteration callback */
     H5D_chk_idx_info_t idx_info_dst;    /* Dest. chunked index info */
     H5D_chk_idx_info_t idx_info_src;    /* Source chunked index info */
+    int         sndims;                 /* Rank of dataspace */
+    hsize_t     curr_dims[H5O_LAYOUT_NDIMS]; /* Curr. size of dataset dimensions */
+    hsize_t     max_dims[H5O_LAYOUT_NDIMS]; /* Curr. size of dataset dimensions */
     H5O_pline_t _pline;                 /* Temporary pipeline info */
     const H5O_pline_t *pline;           /* Pointer to pipeline info to use */
     H5T_path_t  *tpath_src_mem = NULL, *tpath_mem_dst = NULL;   /* Datatype conversion paths */
@@ -4899,9 +5018,11 @@ H5D__chunk_copy(H5F_t *f_src, H5O_storage_chunk_t *storage_src,
     /* Check args */
     HDassert(f_src);
     HDassert(storage_src);
+    H5D_CHUNK_STORAGE_INDEX_CHK(storage_src);
     HDassert(layout_src);
     HDassert(f_dst);
     HDassert(storage_dst);
+    H5D_CHUNK_STORAGE_INDEX_CHK(storage_dst);
     HDassert(ds_extent_src);
     HDassert(dt_src);
 
@@ -4919,17 +5040,15 @@ H5D__chunk_copy(H5F_t *f_src, H5O_storage_chunk_t *storage_src,
 
     /* Initialize layout information */
     {
-        hsize_t     curr_dims[H5O_LAYOUT_NDIMS];    /* Curr. size of dataset dimensions */
-        int         sndims;                 /* Rank of dataspace */
         unsigned    ndims;                  /* Rank of dataspace */
 
         /* Get the dim info for dataset */
-        if((sndims = H5S_extent_get_dims(ds_extent_src, curr_dims, NULL)) < 0)
+        if((sndims = H5S_extent_get_dims(ds_extent_src, curr_dims, max_dims)) < 0)
             HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get dataspace dimensions")
         H5_CHECKED_ASSIGN(ndims, unsigned, sndims, int);
 
         /* Set the source layout chunk information */
-        if(H5D__chunk_set_info_real(layout_src, ndims, curr_dims) < 0)
+        if(H5D__chunk_set_info_real(layout_src, ndims, curr_dims, max_dims) < 0)
             HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't set layout's chunk info")
     } /* end block */
 
@@ -5131,6 +5250,7 @@ H5D__chunk_bh_info(const H5O_loc_t *loc, hid_t dxpl_id, H5O_t *oh, H5O_layout_t
     H5D_chk_idx_info_t idx_info;        /* Chunked index info */
     H5S_t *space = NULL;                /* Dataset's dataspace */
     H5O_pline_t pline;                  /* I/O pipeline message */
+    H5O_storage_chunk_t *sc = &(layout->storage.u.chunk);
     htri_t exists;                      /* Flag if header message of interest exists */
     hbool_t idx_info_init = FALSE;      /* Whether the chunk index info has been initialized */
     hbool_t pline_read = FALSE;         /* Whether the I/O pipeline message was read */
@@ -5143,6 +5263,7 @@ H5D__chunk_bh_info(const H5O_loc_t *loc, hid_t dxpl_id, H5O_t *oh, H5O_layout_t
     HDassert(loc->file);
     HDassert(H5F_addr_defined(loc->addr));
     HDassert(layout);
+    H5D_CHUNK_STORAGE_INDEX_CHK(sc);
     HDassert(index_size);
 
     /* Check for I/O pipeline message */
@@ -5205,7 +5326,6 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static int
 H5D__chunk_dump_index_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
 {
@@ -5253,12 +5373,14 @@ H5D__chunk_dump_index_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
 herr_t
 H5D__chunk_dump_index(H5D_t *dset, hid_t dxpl_id, FILE *stream)
 {
+    H5O_storage_chunk_t *sc = &(dset->shared->layout.storage.u.chunk);
     herr_t ret_value = SUCCEED;       /* Return value */
 
     FUNC_ENTER_PACKAGE
 
     /* Sanity check */
     HDassert(dset);
+    H5D_CHUNK_STORAGE_INDEX_CHK(sc);
 
     /* Only display info if stream is defined */
     if(stream) {
@@ -5476,7 +5598,7 @@ done:
  */
 static herr_t
 H5D__chunk_file_alloc(const H5D_chk_idx_info_t *idx_info, const H5F_block_t *old_chunk,
-    H5F_block_t *new_chunk, hbool_t *need_insert)
+    H5F_block_t *new_chunk, hbool_t *need_insert, hsize_t scaled[])
 {
     hbool_t alloc_chunk = FALSE;	/* Whether to allocate chunk */
     herr_t ret_value = SUCCEED;   	/* Return value         */
diff --git a/src/H5Dcompact.c b/src/H5Dcompact.c
index ebe75bd..df2a740 100644
--- a/src/H5Dcompact.c
+++ b/src/H5Dcompact.c
@@ -440,12 +440,9 @@ H5D__compact_copy(H5F_t *f_src, H5O_storage_compact_t *storage_src, H5F_t *f_dst
     HDassert(storage_src);
     HDassert(f_dst);
     HDassert(storage_dst);
+    HDassert(storage_dst->buf);
     HDassert(dt_src);
 
-    /* Allocate space for destination data */
-    if(NULL == (storage_dst->buf = H5MM_malloc(storage_src->size)))
-        HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "unable to allocate memory for compact dataset")
-
     /* Create datatype ID for src datatype, so it gets freed */
     if((tid_src = H5I_register(H5I_DATATYPE, dt_src, FALSE)) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTREGISTER, FAIL, "unable to register source file datatype")
diff --git a/src/H5Dcontig.c b/src/H5Dcontig.c
index 988bb61..b5b9b0d 100644
--- a/src/H5Dcontig.c
+++ b/src/H5Dcontig.c
@@ -390,7 +390,6 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5D__contig_construct(H5F_t *f, H5D_t *dset)
 {
diff --git a/src/H5Dint.c b/src/H5Dint.c
index b9899c8..ab2f8d0 100644
--- a/src/H5Dint.c
+++ b/src/H5Dint.c
@@ -718,6 +718,7 @@ static herr_t
 H5D__cache_dataspace_info(const H5D_t *dset)
 {
     int sndims;                         /* Signed number of dimensions of dataspace rank */
+    unsigned u;                         /* Local index value */
     herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_STATIC
@@ -730,6 +731,10 @@ H5D__cache_dataspace_info(const H5D_t *dset)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't cache dataspace dimensions")
     dset->shared->ndims = (unsigned)sndims;
 
+    /* Compute the inital 'power2up' values */
+    for(u = 0; u < dset->shared->ndims; u++)
+        dset->shared->curr_power2up[u] = H5VM_power2up(dset->shared->curr_dims[u]);
+
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5D__cache_dataspace_info() */
@@ -1847,7 +1852,7 @@ H5D__alloc_storage(const H5D_t *dset, hid_t dxpl_id, H5D_time_alloc_t time_alloc
 
             case H5D_CHUNKED:
                 if(!(*dset->shared->layout.ops->is_space_alloc)(&dset->shared->layout.storage)) {
-                    /* Create the root of the B-tree that describes chunked storage */
+                    /* Create the root of the index that manages chunked storage */
                     if(H5D__chunk_create(dset /*in,out*/, dxpl_id) < 0)
                         HGOTO_ERROR(H5E_IO, H5E_CANTINIT, FAIL, "unable to initialize chunked storage")
 
@@ -1860,7 +1865,7 @@ H5D__alloc_storage(const H5D_t *dset, hid_t dxpl_id, H5D_time_alloc_t time_alloc
 
                 /* If space allocation is set to 'early' and we are extending
 		 * the dataset, indicate that space should be allocated, so the
-                 * B-tree gets expanded. -QAK
+                 * index gets expanded. -QAK
                  */
 		if(dset->shared->dcpl_cache.fill.alloc_time == H5D_ALLOC_TIME_EARLY
                         && time_alloc == H5D_ALLOC_EXTEND)
@@ -1911,7 +1916,7 @@ H5D__alloc_storage(const H5D_t *dset, hid_t dxpl_id, H5D_time_alloc_t time_alloc
         /* Check if we need to initialize the space */
         if(must_init_space) {
             if(layout->type == H5D_CHUNKED) {
-                /* If we are doing incremental allocation and the B-tree got
+                /* If we are doing incremental allocation and the index got
                  * created during a H5Dwrite call, don't initialize the storage
                  * now, wait for the actual writes to each block and let the
                  * low-level chunking routines handle initialize the fill-values.
@@ -1934,10 +1939,9 @@ H5D__alloc_storage(const H5D_t *dset, hid_t dxpl_id, H5D_time_alloc_t time_alloc
                 /* If we are filling the dataset on allocation or "if set" and
                  * the fill value _is_ set, do that now */
                 if(dset->shared->dcpl_cache.fill.fill_time == H5D_FILL_TIME_ALLOC ||
-                        (dset->shared->dcpl_cache.fill.fill_time == H5D_FILL_TIME_IFSET && fill_status == H5D_FILL_VALUE_USER_DEFINED)) {
+                        (dset->shared->dcpl_cache.fill.fill_time == H5D_FILL_TIME_IFSET && fill_status == H5D_FILL_VALUE_USER_DEFINED))
                     if(H5D__init_storage(dset, full_overwrite, old_dim, dxpl_id) < 0)
                         HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to initialize dataset with fill value")
-                } /* end if */
             } /* end else */
         } /* end if */
 
@@ -2253,7 +2257,6 @@ H5D__vlen_get_buf_size_alloc(size_t size, void *info)
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 herr_t
 H5D__vlen_get_buf_size(void H5_ATTR_UNUSED *elem, hid_t type_id, unsigned H5_ATTR_UNUSED ndim, const hsize_t *point, void *op_data)
 {
@@ -2623,7 +2626,7 @@ H5D__mark(const H5D_t *dataset, hid_t H5_ATTR_UNUSED dxpl_id, unsigned flags)
         /* Update the layout on disk, if it's been changed */
         if(flags & H5D_MARK_LAYOUT) {
             if(H5D__layout_oh_write(dataset, dxpl_id, oh, update_flags) < 0)
-                HGOTO_ERROR(H5E_DATASET, H5E_WRITEERROR, FAIL, "unable to update layout/pline/efl info")
+                HGOTO_ERROR(H5E_DATASET, H5E_WRITEERROR, FAIL, "unable to update layout info")
 
             /* Reset the "update the modification time" flag, so we only do it once */
             update_flags = 0;
diff --git a/src/H5Dlayout.c b/src/H5Dlayout.c
index 8676d7c..16ff81b 100644
--- a/src/H5Dlayout.c
+++ b/src/H5Dlayout.c
@@ -150,6 +150,7 @@ H5D__layout_meta_size(const H5F_t *f, const H5O_layout_t *layout, hbool_t includ
 
     switch(layout->type) {
         case H5D_COMPACT:
+            /* This information only present in older versions of message */
             /* Size of raw data */
             ret_value += 2;
             if(include_compact_data)
@@ -157,6 +158,7 @@ H5D__layout_meta_size(const H5F_t *f, const H5O_layout_t *layout, hbool_t includ
             break;
 
         case H5D_CONTIGUOUS:
+            /* This information only present in older versions of message */
             ret_value += H5F_SIZEOF_ADDR(f);    /* Address of data */
             ret_value += H5F_SIZEOF_SIZE(f);    /* Length of data */
             break;
@@ -206,7 +208,7 @@ herr_t
 H5D__layout_oh_create(H5F_t *file, hid_t dxpl_id, H5O_t *oh, H5D_t *dset,
     hid_t dapl_id)
 {
-    H5O_layout_t        *layout;         /* Dataset's layout information */
+    H5O_layout_t        *layout;        /* Dataset's layout information */
     const H5O_fill_t	*fill_prop;     /* Pointer to dataset's fill value information */
     hbool_t             layout_init = FALSE;    /* Flag to indicate that chunk information was initialized */
     herr_t ret_value = SUCCEED;         /* Return value */
@@ -401,7 +403,7 @@ done:
 /*-------------------------------------------------------------------------
  * Function:	H5D__layout_oh_write
  *
- * Purpose:	Write layout/pline/efl information for dataset
+ * Purpose:	Write layout information for dataset
  *
  * Return:	Success:    SUCCEED
  *		Failure:    FAIL
diff --git a/src/H5Dmpio.c b/src/H5Dmpio.c
index a5f34d1..0ba340a 100644
--- a/src/H5Dmpio.c
+++ b/src/H5Dmpio.c
@@ -1680,7 +1680,6 @@ H5D__obtain_mpio_mode(H5D_io_info_t* io_info, H5D_chunk_map_t *fm,
     MPI_Comm          comm;
     int               ic, root;
     int               mpi_code;
-    hbool_t           mem_cleanup      = FALSE;
 #ifdef H5_HAVE_INSTRUMENTED_LIBRARY
     int new_value;
     htri_t check_prop;
@@ -1715,12 +1714,14 @@ H5D__obtain_mpio_mode(H5D_io_info_t* io_info, H5D_chunk_map_t *fm,
     threshold_nproc_per_chunk = mpi_size * percent_nproc_per_chunk/100;
 
     /* Allocate memory */
-    io_mode_info      = (uint8_t *)H5MM_calloc(total_chunks);
-    mergebuf          = H5MM_malloc((sizeof(haddr_t) + 1) * total_chunks);
+    if(NULL == (io_mode_info = (uint8_t *)H5MM_calloc(total_chunks)))
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "couldn't allocate I/O mode info buffer")
+    if(NULL == (mergebuf = H5MM_malloc((sizeof(haddr_t) + 1) * total_chunks)))
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "couldn't allocate mergebuf buffer")
     tempbuf           = mergebuf + total_chunks;
     if(mpi_rank == root)
-        recv_io_mode_info = (uint8_t *)H5MM_malloc(total_chunks * mpi_size);
-    mem_cleanup       = TRUE;
+        if(NULL == (recv_io_mode_info = (uint8_t *)H5MM_malloc(total_chunks * mpi_size)))
+            HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "couldn't allocate recv I/O mode info buffer")
 
     /* Obtain the regularity and selection information for all chunks in this process. */
     chunk_node        = H5SL_first(fm->sel_chunks);
@@ -1742,11 +1743,12 @@ H5D__obtain_mpio_mode(H5D_io_info_t* io_info, H5D_chunk_map_t *fm,
 
         /* pre-computing: calculate number of processes and
             regularity of the selection occupied in each chunk */
-        nproc_per_chunk = (int*)H5MM_calloc(total_chunks * sizeof(int));
+        if(NULL == (nproc_per_chunk = (int*)H5MM_calloc(total_chunks * sizeof(int))))
+            HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "couldn't allocate nproc_per_chunk buffer")
 
         /* calculating the chunk address */
         if(H5D__chunk_addrmap(io_info, chunk_addr) < 0) {
-            HDfree(nproc_per_chunk);
+            H5MM_free(nproc_per_chunk);
             HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get chunk address")
         } /* end if */
 
@@ -1774,7 +1776,7 @@ H5D__obtain_mpio_mode(H5D_io_info_t* io_info, H5D_chunk_map_t *fm,
         HDmemcpy(mergebuf, assign_io_mode, total_chunks);
         HDmemcpy(tempbuf, chunk_addr, sizeof(haddr_t) * total_chunks);
 
-        HDfree(nproc_per_chunk);
+        H5MM_free(nproc_per_chunk);
     } /* end if */
 
     /* Broadcasting the MPI_IO option info. and chunk address info. */
@@ -1824,11 +1826,13 @@ H5D__obtain_mpio_mode(H5D_io_info_t* io_info, H5D_chunk_map_t *fm,
 #endif
 
 done:
-    if(mem_cleanup) {
-        HDfree(io_mode_info);
-        HDfree(mergebuf);
-        if(mpi_rank == root)
-            HDfree(recv_io_mode_info);
+    if(io_mode_info)
+        H5MM_free(io_mode_info);
+    if(mergebuf)
+        H5MM_free(mergebuf);
+    if(recv_io_mode_info) {
+        HDassert(mpi_rank == root);
+        H5MM_free(recv_io_mode_info);
     } /* end if */
 
     FUNC_LEAVE_NOAPI(ret_value)
diff --git a/src/H5Dpkg.h b/src/H5Dpkg.h
index f391e8c..97fc442 100644
--- a/src/H5Dpkg.h
+++ b/src/H5Dpkg.h
@@ -240,7 +240,7 @@ typedef struct H5D_chk_idx_info_t {
 typedef struct H5D_chunk_rec_t {
     hsize_t	scaled[H5O_LAYOUT_NDIMS];	/* Logical offset to start */
     uint32_t	nbytes;				/* Size of stored data	*/
-    unsigned	filter_mask;			/* Excluded filters	*/
+    uint32_t	filter_mask;			/* Excluded filters	*/
     haddr_t     chunk_addr;                     /* Address of chunk in file */
 } H5D_chunk_rec_t;
 
@@ -250,7 +250,6 @@ typedef struct H5D_chunk_rec_t {
  * to which the index points.
  */
 typedef struct H5D_chunk_common_ud_t {
-    /* downward */
     const H5O_layout_chunk_t *layout;           /* Chunk layout description */
     const H5O_storage_chunk_t *storage;         /* Chunk storage description */
     const hsize_t *scaled;		        /* Scaled coordinates for a chunk */
@@ -258,12 +257,14 @@ typedef struct H5D_chunk_common_ud_t {
 
 /* B-tree callback info for various operations */
 typedef struct H5D_chunk_ud_t {
+    /* Downward */
     H5D_chunk_common_ud_t common;       /* Common info for B-tree user data (must be first) */
 
     /* Upward */
-    unsigned    idx_hint;               /*index of chunk in cache, if present */
-    H5F_block_t chunk_block;            /*offset/length of chunk in file */
-    unsigned	filter_mask;		/*excluded filters	*/
+    unsigned    idx_hint;               /* Index of chunk in cache, if present */
+    H5F_block_t chunk_block;            /* Offset/length of chunk in file */
+    unsigned	filter_mask;		/* Excluded filters	*/
+    hsize_t     chunk_idx;              /* Chunk index for EA, FA indexing */
 } H5D_chunk_ud_t;
 
 /* Typedef for "generic" chunk callbacks */
@@ -276,7 +277,7 @@ typedef herr_t (*H5D_chunk_init_func_t)(const H5D_chk_idx_info_t *idx_info,
 typedef herr_t (*H5D_chunk_create_func_t)(const H5D_chk_idx_info_t *idx_info);
 typedef hbool_t (*H5D_chunk_is_space_alloc_func_t)(const H5O_storage_chunk_t *storage);
 typedef herr_t (*H5D_chunk_insert_func_t)(const H5D_chk_idx_info_t *idx_info,
-    H5D_chunk_ud_t *udata);
+    H5D_chunk_ud_t *udata, const H5D_t *dset);
 typedef herr_t (*H5D_chunk_get_addr_func_t)(const H5D_chk_idx_info_t *idx_info,
     H5D_chunk_ud_t *udata);
 typedef herr_t (*H5D_chunk_resize_func_t)(H5O_layout_chunk_t *layout);
@@ -363,10 +364,12 @@ typedef struct H5D_chunk_cached_t {
     hsize_t	scaled[H5O_LAYOUT_NDIMS];	/*scaled offset of chunk*/
     haddr_t	addr;				/*file address of chunk */
     uint32_t	nbytes;				/*size of stored data	*/
+    hsize_t     chunk_idx;			/*index of chunk in dataset */
     unsigned	filter_mask;			/*excluded filters	*/
 } H5D_chunk_cached_t;
 
 /* The raw data chunk cache */
+struct H5D_rdcc_ent_t;  /* Forward declaration of struct used below */
 typedef struct H5D_rdcc_t {
     struct {
         unsigned	ninits;	/* Number of chunk creations		*/
@@ -379,6 +382,7 @@ typedef struct H5D_rdcc_t {
     double		w0;     /* Chunk preemption policy          */
     struct H5D_rdcc_ent_t *head; /* Head of doubly linked list		*/
     struct H5D_rdcc_ent_t *tail; /* Tail of doubly linked list		*/
+    struct H5D_rdcc_ent_t *tmp_head; /* Head of temporary doubly linked list.  Chunks on this list are not in the hash table (slot).  The head entry is a sentinel (does not refer to an actual chunk). */
     size_t		nbytes_used; /* Current cached raw data in bytes */
     int			nused;	/* Number of chunk slots in use		*/
     H5D_chunk_cached_t last;    /* Cached copy of last chunk information */
@@ -422,6 +426,7 @@ typedef struct H5D_shared_t {
     /* Cached dataspace info */
     unsigned            ndims;          /* The dataset's dataspace rank */
     hsize_t             curr_dims[H5S_MAX_RANK];    /* The curr. size of dataset dimensions */
+    hsize_t             curr_power2up[H5S_MAX_RANK];    /* The curr. dim sizes, rounded up to next power of 2 */
     hsize_t             max_dims[H5S_MAX_RANK];     /* The max. size of dataset dimensions */ 
 
     /* Buffered/cached information for types of raw data storage*/
@@ -493,22 +498,6 @@ typedef struct {
     hsize_t size;       /* Accumulated number of bytes for the selection */
 } H5D_vlen_bufsize_t;
 
-/* Raw data chunks are cached.  Each entry in the cache is: */
-typedef struct H5D_rdcc_ent_t {
-    hbool_t	locked;		/*entry is locked in cache		*/
-    hbool_t	dirty;		/*needs to be written to disk?		*/
-    hbool_t     deleted;        /*chunk about to be deleted		*/
-    hsize_t 	scaled[H5O_LAYOUT_NDIMS]; /*scaled chunk 'name' (coordinates) */
-    uint32_t	rd_count;	/*bytes remaining to be read		*/
-    uint32_t	wr_count;	/*bytes remaining to be written		*/
-    H5F_block_t chunk_block;    /*offset/length of chunk in file        */
-    uint8_t	*chunk;		/*the unfiltered chunk data		*/
-    unsigned	idx;		/*index in hash table			*/
-    struct H5D_rdcc_ent_t *next;/*next item in doubly-linked list	*/
-    struct H5D_rdcc_ent_t *prev;/*previous item in doubly-linked list	*/
-} H5D_rdcc_ent_t;
-typedef H5D_rdcc_ent_t *H5D_rdcc_ent_ptr_t; /* For free lists */
-
 
 /*****************************/
 /* Package Private Variables */
@@ -616,11 +605,6 @@ H5_DLL herr_t H5D__chunk_set_info(const H5D_t *dset);
 H5_DLL hbool_t H5D__chunk_is_space_alloc(const H5O_storage_t *storage);
 H5_DLL herr_t H5D__chunk_lookup(const H5D_t *dset, hid_t dxpl_id,
     const hsize_t *scaled, H5D_chunk_ud_t *udata);
-H5_DLL void *H5D__chunk_lock(const H5D_io_info_t *io_info,
-    H5D_chunk_ud_t *udata, hbool_t relax);
-H5_DLL herr_t H5D__chunk_unlock(const H5D_io_info_t *io_info,
-    const H5D_chunk_ud_t *udata, hbool_t dirty, void *chunk,
-    uint32_t naccessed);
 H5_DLL herr_t H5D__chunk_allocated(H5D_t *dset, hid_t dxpl_id, hsize_t *nbytes);
 H5_DLL herr_t H5D__chunk_allocate(const H5D_t *dset, hid_t dxpl_id,
     hbool_t full_overwrite, hsize_t old_dim[]);
diff --git a/src/H5Dvirtual.c b/src/H5Dvirtual.c
index 7c5186d..bf754cb 100644
--- a/src/H5Dvirtual.c
+++ b/src/H5Dvirtual.c
@@ -446,10 +446,10 @@ H5D__virtual_copy_layout(H5O_layout_t *layout)
 
             /* Copy original source names */
             if(NULL == (layout->storage.u.virt.list[i].source_file_name
-                    = HDstrdup(orig_list[i].source_file_name)))
+                    = H5MM_strdup(orig_list[i].source_file_name)))
                 HGOTO_ERROR(H5E_DATASET, H5E_RESOURCE, FAIL, "unable to duplicate source file name")
             if(NULL == (layout->storage.u.virt.list[i].source_dset_name
-                    = HDstrdup(orig_list[i].source_dset_name)))
+                    = H5MM_strdup(orig_list[i].source_dset_name)))
                 HGOTO_ERROR(H5E_DATASET, H5E_RESOURCE, FAIL, "unable to duplicate source dataset name")
 
             /* Copy source selection */
@@ -488,7 +488,7 @@ H5D__virtual_copy_layout(H5O_layout_t *layout)
                 } /* end if */
                 else
                     if(NULL == (layout->storage.u.virt.list[i].source_dset.file_name
-                            = HDstrdup(orig_list[i].source_dset.file_name)))
+                            = H5MM_strdup(orig_list[i].source_dset.file_name)))
                         HGOTO_ERROR(H5E_DATASET, H5E_RESOURCE, FAIL, "unable to duplicate source file name")
             } /* end if */
             if(orig_list[i].source_dset.dset_name) {
@@ -504,7 +504,7 @@ H5D__virtual_copy_layout(H5O_layout_t *layout)
                 } /* end if */
                 else
                     if(NULL == (layout->storage.u.virt.list[i].source_dset.dset_name
-                            = HDstrdup(orig_list[i].source_dset.dset_name)))
+                            = H5MM_strdup(orig_list[i].source_dset.dset_name)))
                         HGOTO_ERROR(H5E_DATASET, H5E_RESOURCE, FAIL, "unable to duplicate source dataset name")
             } /* end if */
 
@@ -1124,7 +1124,7 @@ H5D__virtual_copy_parsed_name(H5O_storage_virtual_name_seg_t **dst,
 
         /* Duplicate name segment */
         if(p_src->name_segment) {
-            if(NULL == ((*p_dst)->name_segment = HDstrdup(p_src->name_segment)))
+            if(NULL == ((*p_dst)->name_segment = H5MM_strdup(p_src->name_segment)))
                 HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, FAIL, "unable to duplicate name segment")
         } /* end if */
 
diff --git a/src/H5E.c b/src/H5E.c
index 4374f1d..efa83e4 100644
--- a/src/H5E.c
+++ b/src/H5E.c
@@ -1417,8 +1417,13 @@ H5Epush2(hid_t err_stack, const char *file, const char *func, unsigned line,
 done:
     if(va_started)
         va_end(ap);
+#ifdef H5_HAVE_VASPRINTF
+    if(tmp)
+        HDfree(tmp);
+#else /* H5_HAVE_VASPRINTF */
     if(tmp)
         H5MM_xfree(tmp);
+#endif /* H5_HAVE_VASPRINTF */
 
     FUNC_LEAVE_API(ret_value)
 } /* end H5Epush2() */
diff --git a/src/H5EAdblkpage.c b/src/H5EAdblkpage.c
index 15bad43..9f3b39a 100644
--- a/src/H5EAdblkpage.c
+++ b/src/H5EAdblkpage.c
@@ -290,7 +290,6 @@ END_FUNC(PKG)   /* end H5EA__dblk_page_unprotect() */
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 BEGIN_FUNC(PKG, ERR,
 herr_t, SUCCEED, FAIL,
 H5EA__dblk_page_dest(H5EA_dblk_page_t *dblk_page))
diff --git a/src/H5EAdblock.c b/src/H5EAdblock.c
index cd20bba..3eaaf1c 100644
--- a/src/H5EAdblock.c
+++ b/src/H5EAdblock.c
@@ -457,7 +457,6 @@ END_FUNC(PKG)   /* end H5EA__dblock_delete() */
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 BEGIN_FUNC(PKG, ERR,
 herr_t, SUCCEED, FAIL,
 H5EA__dblock_dest(H5EA_dblock_t *dblock))
diff --git a/src/H5EAhdr.c b/src/H5EAhdr.c
index eff4b54..da15087 100644
--- a/src/H5EAhdr.c
+++ b/src/H5EAhdr.c
@@ -43,7 +43,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5EApkg.h"		/* Extensible Arrays			*/
 #include "H5MFprivate.h"	/* File memory management		*/
-#include "H5VMprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"	/* Vectors and arrays 			*/
 
 
 /****************/
@@ -128,7 +128,7 @@ H5EA__hdr_alloc(H5F_t *f))
 
     /* Allocate space for the shared information */
     if(NULL == (hdr = H5FL_CALLOC(H5EA_hdr_t)))
-	H5E_THROW(H5E_CANTALLOC, "memory allocation failed for extensible array shared header")
+        H5E_THROW(H5E_CANTALLOC, "memory allocation failed for extensible array shared header")
 
     /* Set non-zero internal fields */
     hdr->addr = HADDR_UNDEF;
@@ -390,35 +390,35 @@ HDfprintf(stderr, "%s: Called\n", FUNC);
 
     /* Check for valid parameters */
     if(cparam->raw_elmt_size == 0)
-	H5E_THROW(H5E_BADVALUE, "element size must be greater than zero")
+        H5E_THROW(H5E_BADVALUE, "element size must be greater than zero")
     if(cparam->max_nelmts_bits == 0)
-	H5E_THROW(H5E_BADVALUE, "max. # of elements bits must be greater than zero")
+        H5E_THROW(H5E_BADVALUE, "max. # of elements bits must be greater than zero")
     if(cparam->max_nelmts_bits > H5EA_MAX_NELMTS_IDX_MAX)
-	H5E_THROW(H5E_BADVALUE, "max. # of elements bits must be <= %u", (unsigned)H5EA_MAX_NELMTS_IDX_MAX)
+        H5E_THROW(H5E_BADVALUE, "max. # of elements bits must be <= %u", (unsigned)H5EA_MAX_NELMTS_IDX_MAX)
     if(cparam->sup_blk_min_data_ptrs < 2)
-	H5E_THROW(H5E_BADVALUE, "min # of data block pointers in super block must be >= two")
+        H5E_THROW(H5E_BADVALUE, "min # of data block pointers in super block must be >= two")
     if(!POWER_OF_TWO(cparam->sup_blk_min_data_ptrs))
-	H5E_THROW(H5E_BADVALUE, "min # of data block pointers in super block must be power of two")
+        H5E_THROW(H5E_BADVALUE, "min # of data block pointers in super block must be power of two")
     if(!POWER_OF_TWO(cparam->data_blk_min_elmts))
-	H5E_THROW(H5E_BADVALUE, "min # of elements per data block must be power of two")
+        H5E_THROW(H5E_BADVALUE, "min # of elements per data block must be power of two")
     dblk_page_nelmts = (size_t)1 << cparam->max_dblk_page_nelmts_bits;
     if(dblk_page_nelmts < cparam->idx_blk_elmts)
-	H5E_THROW(H5E_BADVALUE, "# of elements per data block page must be greater than # of elements in index block")
+        H5E_THROW(H5E_BADVALUE, "# of elements per data block page must be greater than # of elements in index block")
 
     /* Compute the number of elements in data blocks for first actual super block */
     sblk_idx = H5EA_SBLK_FIRST_IDX(cparam->sup_blk_min_data_ptrs);
     dblk_nelmts = H5EA_SBLK_DBLK_NELMTS(sblk_idx, cparam->data_blk_min_elmts);
     if(dblk_page_nelmts < dblk_nelmts)
-	H5E_THROW(H5E_BADVALUE, "max. # of elements per data block page bits must be > # of elements in first data block from super block")
+        H5E_THROW(H5E_BADVALUE, "max. # of elements per data block page bits must be > # of elements in first data block from super block")
 
     if(cparam->max_dblk_page_nelmts_bits > cparam->max_nelmts_bits)
-	H5E_THROW(H5E_BADVALUE, "max. # of elements per data block page bits must be <= max. # of elements bits")
+        H5E_THROW(H5E_BADVALUE, "max. # of elements per data block page bits must be <= max. # of elements bits")
 }
 #endif /* NDEBUG */
 
     /* Allocate space for the shared information */
     if(NULL == (hdr = H5EA__hdr_alloc(f)))
-	H5E_THROW(H5E_CANTALLOC, "memory allocation failed for extensible array shared header")
+        H5E_THROW(H5E_CANTALLOC, "memory allocation failed for extensible array shared header")
 
     /* Set the internal parameters for the array */
     hdr->idx_blk_addr = HADDR_UNDEF;
@@ -428,15 +428,15 @@ HDfprintf(stderr, "%s: Called\n", FUNC);
 
     /* Finish initializing extensible array header */
     if(H5EA__hdr_init(hdr, ctx_udata) < 0)
-	H5E_THROW(H5E_CANTINIT, "initialization failed for extensible array header")
+        H5E_THROW(H5E_CANTINIT, "initialization failed for extensible array header")
 
     /* Allocate space for the header on disk */
     if(HADDR_UNDEF == (hdr->addr = H5MF_alloc(f, H5FD_MEM_EARRAY_HDR, dxpl_id, (hsize_t)hdr->size)))
-	H5E_THROW(H5E_CANTALLOC, "file allocation failed for extensible array header")
+        H5E_THROW(H5E_CANTALLOC, "file allocation failed for extensible array header")
 
     /* Cache the new extensible array header */
     if(H5AC_insert_entry(f, dxpl_id, H5AC_EARRAY_HDR, hdr->addr, hdr, H5AC__NO_FLAGS_SET) < 0)
-	H5E_THROW(H5E_CANTINSERT, "can't add extensible array header to cache")
+        H5E_THROW(H5E_CANTINSERT, "can't add extensible array header to cache")
 
     /* Set address of array header to return */
     ret_value = hdr->addr;
@@ -616,7 +616,7 @@ END_FUNC(PKG)   /* end H5EA__hdr_modified() */
  *
  * Purpose:	Convenience wrapper around protecting extensible array header
  *
- * Return:	Non-NULL pointer to index block on success/NULL on failure
+ * Return:	Non-NULL pointer to header on success/NULL on failure
  *
  * Programmer:	Quincey Koziol
  *		koziol@hdfgroup.org
@@ -647,6 +647,7 @@ H5EA__hdr_protect(H5F_t *f, hid_t dxpl_id, haddr_t ea_addr, void *ctx_udata,
     /* Protect the header */
     if(NULL == (ret_value = (H5EA_hdr_t *)H5AC_protect(f, dxpl_id, H5AC_EARRAY_HDR, ea_addr, &udata, flags)))
         H5E_THROW(H5E_CANTPROTECT, "unable to protect extensible array header, address = %llu", (unsigned long long)ea_addr)
+    ret_value->f = f;   /* (Must be set again here, in case the header was already in the cache -QAK) */
 
 CATCH
 
diff --git a/src/H5EAiblock.c b/src/H5EAiblock.c
index 3f49d0d..623ae30 100644
--- a/src/H5EAiblock.c
+++ b/src/H5EAiblock.c
@@ -432,7 +432,6 @@ END_FUNC(PKG)   /* end H5EA__iblock_delete() */
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 BEGIN_FUNC(PKG, ERR,
 herr_t, SUCCEED, FAIL,
 H5EA__iblock_dest(H5EA_iblock_t *iblock))
diff --git a/src/H5EAsblock.c b/src/H5EAsblock.c
index 7753f0e..f775484 100644
--- a/src/H5EAsblock.c
+++ b/src/H5EAsblock.c
@@ -409,7 +409,6 @@ END_FUNC(PKG)   /* end H5EA__sblock_delete() */
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 BEGIN_FUNC(PKG, ERR,
 herr_t, SUCCEED, FAIL,
 H5EA__sblock_dest(H5EA_sblock_t *sblock))
diff --git a/src/H5Eint.c b/src/H5Eint.c
index 6e84a09..6ed405f 100644
--- a/src/H5Eint.c
+++ b/src/H5Eint.c
@@ -743,8 +743,13 @@ H5E_printf_stack(H5E_t *estack, const char *file, const char *func, unsigned lin
 done:
     if(va_started)
         va_end(ap);
+#ifdef H5_HAVE_VASPRINTF
+    if(tmp)
+        HDfree(tmp);
+#else /* H5_HAVE_VASPRINTF */
     if(tmp)
         H5MM_xfree(tmp);
+#endif /* H5_HAVE_VASPRINTF */
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5E_printf_stack() */
diff --git a/src/H5FAhdr.c b/src/H5FAhdr.c
index 62b1837..ac9a103 100644
--- a/src/H5FAhdr.c
+++ b/src/H5FAhdr.c
@@ -397,7 +397,7 @@ END_FUNC(PKG)   /* end H5FA__hdr_modified() */
  *
  * Purpose:	Convenience wrapper around protecting fixed array header
  *
- * Return:	Non-NULL pointer to index block on success/NULL on failure
+ * Return:	Non-NULL pointer to header on success/NULL on failure
  *
  * Programmer:	Quincey Koziol
  *		koziol@hdfgroup.org
@@ -428,6 +428,7 @@ H5FA__hdr_protect(H5F_t *f, hid_t dxpl_id, haddr_t fa_addr, void *ctx_udata,
     /* Protect the header */
     if(NULL == (ret_value = (H5FA_hdr_t *)H5AC_protect(f, dxpl_id, H5AC_FARRAY_HDR, fa_addr, &udata, flags)))
         H5E_THROW(H5E_CANTPROTECT, "unable to protect fixed array header, address = %llu", (unsigned long long)fa_addr)
+    ret_value->f = f;   /* (Must be set again here, in case the header was already in the cache -QAK) */
 
 CATCH
 
diff --git a/src/H5FDfamily.c b/src/H5FDfamily.c
index 310b72f..b92a685 100644
--- a/src/H5FDfamily.c
+++ b/src/H5FDfamily.c
@@ -861,7 +861,6 @@ H5FD_family_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5FD_family_query(const H5FD_t * _file, unsigned long *flags /* out */)
 {
diff --git a/src/H5FDlog.c b/src/H5FDlog.c
index a8228e0..4bb72ce 100644
--- a/src/H5FDlog.c
+++ b/src/H5FDlog.c
@@ -406,7 +406,7 @@ H5FD_log_fapl_copy(const void *_old_fa)
 
     /* Deep copy the log file name */
     if(old_fa->logfile != NULL)
-        if(NULL == (new_fa->logfile = H5MM_xstrdup(old_fa->logfile)))
+        if(NULL == (new_fa->logfile = H5MM_strdup(old_fa->logfile)))
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "unable to allocate log file name")
 
     /* Set return value */
@@ -416,7 +416,7 @@ done:
     if(NULL == ret_value)
         if(new_fa) {
             if(new_fa->logfile)
-                H5MM_free(new_fa->logfile);
+                new_fa->logfile = H5MM_xfree(new_fa->logfile);
             H5MM_free(new_fa);
         } /* end if */
 
@@ -445,7 +445,7 @@ H5FD_log_fapl_free(void *_fa)
 
     /* Free the fapl information */
     if(fa->logfile)
-        H5MM_xfree(fa->logfile);
+        fa->logfile = H5MM_xfree(fa->logfile);
     H5MM_xfree(fa);
 
     FUNC_LEAVE_NOAPI(SUCCEED)
@@ -594,7 +594,7 @@ H5FD_log_open(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr)
     /* Get the flags for logging */
     file->fa.flags = fa->flags;
     if(fa->logfile)
-        file->fa.logfile = HDstrdup(fa->logfile);
+        file->fa.logfile = H5MM_strdup(fa->logfile);
     else
         file->fa.logfile = NULL;
     file->fa.buf_size = fa->buf_size;
@@ -798,10 +798,8 @@ H5FD_log_close(H5FD_t *_file)
             HDfclose(file->logfp);
     } /* end if */
 
-    if(file->fa.logfile) {
-        HDfree(file->fa.logfile);
-        file->fa.logfile = NULL;
-    }
+    if(file->fa.logfile)
+        file->fa.logfile = H5MM_xfree(file->fa.logfile);
 
     /* Release the file info */
     file = H5FL_FREE(H5FD_log_t, file);
diff --git a/src/H5Fint.c b/src/H5Fint.c
index 4e44bcb..0c4ffb9 100644
--- a/src/H5Fint.c
+++ b/src/H5Fint.c
@@ -130,7 +130,7 @@ H5F_get_access_plist(H5F_t *f, hbool_t app_ref)
     H5FD_driver_prop_t driver_prop;         /* Property for driver ID & info */
     hbool_t driver_prop_copied = FALSE;     /* Whether the driver property has been set up */
     unsigned    efc_size = 0;
-    hid_t	ret_value = SUCCEED;
+    hid_t	ret_value = SUCCEED;        /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
@@ -1062,6 +1062,7 @@ H5F_open(const char *name, unsigned flags, hid_t fcpl_id, hid_t fapl_id,
         if(H5G_mkroot(file, dxpl_id, TRUE) < 0)
             HGOTO_ERROR(H5E_FILE, H5E_CANTINIT, NULL, "unable to create/open root group")
     } else if (1 == shared->nrefs) {
+
 	/* Read the superblock if it hasn't been read before. */
         if(H5F__super_read(file, dxpl_id) < 0)
 	    HGOTO_ERROR(H5E_FILE, H5E_READERROR, NULL, "unable to read superblock")
@@ -1109,8 +1110,8 @@ H5F_open(const char *name, unsigned flags, hid_t fcpl_id, hid_t fapl_id,
 
 done:
     if(!ret_value && file)
-        if(H5F_dest(file, dxpl_id, FALSE) < 0)
-            HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, NULL, "problems closing file")
+	if(H5F_dest(file, dxpl_id, FALSE) < 0)
+	    HDONE_ERROR(H5E_FILE, H5E_CANTCLOSEFILE, NULL, "problems closing file")
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5F_open() */
diff --git a/src/H5Fprivate.h b/src/H5Fprivate.h
index 2d61a4c..be4acb7 100644
--- a/src/H5Fprivate.h
+++ b/src/H5Fprivate.h
@@ -646,8 +646,7 @@ H5_DLL hid_t H5F_get_driver_id(const H5F_t *f);
 H5_DLL herr_t H5F_get_fileno(const H5F_t *f, unsigned long *filenum);
 H5_DLL hbool_t H5F_has_feature(const H5F_t *f, unsigned feature);
 H5_DLL haddr_t H5F_get_eoa(const H5F_t *f, H5FD_mem_t type);
-H5_DLL herr_t H5F_get_vfd_handle(const H5F_t *file, hid_t fapl,
-    void **file_handle);
+H5_DLL herr_t H5F_get_vfd_handle(const H5F_t *file, hid_t fapl, void **file_handle);
 
 /* Functions that check file mounting information */
 H5_DLL hbool_t H5F_is_mount(const H5F_t *file);
diff --git a/src/H5Fsuper.c b/src/H5Fsuper.c
index c6b1c83..332dfa6 100644
--- a/src/H5Fsuper.c
+++ b/src/H5Fsuper.c
@@ -296,7 +296,7 @@ H5F__super_read(H5F_t *f, hid_t dxpl_id)
 
     /* Make certain we can read the fixed-size portion of the superblock */
     if(H5F__set_eoa(f, H5FD_MEM_SUPER, 
-              H5F_SUPERBLOCK_FIXED_SIZE + H5F_SUPERBLOCK_MINIMAL_VARLEN_SIZE) < 0)
+              (haddr_t)(H5F_SUPERBLOCK_FIXED_SIZE + H5F_SUPERBLOCK_MINIMAL_VARLEN_SIZE)) < 0)
         HGOTO_ERROR(H5E_FILE, H5E_CANTSET, FAIL, "set end of space allocation request failed")
 
     /* Set up the user data for cache callbacks */
@@ -510,8 +510,10 @@ H5F__super_read(H5F_t *f, hid_t dxpl_id)
                     HGOTO_ERROR(H5E_FILE, H5E_CANTGET, FAIL, "driver info message not present")
 
                 /* Validate and decode driver information */
-                if(H5FD_sb_load(f->shared->lf, drvinfo.name, drvinfo.buf) < 0)
+                if(H5FD_sb_load(f->shared->lf, drvinfo.name, drvinfo.buf) < 0) {
+                    H5O_msg_reset(H5O_DRVINFO_ID, &drvinfo);
                     HGOTO_ERROR(H5E_FILE, H5E_CANTDECODE, FAIL, "unable to decode driver information")
+                } /* end if */
 
                 /* Reset driver info message */
                 H5O_msg_reset(H5O_DRVINFO_ID, &drvinfo);
diff --git a/src/H5Gbtree2.c b/src/H5Gbtree2.c
index b464930..1a99b12 100644
--- a/src/H5Gbtree2.c
+++ b/src/H5Gbtree2.c
@@ -114,9 +114,7 @@ const H5B2_class_t H5G_BT2_NAME[1]={{   /* B-tree class information */
     H5G_dense_btree2_name_compare,      /* Record comparison callback */
     H5G_dense_btree2_name_encode,       /* Record encoding callback */
     H5G_dense_btree2_name_decode,       /* Record decoding callback */
-    H5G_dense_btree2_name_debug,        /* Record debugging callback */
-    NULL,                               /* Create debugging context */
-    NULL                                /* Destroy debugging context */
+    H5G_dense_btree2_name_debug         /* Record debugging callback */
 }};
 
 /* v2 B-tree class for indexing 'creation order' field of links */
@@ -130,9 +128,7 @@ const H5B2_class_t H5G_BT2_CORDER[1]={{ /* B-tree class information */
     H5G_dense_btree2_corder_compare,    /* Record comparison callback */
     H5G_dense_btree2_corder_encode,     /* Record encoding callback */
     H5G_dense_btree2_corder_decode,     /* Record decoding callback */
-    H5G_dense_btree2_corder_debug,      /* Record debugging callback */
-    NULL,                               /* Create debugging context */
-    NULL                                /* Destroy debugging context */
+    H5G_dense_btree2_corder_debug       /* Record debugging callback */
 }};
 
 /*****************************/
diff --git a/src/H5HFbtree2.c b/src/H5HFbtree2.c
index d82de93..a79bf58 100644
--- a/src/H5HFbtree2.c
+++ b/src/H5HFbtree2.c
@@ -71,7 +71,6 @@ typedef struct H5HF_huge_bt2_ctx_t {
 /* Common callbacks */
 static void *H5HF__huge_bt2_crt_context(void *udata);
 static herr_t H5HF__huge_bt2_dst_context(void *ctx);
-static void *H5HF__huge_bt2_crt_dbg_context(H5F_t *f, hid_t dxpl_id, haddr_t addr);
 
 /* Callbacks for indirect objects */
 static herr_t H5HF__huge_bt2_indir_store(void *native, const void *udata);
@@ -127,9 +126,7 @@ const H5B2_class_t H5HF_HUGE_BT2_INDIR[1]={{ /* B-tree class information */
     H5HF__huge_bt2_indir_compare,           /* Record comparison callback */
     H5HF__huge_bt2_indir_encode,            /* Record encoding callback */
     H5HF__huge_bt2_indir_decode,            /* Record decoding callback */
-    H5HF__huge_bt2_indir_debug,             /* Record debugging callback */
-    H5HF__huge_bt2_crt_dbg_context,         /* Create debugging context */
-    H5HF__huge_bt2_dst_context              /* Destroy debugging context */
+    H5HF__huge_bt2_indir_debug              /* Record debugging callback */
 }};
 
 /* v2 B-tree class for indirectly accessed, filtered 'huge' objects */
@@ -143,9 +140,7 @@ const H5B2_class_t H5HF_HUGE_BT2_FILT_INDIR[1]={{ /* B-tree class information */
     H5HF__huge_bt2_filt_indir_compare,      /* Record comparison callback */
     H5HF__huge_bt2_filt_indir_encode,       /* Record encoding callback */
     H5HF__huge_bt2_filt_indir_decode,       /* Record decoding callback */
-    H5HF__huge_bt2_filt_indir_debug,        /* Record debugging callback */
-    H5HF__huge_bt2_crt_dbg_context,         /* Create debugging context */
-    H5HF__huge_bt2_dst_context              /* Destroy debugging context */
+    H5HF__huge_bt2_filt_indir_debug         /* Record debugging callback */
 }};
 
 /* v2 B-tree class for directly accessed 'huge' objects */
@@ -159,9 +154,7 @@ const H5B2_class_t H5HF_HUGE_BT2_DIR[1]={{  /* B-tree class information */
     H5HF__huge_bt2_dir_compare,             /* Record comparison callback */
     H5HF__huge_bt2_dir_encode,              /* Record encoding callback */
     H5HF__huge_bt2_dir_decode,              /* Record decoding callback */
-    H5HF__huge_bt2_dir_debug,               /* Record debugging callback */
-    H5HF__huge_bt2_crt_dbg_context,         /* Create debugging context */
-    H5HF__huge_bt2_dst_context              /* Destroy debugging context */
+    H5HF__huge_bt2_dir_debug                /* Record debugging callback */
 }};
 
 /* v2 B-tree class for directly accessed, filtered 'huge' objects */
@@ -175,9 +168,7 @@ const H5B2_class_t H5HF_HUGE_BT2_FILT_DIR[1]={{ /* B-tree class information */
     H5HF__huge_bt2_filt_dir_compare,        /* Record comparison callback */
     H5HF__huge_bt2_filt_dir_encode,         /* Record encoding callback */
     H5HF__huge_bt2_filt_dir_decode,         /* Record decoding callback */
-    H5HF__huge_bt2_filt_dir_debug,          /* Record debugging callback */
-    H5HF__huge_bt2_crt_dbg_context,         /* Create debugging context */
-    H5HF__huge_bt2_dst_context              /* Destroy debugging context */
+    H5HF__huge_bt2_filt_dir_debug           /* Record debugging callback */
 }};
 
 /*****************************/
@@ -270,46 +261,6 @@ H5HF__huge_bt2_dst_context(void *_ctx)
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5HF__huge_bt2_crt_dbg_context
- *
- * Purpose:	Create context for debugging callback
- *
- * Return:	Success:	non-NULL
- *		Failure:	NULL
- *
- * Programmer:	Quincey Koziol
- *              Tuesday, December 1, 2009
- *
- *-------------------------------------------------------------------------
- */
-static void *
-H5HF__huge_bt2_crt_dbg_context(H5F_t *f, hid_t H5_ATTR_UNUSED dxpl_id, haddr_t H5_ATTR_UNUSED addr)
-{
-    H5HF_huge_bt2_ctx_t *ctx;   /* Callback context structure */
-    void *ret_value = NULL;     /* Return value */
-
-    FUNC_ENTER_STATIC
-
-    /* Sanity check */
-    HDassert(f);
-
-    /* Allocate callback context */
-    if(NULL == (ctx = H5FL_MALLOC(H5HF_huge_bt2_ctx_t)))
-        HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, NULL, "can't allocate callback context")
-
-    /* Determine the size of addresses & lengths in the file */
-    ctx->sizeof_addr = H5F_SIZEOF_ADDR(f);
-    ctx->sizeof_size = H5F_SIZEOF_SIZE(f);
-
-    /* Set return value */
-    ret_value = ctx;
-
-done:
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* H5HF__huge_bt2_crt_dbg_context() */
-
-
-/*-------------------------------------------------------------------------
  * Function:	H5HF__huge_bt2_indir_found
  *
  * Purpose:	Retrieve record for indirectly accessed 'huge' object, when
diff --git a/src/H5L.c b/src/H5L.c
index 84d8d35..9e0e277 100644
--- a/src/H5L.c
+++ b/src/H5L.c
@@ -93,6 +93,17 @@ typedef struct {
     hid_t dxpl_id;                      /* Dataset transfer property list */
 } H5L_trav_mv2_t;
 
+/* User data for path traversal routine for checking if a link exists */
+typedef struct {
+    /* Down */
+    char *sep;                          /* Pointer to next separator in the string */
+    hid_t lapl_id;                      /* Link access property list */
+    hid_t dxpl_id;                      /* Dataset transfer property list */
+
+    /* Up */
+    hbool_t exists;                     /* Whether the link exists or not */
+} H5L_trav_le_t;
+
 /* User data for path traversal routine for getting link value */
 typedef struct {
     size_t size;                        /* Size of user buffer */
@@ -170,10 +181,13 @@ static herr_t H5L_move_cb(H5G_loc_t *grp_loc/*in*/, const char *name,
 static herr_t H5L_move_dest_cb(H5G_loc_t *grp_loc/*in*/, const char *name,
     const H5O_link_t *lnk, H5G_loc_t *obj_loc, void *_udata/*in,out*/,
     H5G_own_loc_t *own_loc/*out*/);
-static herr_t H5L_exists_cb(H5G_loc_t *grp_loc/*in*/, const char *name,
+static herr_t H5L__exists_final_cb(H5G_loc_t *grp_loc/*in*/, const char *name,
+    const H5O_link_t *lnk, H5G_loc_t *obj_loc, void *_udata/*in,out*/,
+    H5G_own_loc_t *own_loc/*out*/);
+static herr_t H5L__exists_inter_cb(H5G_loc_t *grp_loc/*in*/, const char *name,
     const H5O_link_t *lnk, H5G_loc_t *obj_loc, void *_udata/*in,out*/,
     H5G_own_loc_t *own_loc/*out*/);
-static htri_t H5L_exists(const H5G_loc_t *loc, const char *name, hid_t lapl_id,
+static htri_t H5L__exists(const H5G_loc_t *loc, const char *name, hid_t lapl_id,
     hid_t dxpl_id);
 static herr_t H5L_get_info_cb(H5G_loc_t *grp_loc/*in*/, const char *name,
     const H5O_link_t *lnk, H5G_loc_t *obj_loc, void *_udata/*in,out*/,
@@ -859,7 +873,7 @@ H5Lexists(hid_t loc_id, const char *name, hid_t lapl_id)
         HGOTO_ERROR(H5E_PLIST, H5E_CANTSET, FAIL, "can't set access and transfer property lists")
 
     /* Check for the existence of the link */
-    if((ret_value = H5L_exists(&loc, name, lapl_id, dxpl_id)) < 0)
+    if((ret_value = H5L__exists(&loc, name, lapl_id, dxpl_id)) < 0)
 	HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "unable to get link info")
 
 done:
@@ -2752,9 +2766,10 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5L_exists_cb
+ * Function:	H5L__exists_final_cb
  *
- * Purpose:	Callback for checking whether a link exists
+ * Purpose:	Callback for checking whether a link exists, as the final
+ *              component of a path
  *
  * Return:	Non-negative on success/Negative on failure
  *
@@ -2764,30 +2779,162 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5L_exists_cb(H5G_loc_t H5_ATTR_UNUSED *grp_loc/*in*/, const char H5_ATTR_UNUSED *name,
+H5L__exists_final_cb(H5G_loc_t H5_ATTR_UNUSED *grp_loc/*in*/, const char H5_ATTR_UNUSED *name,
     const H5O_link_t *lnk, H5G_loc_t H5_ATTR_UNUSED *obj_loc, void *_udata/*in,out*/,
     H5G_own_loc_t *own_loc/*out*/)
 {
-    hbool_t *udata = (hbool_t *)_udata;   /* User data passed in */
+    H5L_trav_le_t *udata = (H5L_trav_le_t *)_udata;   /* User data passed in */
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
     /* Check if the name in this group resolved to a valid link */
-    *udata = (hbool_t)(lnk != NULL);
+    udata->exists = (hbool_t)(lnk != NULL);
 
     /* Indicate that this callback didn't take ownership of the group *
      * location for the object */
     *own_loc = H5G_OWN_NONE;
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5L_exists_cb() */
+} /* end H5L__exists_final_cb() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5L_exists
+ * Function:	H5L__exists_inter_cb
+ *
+ * Purpose:	Callback for checking whether a link exists, as an intermediate
+ *              component of a path
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Quincey Koziol
+ *              Thursday, December 31 2015
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5L__exists_inter_cb(H5G_loc_t H5_ATTR_UNUSED *grp_loc/*in*/, const char H5_ATTR_UNUSED *name,
+    const H5O_link_t *lnk, H5G_loc_t *obj_loc, void *_udata/*in,out*/,
+    H5G_own_loc_t *own_loc/*out*/)
+{
+    H5L_trav_le_t *udata = (H5L_trav_le_t *)_udata;   /* User data passed in */
+    herr_t ret_value = SUCCEED;         /* Return value */
+
+    FUNC_ENTER_STATIC
+
+    /* Check if the name in this group resolved to a valid link */
+    if(lnk != NULL) {
+        /* Check for more components to the path */
+        if(udata->sep) {
+            H5G_traverse_t cb_func;     /* Callback function for tranversal */
+            char *next;                 /* Pointer to next component name */
+
+            /* Look for another separator */
+            next = udata->sep;
+            if(NULL == (udata->sep = HDstrchr(udata->sep, '/')))
+                cb_func = H5L__exists_final_cb;
+            else {
+                /* Chew through adjacent separators, if present */
+                do {
+                    *udata->sep = '\0';
+                    udata->sep++;
+                } while('/' == *udata->sep);
+                cb_func = H5L__exists_inter_cb;
+            } /* end else */
+            if(H5G_traverse(obj_loc, next, H5G_TARGET_SLINK | H5G_TARGET_UDLINK, cb_func, udata, udata->lapl_id, udata->dxpl_id) < 0)
+                HGOTO_ERROR(H5E_SYM, H5E_CANTGET, FAIL, "can't determine if link exists")
+        } /* end if */
+        else
+            udata->exists = TRUE;
+    } /* end if */
+    else
+        udata->exists = FALSE;
+
+    /* Indicate that this callback didn't take ownership of the group *
+     * location for the object */
+    *own_loc = H5G_OWN_NONE;
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5L__exists_inter_cb() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5L_exists_tolerant
  *
  * Purpose:	Returns whether a link exists in a group
  *
+ * Note:	Same as H5L_exists, except that missing links are reported
+ *		as 'FALSE' instead of causing failures
+ *
+ * Return:	Non-negative (TRUE/FALSE) on success/Negative on failure
+ *
+ * Programmer:	Quincey Koziol
+ *              Thursday, December 31 2015
+ *
+ *-------------------------------------------------------------------------
+ */
+htri_t
+H5L_exists_tolerant(const H5G_loc_t *loc, const char *name, hid_t lapl_id, hid_t dxpl_id)
+{
+    H5L_trav_le_t udata;        /* User data for traversal */
+    H5G_traverse_t cb_func;     /* Callback function for tranversal */
+    char *name_copy = NULL;     /* Duplicate of name */
+    char *name_trav;            /* Name to traverse */
+    htri_t ret_value = FAIL;    /* Return value */
+
+    FUNC_ENTER_NOAPI(FAIL)
+
+    /* Sanity checks */
+    HDassert(loc);
+    HDassert(name);
+
+    /* Copy the name and skip leading '/'s */
+    name_trav = name_copy = H5MM_strdup(name);
+    while('/' == *name_trav)
+        name_trav++;
+
+    /* A path of "/" will always exist in a file */
+    if('\0' == *name_trav)
+        HGOTO_DONE(TRUE)
+
+    /* Set up user data & correct callback */
+    udata.lapl_id = lapl_id;
+    udata.dxpl_id = dxpl_id;
+    udata.exists = FALSE;
+    if(NULL == (udata.sep = HDstrchr(name_trav, '/')))
+        cb_func = H5L__exists_final_cb;
+    else {
+        /* Chew through adjacent separators, if present */
+        do {
+            *udata.sep = '\0';
+            udata.sep++;
+        } while('/' == *udata.sep);
+        cb_func = H5L__exists_inter_cb;
+    } /* end else */
+
+    /* Traverse the group hierarchy to locate the link to check */
+    if(H5G_traverse(loc, name_trav, H5G_TARGET_SLINK | H5G_TARGET_UDLINK, cb_func, &udata, lapl_id, dxpl_id) < 0)
+        HGOTO_ERROR(H5E_SYM, H5E_CANTGET, FAIL, "can't determine if link exists")
+
+    /* Set return value */
+    ret_value = (htri_t)udata.exists;
+
+done:
+    /* Release duplicated string */
+    H5MM_xfree(name_copy);
+
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5L_exists_tolerant() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5L__exists
+ *
+ * Purpose:	Returns whether a link exists in a group
+ *
+ * Note:	Same as H5L_exists_tolerant, except that missing links are reported
+ *		as failures
+ *
  * Return:	Non-negative (TRUE/FALSE) on success/Negative on failure
  *
  * Programmer:	Quincey Koziol
@@ -2796,23 +2943,28 @@ H5L_exists_cb(H5G_loc_t H5_ATTR_UNUSED *grp_loc/*in*/, const char H5_ATTR_UNUSED
  *-------------------------------------------------------------------------
  */
 static htri_t
-H5L_exists(const H5G_loc_t *loc, const char *name, hid_t lapl_id, hid_t dxpl_id)
+H5L__exists(const H5G_loc_t *loc, const char *name, hid_t lapl_id, hid_t dxpl_id)
 {
-    hbool_t exists = FALSE;     /* Whether the link exists in the group */
+    H5L_trav_le_t udata;        /* User data for traversal */
     htri_t ret_value = FAIL;    /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
+
+    /* A path of "/" will always exist in a file */
+    if(0 == HDstrcmp(name, "/"))
+        HGOTO_DONE(TRUE)
 
     /* Traverse the group hierarchy to locate the object to get info about */
-    if(H5G_traverse(loc, name, H5G_TARGET_SLINK|H5G_TARGET_UDLINK, H5L_exists_cb, &exists, lapl_id, dxpl_id) < 0)
+    udata.exists = FALSE;
+    if(H5G_traverse(loc, name, H5G_TARGET_SLINK | H5G_TARGET_UDLINK, H5L__exists_final_cb, &udata, lapl_id, dxpl_id) < 0)
         HGOTO_ERROR(H5E_SYM, H5E_EXISTS, FAIL, "path doesn't exist")
 
     /* Set return value */
-    ret_value = (htri_t)exists;
+    ret_value = (htri_t)udata.exists;
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* H5L_exists() */
+} /* H5L__exists() */
 
 
 /*-------------------------------------------------------------------------
diff --git a/src/H5Lprivate.h b/src/H5Lprivate.h
index f3079bc..1c8690b 100644
--- a/src/H5Lprivate.h
+++ b/src/H5Lprivate.h
@@ -81,6 +81,8 @@ H5_DLL hid_t H5L_get_default_lcpl(void);
 H5_DLL herr_t H5L_move(H5G_loc_t *src_loc, const char *src_name,
     H5G_loc_t *dst_loc, const char *dst_name, hbool_t copy_flag,
     hid_t lcpl_id, hid_t lapl_id, hid_t dxpl_id);
+H5_DLL htri_t H5L_exists_tolerant(const H5G_loc_t *loc, const char *name, hid_t lapl_id,
+    hid_t dxpl_id);
 H5_DLL herr_t H5L_get_info(const H5G_loc_t *loc, const char *name,
     H5L_info_t *linkbuf/*out*/, hid_t lapl_id, hid_t dxpl_id);
 H5_DLL herr_t H5L_delete(H5G_loc_t *loc, const char *name, hid_t lapl_id,
diff --git a/src/H5MM.c b/src/H5MM.c
index a37bbff..09e6461 100644
--- a/src/H5MM.c
+++ b/src/H5MM.c
@@ -25,9 +25,225 @@
  */
 
 
-#include "H5private.h"
-#include "H5Eprivate.h"
-#include "H5MMprivate.h"
+/****************/
+/* Module Setup */
+/****************/
+
+
+/***********/
+/* Headers */
+/***********/
+#include "H5private.h"		/* Generic Functions			*/
+#include "H5Eprivate.h"		/* Error handling		  	*/
+#include "H5MMprivate.h"	/* Memory management			*/
+
+
+/****************/
+/* Local Macros */
+/****************/
+#if defined H5_MEMORY_ALLOC_SANITY_CHECK
+#define H5MM_SIG_SIZE           4
+#define H5MM_HEAD_GUARD_SIZE    8
+#define H5MM_TAIL_GUARD_SIZE    8
+#define H5MM_BLOCK_FROM_BUF(mem) ((H5MM_block_t *)((unsigned char *)mem - (offsetof(H5MM_block_t, b) + H5MM_HEAD_GUARD_SIZE)))
+#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
+
+
+/******************/
+/* Local Typedefs */
+/******************/
+
+#if defined H5_MEMORY_ALLOC_SANITY_CHECK
+/* Memory allocation "block", wrapped around each allocation */
+struct H5MM_block_t;    /* Forward declaration for typedef */
+typedef struct H5MM_block_t {
+    unsigned char sig[H5MM_SIG_SIZE];   /* Signature for the block, to indicate it was allocated with H5MM* interface */
+    struct H5MM_block_t *next;          /* Pointer to next block in the list of allocated blocks */
+    struct H5MM_block_t *prev;          /* Pointer to previous block in the list of allocated blocks */
+    union {
+        struct {
+            size_t size;                /* Size of allocated block */
+            hbool_t in_use;             /* Whether the block is in use or is free */
+        } info;
+        double _align;                  /* Align following buffer (b) to double boundary (unused) */
+    } u;
+    unsigned char b[];                  /* Buffer for caller (includes header and footer) */
+} H5MM_block_t;
+#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
+
+
+/********************/
+/* Local Prototypes */
+/********************/
+#if defined H5_MEMORY_ALLOC_SANITY_CHECK
+static hbool_t H5MM__is_our_block(void *mem);
+static void H5MM__sanity_check_block(const H5MM_block_t *block);
+static void H5MM__sanity_check(void *mem);
+#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
+
+
+/*********************/
+/* Package Variables */
+/*********************/
+
+
+/*****************************/
+/* Library Private Variables */
+/*****************************/
+
+
+/*******************/
+/* Local Variables */
+/*******************/
+
+#if defined H5_MEMORY_ALLOC_SANITY_CHECK
+/* Constant strings for block signature, head & tail guards */
+static const char H5MM_block_signature_s[H5MM_SIG_SIZE] = {'H', '5', 'M', 'M'};
+static const char H5MM_block_head_guard_s[H5MM_HEAD_GUARD_SIZE] = {'D', 'E', 'A', 'D', 'B', 'E', 'E', 'F'};
+static const char H5MM_block_tail_guard_s[H5MM_TAIL_GUARD_SIZE] = {'B', 'E', 'E', 'F', 'D', 'E', 'A', 'D'};
+
+/* Flag to indicate the the interface has been initialized */
+static hbool_t H5MM_init_s = FALSE;
+
+/* Head of the list of allocated blocks */
+static H5MM_block_t H5MM_block_head_s;
+
+/* Statistics about block allocations */
+static unsigned long long H5MM_total_alloc_bytes_s = 0;
+static unsigned long long H5MM_curr_alloc_bytes_s = 0;
+static unsigned long long H5MM_peak_alloc_bytes_s = 0;
+static size_t H5MM_max_block_size_s = 0;
+static size_t H5MM_total_alloc_blocks_count_s = 0;
+static size_t H5MM_curr_alloc_blocks_count_s = 0;
+static size_t H5MM_peak_alloc_blocks_count_s = 0;
+#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
+
+
+#if defined H5_MEMORY_ALLOC_SANITY_CHECK
+
+/*-------------------------------------------------------------------------
+ * Function:    H5MM__is_our_block
+ *
+ * Purpose:     Try to determine if a memory buffer has been allocated through
+ *		the H5MM* interface, instead of the system's malloc() routines.
+ *
+ * Return:	Success:    TRUE/FALSE
+ *		Failure:    (Can't fail)
+ *
+ * Programmer:  Quincey Koziol
+ *              Dec 30 2015
+ *
+ *-------------------------------------------------------------------------
+ */
+static hbool_t
+H5MM__is_our_block(void *mem)
+{
+    H5MM_block_t *block = H5MM_BLOCK_FROM_BUF(mem);
+
+    return(0 == HDmemcmp(block->sig, H5MM_block_signature_s, H5MM_SIG_SIZE));
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5MM__sanity_check_block
+ *
+ * Purpose:     Check a block wrapper around a buffer to validate it.
+ *
+ * Return:	N/A (void)
+ *
+ * Programmer:  Quincey Koziol
+ *              Dec 30 2015
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+H5MM__sanity_check_block(const H5MM_block_t *block)
+{
+    HDassert(block->u.info.size > 0);
+    HDassert(block->u.info.in_use);
+    /* Check for head & tail guards, if not head of linked list */
+    if(block->u.info.size != SIZET_MAX) {
+        HDassert(0 == HDmemcmp(block->b, H5MM_block_head_guard_s, H5MM_HEAD_GUARD_SIZE));
+        HDassert(0 == HDmemcmp(block->b + H5MM_HEAD_GUARD_SIZE + block->u.info.size, H5MM_block_tail_guard_s, H5MM_TAIL_GUARD_SIZE));
+    }
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5MM__sanity_check
+ *
+ * Purpose:     Check a buffer to validate it (just calls
+ *		H5MM__sanity_check_block after finding block for buffer)
+ *
+ * Return:	N/A (void)
+ *
+ * Programmer:  Quincey Koziol
+ *              Dec 30 2015
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+H5MM__sanity_check(void *mem)
+{
+    H5MM_block_t *block = H5MM_BLOCK_FROM_BUF(mem);
+
+    H5MM__sanity_check_block(block);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5MM_sanity_check_all
+ *
+ * Purpose:     Sanity check all current memory allocations.
+ *
+ * Return:	N/A (void)
+ *
+ * Programmer:  Quincey Koziol
+ *              Jan  5 2016
+ *
+ *-------------------------------------------------------------------------
+ */
+void
+H5MM_sanity_check_all(void)
+{
+    H5MM_block_t *curr;
+
+    curr = H5MM_block_head_s.next;
+    while(curr != &H5MM_block_head_s) {
+        H5MM__sanity_check_block(curr);
+        curr = curr->next;
+    } /* end while */
+} /* end H5MM_sanity_check_all() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5MM_final_sanity_check
+ *
+ * Purpose:     Final sanity checks on memory allocation.
+ *
+ * Return:	N/A (void)
+ *
+ * Programmer:  Quincey Koziol
+ *              Jan  1 2016
+ *
+ *-------------------------------------------------------------------------
+ */
+void
+H5MM_final_sanity_check(void)
+{
+    HDassert(0 == H5MM_curr_alloc_bytes_s);
+    HDassert(0 == H5MM_curr_alloc_blocks_count_s);
+    HDassert(H5MM_block_head_s.next == &H5MM_block_head_s);
+    HDassert(H5MM_block_head_s.prev == &H5MM_block_head_s);
+#ifdef H5MM_PRINT_MEMORY_STATS
+    HDfprintf(stderr, "%s: H5MM_total_alloc_bytes_s = %llu\n", __func__, H5MM_total_alloc_bytes_s);
+    HDfprintf(stderr, "%s: H5MM_peak_alloc_bytes_s = %llu\n", __func__, H5MM_peak_alloc_bytes_s);
+    HDfprintf(stderr, "%s: H5MM_max_block_size_s = %zu\n", __func__, H5MM_max_block_size_s);
+    HDfprintf(stderr, "%s: H5MM_total_alloc_blocks_count_s = %zu\n", __func__, H5MM_total_alloc_blocks_count_s);
+    HDfprintf(stderr, "%s: H5MM_peak_alloc_blocks_count_s = %zu\n", __func__, H5MM_peak_alloc_blocks_count_s);
+#endif /* H5MM_PRINT_MEMORY_STATS */
+}
+#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
 
 
 /*-------------------------------------------------------------------------
@@ -42,7 +258,6 @@
  *              bytes usually indicate problems.
  *  
  * Return:  Success:    Pointer new memory
- *
  *          Failure:	NULL
  *
  * Programmer:  Quincey Koziol
@@ -60,12 +275,61 @@ H5MM_malloc(size_t size)
     /* Use FUNC_ENTER_NOAPI_NOINIT_NOERR here to avoid performance issues */
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
-    if(size)
+#if defined H5_MEMORY_ALLOC_SANITY_CHECK
+    /* Initialize block list head singleton */
+    if(!H5MM_init_s) {
+        HDmemcpy(H5MM_block_head_s.sig, H5MM_block_signature_s, H5MM_SIG_SIZE);
+        H5MM_block_head_s.next = &H5MM_block_head_s;
+        H5MM_block_head_s.prev = &H5MM_block_head_s;
+        H5MM_block_head_s.u.info.size = SIZET_MAX;
+        H5MM_block_head_s.u.info.in_use = TRUE;
+
+        H5MM_init_s = TRUE;
+    } /* end if */
+#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
+
+    if(size) {
+#if defined H5_MEMORY_ALLOC_SANITY_CHECK
+        H5MM_block_t *block;
+        size_t alloc_size = sizeof(H5MM_block_t) + size + H5MM_HEAD_GUARD_SIZE + H5MM_TAIL_GUARD_SIZE;
+
+        if(NULL != (block = (H5MM_block_t *)HDmalloc(alloc_size))) {
+            /* Set up block */
+            HDmemcpy(block->sig, H5MM_block_signature_s, H5MM_SIG_SIZE);
+            block->next = H5MM_block_head_s.next;
+            H5MM_block_head_s.next = block;
+            block->next->prev = block;
+            block->prev = &H5MM_block_head_s;
+            block->u.info.size = size;
+            block->u.info.in_use = TRUE;
+            HDmemcpy(block->b, H5MM_block_head_guard_s, H5MM_HEAD_GUARD_SIZE);
+            HDmemcpy(block->b + H5MM_HEAD_GUARD_SIZE + size, H5MM_block_tail_guard_s, H5MM_TAIL_GUARD_SIZE);
+
+            /* Update statistics */
+            H5MM_total_alloc_bytes_s += size;
+            H5MM_curr_alloc_bytes_s += size;
+            if(H5MM_curr_alloc_bytes_s > H5MM_peak_alloc_bytes_s)
+                H5MM_peak_alloc_bytes_s = H5MM_curr_alloc_bytes_s;
+            if(size > H5MM_max_block_size_s)
+                H5MM_max_block_size_s = size;
+            H5MM_total_alloc_blocks_count_s++;
+            H5MM_curr_alloc_blocks_count_s++;
+            if(H5MM_curr_alloc_blocks_count_s > H5MM_peak_alloc_blocks_count_s)
+                H5MM_peak_alloc_blocks_count_s = H5MM_curr_alloc_blocks_count_s;
+
+            /* Set buffer to return */
+            ret_value = block->b + H5MM_HEAD_GUARD_SIZE;
+        } /* end if */
+        else
+            ret_value = NULL;
+#else /* H5_MEMORY_ALLOC_SANITY_CHECK */
         ret_value = HDmalloc(size);
+#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
+    } /* end if */
     else
         ret_value = NULL;
 
-    FUNC_LEAVE_NOAPI(ret_value);
+    FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5MM_malloc() */
 
 
@@ -83,7 +347,6 @@ H5MM_malloc(size_t size)
  *
  *
  * Return:  Success:    Pointer new memory
- *
  *          Failure:	NULL
  *
  * Programmer:	Quincey Koziol
@@ -101,12 +364,18 @@ H5MM_calloc(size_t size)
     /* Use FUNC_ENTER_NOAPI_NOINIT_NOERR here to avoid performance issues */
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
-    if(size)
+    if(size) {
+#if defined H5_MEMORY_ALLOC_SANITY_CHECK
+        if(NULL != (ret_value = H5MM_malloc(size)))
+            HDmemset(ret_value, 0, size);
+#else /* H5_MEMORY_ALLOC_SANITY_CHECK */
         ret_value = HDcalloc((size_t)1, size);
+#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
+    } /* end if */
     else
         ret_value = NULL;
 
-    FUNC_LEAVE_NOAPI(ret_value);
+    FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5MM_calloc() */
 
 
@@ -123,9 +392,7 @@ H5MM_calloc(size_t size)
  *              Note that the (NULL, 0) combination is undefined behavior
  *              in the C standard.
  *
- * Return:  Success:    Ptr to new memory if size > 0
- *                      NULL if size is zero
- *
+ * Return:  Success:    Ptr to new memory if size > 0, NULL if size is zero
  *          Failure:    NULL (input buffer is unchanged on failure)
  *
  * Programmer:  Robb Matzke
@@ -143,17 +410,39 @@ H5MM_realloc(void *mem, size_t size)
 
     HDassert(mem || size);
 
-    if(NULL == mem && 0 == size) {  
+    if(NULL == mem && 0 == size)
         /* Not defined in the standard, return NULL */
         ret_value = NULL;
-    }
     else {
+#if defined H5_MEMORY_ALLOC_SANITY_CHECK
+        if(size > 0) {
+            if(mem) {
+                if(H5MM__is_our_block(mem)) {
+                    H5MM_block_t *block = H5MM_BLOCK_FROM_BUF(mem);
+                    size_t old_size = block->u.info.size;
+
+                    H5MM__sanity_check(mem);
+
+                    ret_value = H5MM_malloc(size);
+                    HDmemcpy(ret_value, mem, MIN(size, old_size));
+                    H5MM_xfree(mem);
+                } /* end if */
+                else
+                    ret_value = HDrealloc(mem, size);
+            }
+            else
+                ret_value = H5MM_malloc(size);
+        }
+        else
+            ret_value = H5MM_xfree(mem);
+#else /* H5_MEMORY_ALLOC_SANITY_CHECK */
         ret_value = HDrealloc(mem, size);
 
         /* Some platforms do not return NULL if size is zero. */
         if(0 == size)
             ret_value = NULL;
-    }
+#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
+    } /* end else */
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5MM_realloc() */
@@ -250,8 +539,38 @@ H5MM_xfree(void *mem)
     /* Use FUNC_ENTER_NOAPI_NOINIT_NOERR here to avoid performance issues */
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
-    if(mem)
+    if(mem) {
+#if defined H5_MEMORY_ALLOC_SANITY_CHECK
+        if(H5MM__is_our_block(mem)) {
+            H5MM_block_t *block = H5MM_BLOCK_FROM_BUF(mem);
+
+            /* Run sanity checks on this block and its neighbors */
+            H5MM__sanity_check(mem);
+            H5MM__sanity_check_block(block->next);
+            H5MM__sanity_check_block(block->prev);
+
+            /* Update statistics */
+            H5MM_curr_alloc_bytes_s -= block->u.info.size;
+            H5MM_curr_alloc_blocks_count_s--;
+
+            /* Reset block info */
+            HDmemset(block->sig, 0, H5MM_SIG_SIZE);
+            block->next->prev = block->prev;
+            block->prev->next = block->next;
+            block->next = NULL;
+            block->prev = NULL;
+            block->u.info.in_use = FALSE;
+
+            /* Free the block (finally!) */
+            HDfree(block);
+        }
+        else
+            HDfree(mem);
+#else /* H5_MEMORY_ALLOC_SANITY_CHECK */
         HDfree(mem);
+#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
+    } /* end if */
 
-    FUNC_LEAVE_NOAPI(NULL);
+    FUNC_LEAVE_NOAPI(NULL)
 } /* end H5MM_xfree() */
+
diff --git a/src/H5MMprivate.h b/src/H5MMprivate.h
index 0d608b2..14bd28d 100644
--- a/src/H5MMprivate.h
+++ b/src/H5MMprivate.h
@@ -21,8 +21,6 @@
  *
  * Purpose:             Private header for memory management.
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 #ifndef _H5MMprivate_H
@@ -33,7 +31,12 @@
 /* Private headers needed by this file */
 #include "H5private.h"
 
+#if defined H5_MEMORY_ALLOC_SANITY_CHECK
+/*#define H5MM_PRINT_MEMORY_STATS */
+#define H5MM_free(Z)	H5MM_xfree(Z)
+#else /* H5_MEMORY_ALLOC_SANITY_CHECK */
 #define H5MM_free(Z)	HDfree(Z)
+#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
 
 /*
  * Library prototypes...
@@ -44,5 +47,10 @@ H5_DLL void *H5MM_realloc(void *mem, size_t size);
 H5_DLL char *H5MM_xstrdup(const char *s);
 H5_DLL char *H5MM_strdup(const char *s);
 H5_DLL void *H5MM_xfree(void *mem);
+#if defined H5_MEMORY_ALLOC_SANITY_CHECK
+H5_DLL void H5MM_sanity_check_all(void);
+H5_DLL void H5MM_final_sanity_check(void);
+#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
+
+#endif /* _H5MMprivate_H */
 
-#endif
diff --git a/src/H5Ocopy.c b/src/H5Ocopy.c
index 02c72e7..70dc560 100644
--- a/src/H5Ocopy.c
+++ b/src/H5Ocopy.c
@@ -213,10 +213,10 @@ H5Ocopy(hid_t src_loc_id, const char *src_name, hid_t dst_loc_id,
     /* for opening the destination object */
     H5G_name_t  src_path;               /* Opened source object hier. path */
     H5O_loc_t   src_oloc;               /* Opened source object object location */
+    htri_t      dst_exists;             /* Does destination name exist already? */
     hbool_t     loc_found = FALSE;      /* Location at 'name' found */
     hbool_t     obj_open = FALSE;       /* Entry at 'name' found */
-
-    herr_t      ret_value = SUCCEED;        /* Return value */
+    herr_t      ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE6("e", "i*si*sii", src_loc_id, src_name, dst_loc_id, dst_name,
@@ -233,22 +233,10 @@ H5Ocopy(hid_t src_loc_id, const char *src_name, hid_t dst_loc_id,
 	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no destination name specified")
 
     /* check if destination name already exists */
-    {
-        H5G_name_t  tmp_path;
-        H5O_loc_t   tmp_oloc;
-        H5G_loc_t   tmp_loc;
-
-        /* Set up group location */
-        tmp_loc.oloc = &tmp_oloc;
-        tmp_loc.path = &tmp_path;
-        H5G_loc_reset(&tmp_loc);
-
-        /* Check if object already exists in destination */
-        if(H5G_loc_find(&dst_loc, dst_name, &tmp_loc, H5P_DEFAULT, H5AC_ind_dxpl_id) >= 0) {
-            H5G_name_free(&tmp_path);
-            HGOTO_ERROR(H5E_SYM, H5E_EXISTS, FAIL, "destination object already exists")
-        } /* end if */
-    }
+    if((dst_exists = H5L_exists_tolerant(&dst_loc, dst_name, H5P_DEFAULT, H5AC_ind_dxpl_id)) < 0)
+	HGOTO_ERROR(H5E_OHDR, H5E_CANTGET, FAIL, "unable to check if destination name exists")
+    if(TRUE == dst_exists)
+        HGOTO_ERROR(H5E_OHDR, H5E_EXISTS, FAIL, "destination object already exists")
 
     /* Set up opened group location to fill in */
     src_loc.oloc = &src_oloc;
@@ -475,7 +463,7 @@ H5O_copy_header_real(const H5O_loc_t *oloc_src, H5O_loc_t *oloc_dst /*out*/,
     /* Allocate memory for "deleted" array.  This array marks the message in
      * the source that shouldn't be copied to the destination.
      */
-    if(NULL == (deleted = (hbool_t *)HDmalloc(sizeof(hbool_t) * oh_src->nmesgs)))
+    if(NULL == (deleted = (hbool_t *)H5MM_malloc(sizeof(hbool_t) * oh_src->nmesgs)))
         HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
     HDmemset(deleted, FALSE, sizeof(hbool_t) * oh_src->nmesgs);
 
@@ -882,7 +870,7 @@ H5O_copy_header_real(const H5O_loc_t *oloc_src, H5O_loc_t *oloc_dst /*out*/,
 done:
     /* Free deleted array */
     if(deleted)
-        HDfree(deleted);
+        H5MM_free(deleted);
 
     /* Release pointer to source object header and its derived objects */
     if(oh_src && H5O_unprotect(oloc_src, dxpl_id, oh_src, H5AC__NO_FLAGS_SET) < 0)
diff --git a/src/H5Oprivate.h b/src/H5Oprivate.h
index 0d77a83..9235d6c 100644
--- a/src/H5Oprivate.h
+++ b/src/H5Oprivate.h
@@ -506,10 +506,14 @@ typedef struct H5O_storage_t {
 typedef struct H5O_layout_chunk_t {
     unsigned	ndims;			/* Num dimensions in chunk           */
     uint32_t	dim[H5O_LAYOUT_NDIMS];	/* Size of chunk in elements         */
+    unsigned    enc_bytes_per_dim;      /* Encoded # of bytes for storing each chunk dimension */
     uint32_t    size;                   /* Size of chunk in bytes            */
     hsize_t     nchunks;                /* Number of chunks in dataset	     */
+    hsize_t     max_nchunks;                       /* Max. number of chunks in dataset	     */
     hsize_t     chunks[H5O_LAYOUT_NDIMS];          /* # of chunks in each dataset dimension  */
+    hsize_t     max_chunks[H5O_LAYOUT_NDIMS];      /* # of chunks in each dataset's max. dimension */
     hsize_t    	down_chunks[H5O_LAYOUT_NDIMS];     /* "down" size of number of chunks in each dimension */
+    hsize_t    	max_down_chunks[H5O_LAYOUT_NDIMS]; /* "down" size of number of chunks in each max dim */
 } H5O_layout_chunk_t;
 
 typedef struct H5O_layout_t {
diff --git a/src/H5PL.c b/src/H5PL.c
index 4c35c09..a196884 100644
--- a/src/H5PL.c
+++ b/src/H5PL.c
@@ -413,9 +413,9 @@ H5PL__init_path_table(void)
      */
     origin_dl_path = HDgetenv("HDF5_PLUGIN_PATH");
     if(NULL == origin_dl_path)
-        dl_path = HDstrdup(H5PL_DEFAULT_PATH);
+        dl_path = H5MM_strdup(H5PL_DEFAULT_PATH);
     else
-        dl_path = HDstrdup(origin_dl_path);
+        dl_path = H5MM_strdup(origin_dl_path);
     if(NULL == dl_path)
         HGOTO_ERROR(H5E_PLUGIN, H5E_CANTALLOC, FAIL, "can't allocate memory for path")
 
@@ -425,7 +425,7 @@ H5PL__init_path_table(void)
         /* Check for too many directories in path */
         if(H5PL_num_paths_g == H5PL_MAX_PATH_NUM)
             HGOTO_ERROR(H5E_PLUGIN, H5E_NOSPACE, FAIL, "too many directories in path for table")
-        if(NULL == (H5PL_path_table_g[H5PL_num_paths_g] = HDstrdup(dir)))
+        if(NULL == (H5PL_path_table_g[H5PL_num_paths_g] = H5MM_strdup(dir)))
             HGOTO_ERROR(H5E_PLUGIN, H5E_CANTALLOC, FAIL, "can't allocate memory for path")
         H5PL_num_paths_g++;
         dir = HDstrtok(NULL, H5PL_PATH_SEPARATOR);
diff --git a/src/H5Pdcpl.c b/src/H5Pdcpl.c
index afef06b..971394c 100644
--- a/src/H5Pdcpl.c
+++ b/src/H5Pdcpl.c
@@ -29,14 +29,14 @@
 /****************/
 
 #include "H5Pmodule.h"          /* This source code file is part of the H5P module */
+#define H5D_FRIEND		        /* Suppress error about including H5Dpkg	       */
 
 
 /***********/
 /* Headers */
 /***********/
 #include "H5private.h"		/* Generic Functions			*/
-#include "H5ACprivate.h"	/* Metadata cache			*/
-#include "H5Dprivate.h"		/* Datasets				*/
+#include "H5Dpkg.h"		/* Datasets 				*/
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5FLprivate.h"	/* Free Lists                           */
 #include "H5Iprivate.h"		/* IDs			  		*/
@@ -45,6 +45,7 @@
 #include "H5Ppkg.h"		/* Property lists		  	*/
 #include "H5Sprivate.h"         /* Dataspaces                           */
 #include "H5Tprivate.h"		/* Datatypes 				*/
+#include "H5VMprivate.h"	/* Vectors and arrays 			*/
 #include "H5Zprivate.h"		/* Data filters				*/
 
 
@@ -55,28 +56,28 @@
 /* Define default layout information */
 #define H5D_DEF_STORAGE_COMPACT_INIT  {(hbool_t)FALSE, (size_t)0, NULL}
 #define H5D_DEF_STORAGE_CONTIG_INIT   {HADDR_UNDEF, (hsize_t)0}
-#define H5D_DEF_STORAGE_CHUNK_INIT    {H5D_CHUNK_IDX_BTREE, HADDR_UNDEF,  NULL, {{HADDR_UNDEF, NULL}}}
-#define H5D_DEF_LAYOUT_CHUNK_INIT    {(unsigned)0, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, (uint32_t)0, (hsize_t)0, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}}
+#define H5D_DEF_STORAGE_CHUNK_INIT    {H5D_CHUNK_IDX_BTREE, HADDR_UNDEF, H5D_COPS_BTREE, {{HADDR_UNDEF, NULL}}}
+#define H5D_DEF_LAYOUT_CHUNK_INIT    {(unsigned)0, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, (unsigned)0, (uint32_t)0, (hsize_t)0, (hsize_t)0, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}}
 #define H5D_DEF_STORAGE_VIRTUAL_INIT  {{HADDR_UNDEF, 0}, 0, NULL, 0, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, H5D_VDS_ERROR, HSIZE_UNDEF, -1, -1, FALSE}
 #ifdef H5_HAVE_C99_DESIGNATED_INITIALIZER
 #define H5D_DEF_STORAGE_COMPACT  {H5D_COMPACT, { .compact = H5D_DEF_STORAGE_COMPACT_INIT }}
 #define H5D_DEF_STORAGE_CONTIG   {H5D_CONTIGUOUS, { .contig = H5D_DEF_STORAGE_CONTIG_INIT }}
 #define H5D_DEF_STORAGE_CHUNK    {H5D_CHUNKED, { .chunk = H5D_DEF_STORAGE_CHUNK_INIT }}
 #define H5D_DEF_STORAGE_VIRTUAL  {H5D_VIRTUAL, { .virt = H5D_DEF_STORAGE_VIRTUAL_INIT }}
-#define H5D_DEF_LAYOUT_COMPACT  {H5D_COMPACT, H5O_LAYOUT_VERSION_3, NULL, {H5D_DEF_LAYOUT_CHUNK_INIT}, H5D_DEF_STORAGE_COMPACT}
-#define H5D_DEF_LAYOUT_CONTIG   {H5D_CONTIGUOUS, H5O_LAYOUT_VERSION_3, NULL, {H5D_DEF_LAYOUT_CHUNK_INIT}, H5D_DEF_STORAGE_CONTIG}
-#define H5D_DEF_LAYOUT_CHUNK    {H5D_CHUNKED, H5O_LAYOUT_VERSION_3, NULL, {H5D_DEF_LAYOUT_CHUNK_INIT}, H5D_DEF_STORAGE_CHUNK}
-#define H5D_DEF_LAYOUT_VIRTUAL  {H5D_VIRTUAL, H5O_LAYOUT_VERSION_3, NULL, {H5D_DEF_LAYOUT_CHUNK_INIT}, H5D_DEF_STORAGE_VIRTUAL}
+#define H5D_DEF_LAYOUT_COMPACT  {H5D_COMPACT, H5O_LAYOUT_VERSION_DEFAULT, H5D_LOPS_COMPACT, {H5D_DEF_LAYOUT_CHUNK_INIT}, H5D_DEF_STORAGE_COMPACT}
+#define H5D_DEF_LAYOUT_CONTIG   {H5D_CONTIGUOUS, H5O_LAYOUT_VERSION_DEFAULT, H5D_LOPS_CONTIG, {H5D_DEF_LAYOUT_CHUNK_INIT}, H5D_DEF_STORAGE_CONTIG}
+#define H5D_DEF_LAYOUT_CHUNK    {H5D_CHUNKED, H5O_LAYOUT_VERSION_DEFAULT, H5D_LOPS_CHUNK, {H5D_DEF_LAYOUT_CHUNK_INIT}, H5D_DEF_STORAGE_CHUNK}
+#define H5D_DEF_LAYOUT_VIRTUAL  {H5D_VIRTUAL, H5O_LAYOUT_VERSION_4, H5D_LOPS_VIRTUAL, {H5D_DEF_LAYOUT_CHUNK_INIT}, H5D_DEF_STORAGE_VIRTUAL}
 #else /* H5_HAVE_C99_DESIGNATED_INITIALIZER */
 /* Note that the compact & chunked layout initialization values are using the
  *      contiguous layout initialization in the union, because the contiguous
  *      layout is first in the union.  These values are overridden in the
  *      H5P__init_def_layout() routine. -QAK
  */
-#define H5D_DEF_LAYOUT_COMPACT  {H5D_COMPACT, H5O_LAYOUT_VERSION_3, NULL, {H5D_DEF_LAYOUT_CHUNK_INIT}, {H5D_CONTIGUOUS, H5D_DEF_STORAGE_CONTIG_INIT}}
-#define H5D_DEF_LAYOUT_CONTIG   {H5D_CONTIGUOUS, H5O_LAYOUT_VERSION_3, NULL, {H5D_DEF_LAYOUT_CHUNK_INIT}, {H5D_CONTIGUOUS, H5D_DEF_STORAGE_CONTIG_INIT}}
-#define H5D_DEF_LAYOUT_CHUNK    {H5D_CHUNKED, H5O_LAYOUT_VERSION_3, NULL, {H5D_DEF_LAYOUT_CHUNK_INIT}, {H5D_CONTIGUOUS, H5D_DEF_STORAGE_CONTIG_INIT}}
-#define H5D_DEF_LAYOUT_VIRTUAL  {H5D_VIRTUAL, H5O_LAYOUT_VERSION_3, NULL, {H5D_DEF_LAYOUT_CHUNK_INIT}, {H5D_CONTIGUOUS, H5D_DEF_STORAGE_CONTIG_INIT}}
+#define H5D_DEF_LAYOUT_COMPACT  {H5D_COMPACT, H5O_LAYOUT_VERSION_DEFAULT, NULL, {H5D_DEF_LAYOUT_CHUNK_INIT}, {H5D_CONTIGUOUS, H5D_DEF_STORAGE_CONTIG_INIT}}
+#define H5D_DEF_LAYOUT_CONTIG   {H5D_CONTIGUOUS, H5O_LAYOUT_VERSION_DEFAULT, NULL, {H5D_DEF_LAYOUT_CHUNK_INIT}, {H5D_CONTIGUOUS, H5D_DEF_STORAGE_CONTIG_INIT}}
+#define H5D_DEF_LAYOUT_CHUNK    {H5D_CHUNKED, H5O_LAYOUT_VERSION_DEFAULT, NULL, {H5D_DEF_LAYOUT_CHUNK_INIT}, {H5D_CONTIGUOUS, H5D_DEF_STORAGE_CONTIG_INIT}}
+#define H5D_DEF_LAYOUT_VIRTUAL  {H5D_VIRTUAL, H5O_LAYOUT_VERSION_4, NULL, {H5D_DEF_LAYOUT_CHUNK_INIT}, {H5D_CONTIGUOUS, H5D_DEF_STORAGE_CONTIG_INIT}}
 #endif /* H5_HAVE_C99_DESIGNATED_INITIALIZER */
 
 /* ========  Dataset creation properties ======== */
@@ -288,7 +289,6 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5P__dcrt_layout_set(hid_t H5_ATTR_UNUSED prop_id, const char H5_ATTR_UNUSED *name,
     size_t H5_ATTR_UNUSED size, void *value)
@@ -1998,6 +1998,7 @@ H5Pset_chunk(hid_t plist_id, int ndims, const hsize_t dim[/*ndims*/])
     H5P_genplist_t *plist;      /* Property list pointer */
     H5O_layout_t chunk_layout;  /* Layout information for setting chunk info */
     uint64_t chunk_nelmts;      /* Number of elements in chunk */
+    unsigned max_enc_bytes_per_dim;     /* Max. number of bytes required to encode this dimension */
     unsigned u;                 /* Local index variable */
     herr_t ret_value = SUCCEED; /* Return value */
 
@@ -2025,7 +2026,10 @@ H5Pset_chunk(hid_t plist_id, int ndims, const hsize_t dim[/*ndims*/])
     HDmemcpy(&chunk_layout, &H5D_def_layout_chunk_g, sizeof(H5D_def_layout_chunk_g));
     HDmemset(&chunk_layout.u.chunk.dim, 0, sizeof(chunk_layout.u.chunk.dim));
     chunk_nelmts = 1;
+    max_enc_bytes_per_dim = 0;
     for(u = 0; u < (unsigned)ndims; u++) {
+        unsigned enc_bytes_per_dim;     /* Number of bytes required to encode this dimension */
+
         if(dim[u] == 0)
             HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "all chunk dimensions must be positive")
         if(dim[u] != (dim[u] & 0xffffffff))
@@ -2034,7 +2038,16 @@ H5Pset_chunk(hid_t plist_id, int ndims, const hsize_t dim[/*ndims*/])
         if(chunk_nelmts > (uint64_t)0xffffffff)
             HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "number of elements in chunk must be < 4GB")
         chunk_layout.u.chunk.dim[u] = (uint32_t)dim[u]; /* Store user's chunk dimensions */
+
+        /* Get encoded size of dim, in bytes */
+        enc_bytes_per_dim = (H5VM_log2_gen(dim[u]) + 8) / 8;
+
+        /* Check if this is the largest value so far */
+        if(enc_bytes_per_dim > max_enc_bytes_per_dim)
+            max_enc_bytes_per_dim = enc_bytes_per_dim;
     } /* end for */
+    HDassert(max_enc_bytes_per_dim > 0 && max_enc_bytes_per_dim <= 8);
+    chunk_layout.u.chunk.enc_bytes_per_dim = max_enc_bytes_per_dim;
 
     /* Get the plist structure */
     if(NULL == (plist = H5P_object_verify(plist_id, H5P_DATASET_CREATE)))
@@ -2214,9 +2227,9 @@ H5Pset_virtual(hid_t dcpl_id, hid_t vspace_id, const char *src_file_name,
     HDmemset(ent, 0, sizeof(H5O_storage_virtual_ent_t));        /* Clear before starting to set up */
     if(NULL == (ent->source_dset.virtual_select = H5S_copy(vspace, FALSE, TRUE)))
         HGOTO_ERROR(H5E_PLIST, H5E_CANTCOPY, FAIL, "unable to copy virtual selection")
-    if(NULL == (ent->source_file_name = HDstrdup(src_file_name)))
+    if(NULL == (ent->source_file_name = H5MM_xstrdup(src_file_name)))
         HGOTO_ERROR(H5E_PLIST, H5E_RESOURCE, FAIL, "can't duplicate source file name")
-    if(NULL == (ent->source_dset_name = HDstrdup(src_dset_name)))
+    if(NULL == (ent->source_dset_name = H5MM_xstrdup(src_dset_name)))
         HGOTO_ERROR(H5E_PLIST, H5E_RESOURCE, FAIL, "can't duplicate source file name")
     if(NULL == (ent->source_select = H5S_copy(src_space, FALSE, TRUE)))
         HGOTO_ERROR(H5E_PLIST, H5E_CANTCOPY, FAIL, "unable to copy source selection")
diff --git a/src/H5Pdxpl.c b/src/H5Pdxpl.c
index 59b3188..1181c16 100644
--- a/src/H5Pdxpl.c
+++ b/src/H5Pdxpl.c
@@ -872,7 +872,6 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5P__dxfr_xform_del(hid_t H5_ATTR_UNUSED prop_id, const char H5_ATTR_UNUSED *name, size_t H5_ATTR_UNUSED size, void *value)
 {
@@ -904,7 +903,6 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5P__dxfr_xform_copy(const char H5_ATTR_UNUSED *name, size_t H5_ATTR_UNUSED size, void *value)
 {
@@ -991,7 +989,6 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5P__dxfr_xform_close(const char H5_ATTR_UNUSED *name, size_t H5_ATTR_UNUSED size, void *value)
 {
diff --git a/src/H5Plapl.c b/src/H5Plapl.c
index b311238..0d5507a 100644
--- a/src/H5Plapl.c
+++ b/src/H5Plapl.c
@@ -463,7 +463,6 @@ done:
  *
  *--------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5P__lacc_elink_fapl_del(hid_t H5_ATTR_UNUSED prop_id, const char H5_ATTR_UNUSED *name, size_t H5_ATTR_UNUSED size, void *value)
 {
@@ -500,7 +499,6 @@ done:
  *
  *--------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5P__lacc_elink_fapl_copy(const char H5_ATTR_UNUSED *name, size_t H5_ATTR_UNUSED size, void *value)
 {
@@ -590,7 +588,6 @@ done:
  *
  *---------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5P__lacc_elink_fapl_close(const char H5_ATTR_UNUSED *name, size_t H5_ATTR_UNUSED size, void *value)
 {
@@ -797,7 +794,6 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5P__lacc_elink_pref_del(hid_t H5_ATTR_UNUSED prop_id, const char H5_ATTR_UNUSED *name, size_t H5_ATTR_UNUSED size, void *value)
 {
@@ -823,7 +819,6 @@ H5P__lacc_elink_pref_del(hid_t H5_ATTR_UNUSED prop_id, const char H5_ATTR_UNUSED
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5P__lacc_elink_pref_copy(const char H5_ATTR_UNUSED *name, size_t H5_ATTR_UNUSED size, void *value)
 {
@@ -884,7 +879,6 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5P__lacc_elink_pref_close(const char H5_ATTR_UNUSED *name, size_t H5_ATTR_UNUSED size, void *value)
 {
diff --git a/src/H5Pocpypl.c b/src/H5Pocpypl.c
index 7657d52..faa2a04 100644
--- a/src/H5Pocpypl.c
+++ b/src/H5Pocpypl.c
@@ -497,7 +497,6 @@ done:
  *
  *--------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5P__ocpy_merge_comm_dt_list_del(hid_t H5_ATTR_UNUSED prop_id, const char H5_ATTR_UNUSED *name,
     size_t H5_ATTR_UNUSED size, void *value)
@@ -527,7 +526,6 @@ H5P__ocpy_merge_comm_dt_list_del(hid_t H5_ATTR_UNUSED prop_id, const char H5_ATT
  *
  *--------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5P__ocpy_merge_comm_dt_list_copy(const char H5_ATTR_UNUSED *name, size_t H5_ATTR_UNUSED size,
     void *value)
@@ -616,7 +614,6 @@ done:
  *
  *---------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5P__ocpy_merge_comm_dt_list_close(const char H5_ATTR_UNUSED *name, size_t H5_ATTR_UNUSED size, void *value)
 {
diff --git a/src/H5SM.c b/src/H5SM.c
index 4a562dd..413ad1f 100644
--- a/src/H5SM.c
+++ b/src/H5SM.c
@@ -1375,11 +1375,23 @@ H5SM_write_mesg(H5F_t *f, hid_t dxpl_id, H5O_t *open_oh,
         } /* end else */
     } /* end else */
 
-    if(found)
+    if(found) {
         /* If the message was found, it's shared in the heap (now).  Set up a
          * shared message so we can mark it as shared.
          */
         shared.type = H5O_SHARE_TYPE_SOHM;
+
+#ifdef H5_USING_MEMCHECKER
+        /* Reset the shared message payload if deferring.  This doesn't matter
+         *      in the long run since the payload will get overwritten when the
+         *      non-deferred call to this routine occurs, but it stops memory
+         *      checkers like valgrind from whining when the partially initialized
+         *      shared message is serialized. -QAK
+         */
+        if(defer)
+            HDmemset(&shared.u, 0, sizeof(shared.u));
+#endif /* H5_USING_MEMCHECKER */
+    } /* end if */
     else {
         htri_t share_in_ohdr;           /* Whether the new message can be shared in another object's header */
 
diff --git a/src/H5SMbtree2.c b/src/H5SMbtree2.c
index e533ae8..0110c1e 100644
--- a/src/H5SMbtree2.c
+++ b/src/H5SMbtree2.c
@@ -50,7 +50,6 @@ static herr_t H5SM__bt2_dst_context(void *ctx);
 static herr_t H5SM__bt2_store(void *native, const void *udata);
 static herr_t H5SM__bt2_debug(FILE *stream, int indent, int fwidth,
     const void *record, const void *_udata);
-static void *H5SM__bt2_crt_dbg_context(H5F_t *f, hid_t dxpl_id, haddr_t addr);
 
 
 /*****************************/
@@ -67,9 +66,7 @@ const H5B2_class_t H5SM_INDEX[1]={{   /* B-tree class information */
     H5SM__message_compare,            /* Record comparison callback */
     H5SM__message_encode,             /* Record encoding callback */
     H5SM__message_decode,             /* Record decoding callback */
-    H5SM__bt2_debug,                  /* Record debugging callback */
-    H5SM__bt2_crt_dbg_context,	      /* Create debugging context */
-    H5SM__bt2_dst_context 	      /* Destroy debugging context */
+    H5SM__bt2_debug                   /* Record debugging callback */
 }};
 
 
@@ -218,45 +215,6 @@ H5SM__bt2_debug(FILE *stream, int indent, int fwidth,
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5SM__bt2_crt_dbg_context
- *
- * Purpose:	Create context for debugging callback
- *
- * Return:	Success:	non-NULL
- *		Failure:	NULL
- *
- * Programmer:	Quincey Koziol
- *              Tuesday, December 1, 2009
- *
- *-------------------------------------------------------------------------
- */
-static void *
-H5SM__bt2_crt_dbg_context(H5F_t *f, hid_t H5_ATTR_UNUSED dxpl_id, haddr_t H5_ATTR_UNUSED addr)
-{
-    H5SM_bt2_ctx_t *ctx;        /* Callback context structure */
-    void *ret_value = NULL;     /* Return value */
-
-    FUNC_ENTER_STATIC
-
-    /* Sanity check */
-    HDassert(f);
-
-    /* Allocate callback context */
-    if(NULL == (ctx = H5FL_MALLOC(H5SM_bt2_ctx_t)))
-        HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, NULL, "can't allocate callback context")
-
-    /* Determine the size of addresses & lengths in the file */
-    ctx->sizeof_addr = H5F_SIZEOF_ADDR(f);
-
-    /* Set return value */
-    ret_value = ctx;
-
-done:
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* H5SM__bt2_crt_dbg_context() */
-
-
-/*-------------------------------------------------------------------------
  * Function:	H5SM_bt2_convert_to_list_op
  *
  * Purpose:	An H5B2_remove_t callback function to convert a SOHM
diff --git a/src/H5TS.c b/src/H5TS.c
index 987bead..6a64a14 100644
--- a/src/H5TS.c
+++ b/src/H5TS.c
@@ -255,19 +255,18 @@ H5TS_cancel_count_inc(void)
 
     if (!cancel_counter) {
         /*
-   * First time thread calls library - create new counter and associate
+         * First time thread calls library - create new counter and associate
          * with key
          */
-  cancel_counter = (H5TS_cancel_t *)H5MM_calloc(sizeof(H5TS_cancel_t));
+        cancel_counter = (H5TS_cancel_t *)HDcalloc(1, sizeof(H5TS_cancel_t));
 
-  if (!cancel_counter) {
-      H5E_push_stack(NULL, "H5TS_cancel_count_inc",
-         __FILE__, __LINE__, H5E_ERR_CLS_g, H5E_RESOURCE, H5E_NOSPACE, "memory allocation failed");
-      return FAIL;
-  }
+        if (!cancel_counter) {
+            H5E_push_stack(NULL, "H5TS_cancel_count_inc", __FILE__, __LINE__,
+                H5E_ERR_CLS_g, H5E_RESOURCE, H5E_NOSPACE, "memory allocation failed");
+            return FAIL;
+        }
 
-        ret_value = pthread_setspecific(H5TS_cancel_key_g,
-          (void *)cancel_counter);
+        ret_value = pthread_setspecific(H5TS_cancel_key_g, (void *)cancel_counter);
     }
 
     if (cancel_counter->cancel_count == 0)
diff --git a/src/H5Tvlen.c b/src/H5Tvlen.c
index 26346d6..0ed8209 100644
--- a/src/H5Tvlen.c
+++ b/src/H5Tvlen.c
@@ -365,7 +365,6 @@ H5T_vlen_seq_mem_getptr(void *_vl)
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static htri_t
 H5T_vlen_seq_mem_isnull(const H5F_t H5_ATTR_UNUSED *f, void *_vl)
 {
@@ -403,7 +402,6 @@ H5T_vlen_seq_mem_isnull(const H5F_t H5_ATTR_UNUSED *f, void *_vl)
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5T_vlen_seq_mem_read(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id, void *_vl, void *buf, size_t len)
 {
@@ -445,7 +443,6 @@ H5T_vlen_seq_mem_read(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id, voi
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5T_vlen_seq_mem_write(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id, const H5T_vlen_alloc_info_t *vl_alloc_info, void *_vl, void *buf, void H5_ATTR_UNUSED *_bg, size_t seq_len, size_t base_size)
 {
@@ -468,7 +465,7 @@ H5T_vlen_seq_mem_write(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id, co
                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for VL data")
           } /* end if */
         else {  /* Default to system malloc */
-            if(NULL==(vl.p=H5MM_malloc(len)))
+            if(NULL == (vl.p = HDmalloc(len)))
                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for VL data")
           } /* end else */
 
@@ -502,7 +499,6 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5T_vlen_seq_mem_setnull(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id, void *_vl, void H5_ATTR_UNUSED *_bg)
 {
@@ -606,7 +602,6 @@ H5T_vlen_str_mem_getptr(void *_vl)
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static htri_t
 H5T_vlen_str_mem_isnull(const H5F_t H5_ATTR_UNUSED *f, void *_vl)
 {
@@ -638,7 +633,6 @@ H5T_vlen_str_mem_isnull(const H5F_t H5_ATTR_UNUSED *f, void *_vl)
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5T_vlen_str_mem_read(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id, void *_vl, void *buf, size_t len)
 {
@@ -679,7 +673,6 @@ H5T_vlen_str_mem_read(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id, voi
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5T_vlen_str_mem_write(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id, const H5T_vlen_alloc_info_t *vl_alloc_info, void *_vl, void *buf, void H5_ATTR_UNUSED *_bg, size_t seq_len, size_t base_size)
 {
@@ -698,7 +691,7 @@ H5T_vlen_str_mem_write(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id, co
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for VL data")
       } /* end if */
     else {  /* Default to system malloc */
-        if(NULL==(t = (char *)H5MM_malloc((seq_len+1)*base_size)))
+        if(NULL == (t = (char *)HDmalloc((seq_len + 1) * base_size)))
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for VL data")
       } /* end else */
 
@@ -726,7 +719,6 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5T_vlen_str_mem_setnull(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id, void *_vl, void H5_ATTR_UNUSED *_bg)
 {
@@ -782,7 +774,6 @@ H5T_vlen_disk_getlen(const void *_vl)
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static void *
 H5T_vlen_disk_getptr(void H5_ATTR_UNUSED *vl)
 {
@@ -840,7 +831,6 @@ H5T_vlen_disk_isnull(const H5F_t *f, void *_vl)
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5T_vlen_disk_read(H5F_t *f, hid_t dxpl_id, void *_vl, void *buf, size_t H5_ATTR_UNUSED len)
 {
@@ -886,7 +876,6 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5T_vlen_disk_write(H5F_t *f, hid_t dxpl_id, const H5T_vlen_alloc_info_t H5_ATTR_UNUSED *vl_alloc_info,
     void *_vl, void *buf, void *_bg, size_t seq_len, size_t base_size)
@@ -1084,14 +1073,14 @@ H5T_vlen_reclaim_recurse(void *elem, const H5T_t *dt, H5MM_free_t free_func, voi
                     if(free_func != NULL)
                         (*free_func)(vl->p, free_info);
                     else
-                        H5MM_xfree(vl->p);
+                        HDfree(vl->p);
                 } /* end if */
             } else if(dt->shared->u.vlen.type == H5T_VLEN_STRING) {
                 /* Free the VL string */
                 if(free_func != NULL)
                     (*free_func)(*(char **)elem, free_info);
                 else
-                    H5MM_xfree(*(char **)elem);
+                    HDfree(*(char **)elem);
             } else {
                 HDassert(0 && "Invalid VL type");
             } /* end else */
@@ -1146,7 +1135,6 @@ done:
  EXAMPLES
  REVISION LOG
 --------------------------------------------------------------------------*/
-/* ARGSUSED */
 herr_t
 H5T_vlen_reclaim(void *elem, hid_t type_id, unsigned H5_ATTR_UNUSED ndim, const hsize_t H5_ATTR_UNUSED *point, void *op_data)
 {
diff --git a/src/H5Zfletcher32.c b/src/H5Zfletcher32.c
index 690d7a2..9ff85cc 100644
--- a/src/H5Zfletcher32.c
+++ b/src/H5Zfletcher32.c
@@ -70,7 +70,6 @@ const H5Z_class2_t H5Z_FLETCHER32[1] = {{
  *              with Release 1.6.2 and before.
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static size_t
 H5Z_filter_fletcher32 (unsigned flags, size_t H5_ATTR_UNUSED cd_nelmts, const unsigned H5_ATTR_UNUSED cd_values[],
                      size_t nbytes, size_t *buf_size, void **buf)
diff --git a/src/H5Zshuffle.c b/src/H5Zshuffle.c
index 3fa6c8d..4cf6adf 100644
--- a/src/H5Zshuffle.c
+++ b/src/H5Zshuffle.c
@@ -61,7 +61,6 @@ const H5Z_class2_t H5Z_SHUFFLE[1] = {{
  *
  *-------------------------------------------------------------------------
  */
-/* ARGSUSED */
 static herr_t
 H5Z_set_local_shuffle(hid_t dcpl_id, hid_t type_id, hid_t H5_ATTR_UNUSED space_id)
 {
diff --git a/src/H5Ztrans.c b/src/H5Ztrans.c
index 0a9a4da..2627a29 100644
--- a/src/H5Ztrans.c
+++ b/src/H5Ztrans.c
@@ -1032,7 +1032,7 @@ H5Z_xform_eval(H5Z_data_xform_t *data_xform_prop, void* array, size_t array_size
         /* Free the temporary arrays we used */
         if(data_xform_prop->dat_val_pointers->num_ptrs > 1)
             for(i=0; i<data_xform_prop->dat_val_pointers->num_ptrs; i++)
-                HDfree(data_xform_prop->dat_val_pointers->ptr_dat_val[i]);
+                H5MM_xfree(data_xform_prop->dat_val_pointers->ptr_dat_val[i]);
     } /* end else */
 
 done:
@@ -1042,7 +1042,7 @@ done:
 	if(data_xform_prop->dat_val_pointers->num_ptrs > 1)
 	    for(i = 0; i < data_xform_prop->dat_val_pointers->num_ptrs; i++)
 		if(data_xform_prop->dat_val_pointers->ptr_dat_val[i])
-		    HDfree(data_xform_prop->dat_val_pointers->ptr_dat_val[i]);
+		    H5MM_xfree(data_xform_prop->dat_val_pointers->ptr_dat_val[i]);
     } /* end if */
 
     FUNC_LEAVE_NOAPI(ret_value)
diff --git a/src/H5public.h b/src/H5public.h
index 5b95fb7..554ad26 100644
--- a/src/H5public.h
+++ b/src/H5public.h
@@ -94,10 +94,10 @@ extern "C" {
 /* Version numbers */
 #define H5_VERS_MAJOR	1	/* For major interface/format changes  	     */
 #define H5_VERS_MINOR	9	/* For minor interface/format changes  	     */
-#define H5_VERS_RELEASE	233	/* For tweaks, bug-fixes, or development     */
+#define H5_VERS_RELEASE	234	/* For tweaks, bug-fixes, or development     */
 #define H5_VERS_SUBRELEASE ""	/* For pre-releases like snap0       */
 				/* Empty string for real releases.           */
-#define H5_VERS_INFO    "HDF5 library version: 1.9.233"      /* Full version string */
+#define H5_VERS_INFO    "HDF5 library version: 1.9.234"      /* Full version string */
 
 #define H5check()	H5check_version(H5_VERS_MAJOR,H5_VERS_MINOR,	      \
 				        H5_VERS_RELEASE)
diff --git a/src/libhdf5.settings.in b/src/libhdf5.settings.in
index 2355543..90224c1 100644
--- a/src/libhdf5.settings.in
+++ b/src/libhdf5.settings.in
@@ -66,6 +66,7 @@ Features:
                         dmalloc: @HAVE_DMALLOC@
 Clear file buffers before write: @CLEARFILEBUF@
            Using memory checker: @USINGMEMCHECKER@
+Memory allocation sanity checks: @MEMORYALLOCSANITYCHECK@
          Function Stack Tracing: @CODESTACK@
       Strict File Format Checks: @STRICT_FORMAT_CHECKS@
    Optimization Instrumentation: @INSTRUMENT@
diff --git a/test/Makefile.am b/test/Makefile.am
index d9c53d4..8389cc4 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -37,16 +37,14 @@ check_SCRIPTS = $(TEST_SCRIPT)
 # executed, generally most specific tests to least specific tests.
 # As an exception, long-running tests should occur earlier in the list.
 # This gives them more time to run when tests are executing in parallel.
-# These tests (fheap, btree2) are under development and are not used by
-# the library yet. Move them to the end so that their failure do not block
-# other current library code tests.
-TEST_PROG= testhdf5 lheap ohdr stab gheap cache cache_api cache_tagging \
+TEST_PROG= testhdf5 cache cache_api cache_tagging lheap ohdr stab gheap \
+           farray earray btree2 fheap \
            pool accum hyperslab istore bittests dt_arith \
            dtypes dsets cmpd_dset filter_fail extend external efc objcopy links unlink \
            big mtime fillval mount flush1 flush2 app_ref enum \
            set_extent ttsafe enc_dec_plist enc_dec_plist_cross_platform\
            getname vfd ntypes dangle dtransform reserved cross_read \
-           freespace mf vds farray earray btree2 fheap file_image unregister
+           freespace mf vds file_image unregister
 
 # List programs to be built when testing here. error_test and err_compat are
 # built at the same time as the other tests, but executed by testerror.sh.
@@ -145,9 +143,9 @@ CHECK_CLEANFILES+=accum.h5 cmpd_dset.h5 compact_dataset.h5 dataset.h5 dset_offse
     multi_file-[rs].h5 core_file plugin.h5 \
     new_move_[ab].h5 ntypes.h5 dangle.h5 error_test.h5 err_compat.h5 \
     dtransform.h5 test_filters.h5 get_file_name.h5 tstint[1-2].h5    \
-    unlink_chunked.h5 btree2.h5 objcopy_src.h5 objcopy_dst.h5        \
-    objcopy_ext.dat trefer1.h5 trefer2.h5 app_ref.h5 farray.h5       \
-    earray.h5 efc[0-5].h5 log_vfd_out.log                            \
+    unlink_chunked.h5 btree2.h5 btree2_tmp.h5 objcopy_src.h5 objcopy_dst.h5 \
+    objcopy_ext.dat trefer1.h5 trefer2.h5 app_ref.h5 farray.h5 farray_tmp.h5 \
+    earray.h5 earray_tmp.h5 efc[0-5].h5 log_vfd_out.log              \
     new_multi_file_v16-r.h5 new_multi_file_v16-s.h5                  \
     split_get_file_image_test-m.h5 split_get_file_image_test-r.h5    \
     file_image_core_test.h5.copy unregister_filter_1.h5 unregister_filter_2.h5 \
diff --git a/test/accum.c b/test/accum.c
index 268b7e1..edfc751 100644
--- a/test/accum.c
+++ b/test/accum.c