[svn-r19378] Modifications to using v2 B-tree as index for chunked datasets with >1 unlimited dimensions.

h5committested.

18 files changed, 2070 insertions, 62 deletions

diff --git a/src/H5B2.c b/src/H5B2.c
index 0ed90a4..d31f0cf 100644
--- a/src/H5B2.c
+++ b/src/H5B2.c
@@ -82,6 +82,8 @@ 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 H5D_BT2[1];
+extern const H5B2_class_t H5D_BT2_FILT[1];
 
 const H5B2_class_t *const H5B2_client_class_g[] = {
     H5B2_TEST,			/* 0 - H5B2_TEST_ID 			*/
@@ -90,10 +92,12 @@ const H5B2_class_t *const H5B2_client_class_g[] = {
     H5HF_HUGE_BT2_DIR,		/* 3 - H5B2_FHEAP_HUGE_DIR_ID 		*/
     H5HF_HUGE_BT2_FILT_DIR,	/* 4 - H5B2_FHEAP_HUGE_FILT_DIR_ID 	*/
     H5G_BT2_NAME,		/* 5 - H5B2_GRP_DENSE_NAME_ID 		*/
-    H5G_BT2_CORDER,		/* 6 - H5B2_GRP_DENSE_CORDER_ID 		*/
+    H5G_BT2_CORDER,		/* 6 - H5B2_GRP_DENSE_CORDER_ID 	*/
     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 		*/
+    H5A_BT2_CORDER,		/* 9 - H5B2_ATTR_DENSE_CORDER_ID 	*/
+    H5D_BT2,              	/* 10 - H5B2_CDSET_ID 			*/
+    H5D_BT2_FILT		/* 11 - H5B2_CDSET_FILT_ID 		*/
 };
 
 
diff --git a/src/H5B2dbg.c b/src/H5B2dbg.c
index cf7301d..1199edf 100644
--- a/src/H5B2dbg.c
+++ b/src/H5B2dbg.c
@@ -84,11 +84,14 @@
  *		koziol@ncsa.uiuc.edu
  *		Feb  2 2005
  *
- *-------------------------------------------------------------------------
+ * Modifications:
+ *	Vailin Choi; August 2010
+ *	Created debugging context so that the header can be loaded correctly.
+ *--------------------------------------------------------------------------
  */
 herr_t
 H5B2_hdr_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE *stream, int indent, int fwidth,
-    const H5B2_class_t *type)
+    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 */
@@ -104,6 +107,7 @@ H5B2_hdr_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE *stream, int indent,
      */
     HDassert(f);
     HDassert(H5F_addr_defined(addr));
+    HDassert(H5F_addr_defined(obj_addr));
     HDassert(stream);
     HDassert(indent >= 0);
     HDassert(fwidth >= 0);
@@ -114,7 +118,7 @@ H5B2_hdr_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE *stream, int indent,
     /* 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, addr)))
+        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 */
 
@@ -198,11 +202,14 @@ done:
  *		koziol@ncsa.uiuc.edu
  *		Feb  4 2005
  *
+ * Modifications:
+ *	Vailin Choi; August 2010
+ *	Created debugging context so that the header can be loaded correctly.
  *-------------------------------------------------------------------------
  */
 herr_t
 H5B2_int_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE *stream, int indent, int fwidth,
-    const H5B2_class_t *type, haddr_t hdr_addr, unsigned nrec, unsigned depth)
+    const H5B2_class_t *type, haddr_t hdr_addr, unsigned nrec, unsigned depth, haddr_t obj_addr)
 {
     H5B2_hdr_t	*hdr = NULL;            /* B-tree header */
     H5B2_internal_t	*internal = NULL;   /* B-tree internal node */
@@ -226,12 +233,13 @@ H5B2_int_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE *stream, int indent,
     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, addr)))
+        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 */
 
@@ -292,7 +300,7 @@ H5B2_int_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE *stream, int indent,
                   temp_str);
         HDassert(H5B2_INT_NREC(internal, hdr, u));
         (void)(type->debug)(stream, f, dxpl_id, indent + 6, MAX (0, fwidth-6),
-            H5B2_INT_NREC(internal, hdr, u), NULL);
+            H5B2_INT_NREC(internal, hdr, u), dbg_ctx);
     } /* end for */
 
     /* Print final node pointer */
@@ -329,11 +337,14 @@ done:
  *		koziol@ncsa.uiuc.edu
  *		Feb  7 2005
  *
+ * Modifications:
+ *	Vailin Choi; August 2010
+ *	Created debugging context so that the header can be loaded correctly.
  *-------------------------------------------------------------------------
  */
 herr_t
 H5B2_leaf_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE *stream, int indent, int fwidth,
-    const H5B2_class_t *type, haddr_t hdr_addr, unsigned nrec)
+    const H5B2_class_t *type, haddr_t hdr_addr, unsigned nrec, haddr_t obj_addr)
 {
     H5B2_hdr_t	*hdr = NULL;            /* B-tree header */
     H5B2_leaf_t	*leaf = NULL;           /* B-tree leaf node */
@@ -357,12 +368,13 @@ H5B2_leaf_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE *stream, int indent,
     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, addr)))
+        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 */
 
@@ -412,7 +424,7 @@ H5B2_leaf_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE *stream, int indent,
                   temp_str);
         HDassert(H5B2_LEAF_NREC(leaf, hdr, u));
         (void)(type->debug)(stream, f, dxpl_id, indent + 6, MAX (0, fwidth-6),
-            H5B2_LEAF_NREC(leaf, hdr, u), NULL);
+            H5B2_LEAF_NREC(leaf, hdr, u), dbg_ctx);
     } /* end for */
 
 done:
diff --git a/src/H5B2pkg.h b/src/H5B2pkg.h
index 543fa3f..b820853 100644
--- a/src/H5B2pkg.h
+++ b/src/H5B2pkg.h
@@ -346,13 +346,13 @@ H5_DLL herr_t H5B2_delete_node(H5B2_hdr_t *hdr, hid_t dxpl_id, unsigned depth,
 
 /* Debugging routines for dumping file structures */
 H5_DLL herr_t H5B2_hdr_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr,
-    FILE *stream, int indent, int fwidth, const H5B2_class_t *type);
+    FILE *stream, int indent, int fwidth, const H5B2_class_t *type, haddr_t obj_addr);
 H5_DLL herr_t H5B2_int_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr,
     FILE *stream, int indent, int fwidth, const H5B2_class_t *type,
-    haddr_t hdr_addr, unsigned nrec, unsigned depth);
+    haddr_t hdr_addr, unsigned nrec, unsigned depth, haddr_t obj_addr);
 H5_DLL herr_t H5B2_leaf_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr,
     FILE *stream, int indent, int fwidth, const H5B2_class_t *type,
-    haddr_t hdr_addr, unsigned nrec);
+    haddr_t hdr_addr, unsigned nrec, haddr_t obj_addr);
 
 /* Testing routines */
 #ifdef H5B2_TESTING
diff --git a/src/H5B2private.h b/src/H5B2private.h
index 4880ab2..8ec9954 100644
--- a/src/H5B2private.h
+++ b/src/H5B2private.h
@@ -54,6 +54,8 @@ 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_CDSET_ID,              /* B-tree is for non-filtered chunked dataset storage w/ >1 unlim dims */
+    H5B2_CDSET_FILT_ID,         /* B-tree is for filtered chunked dataset storage w/ >1 unlim dims */
     H5B2_NUM_BTREE_ID           /* Number of B-tree IDs (must be last)  */
 } H5B2_subid_t;
 
@@ -88,13 +90,13 @@ struct H5B2_class_t {
     /* Extensible array client callback methods */
     void *(*crt_context)(void *udata);          /* Create context for other client callbacks */
     herr_t (*dst_context)(void *ctx);           /* Destroy client callback context */
-    herr_t (*store)(void *nrecord, const void *udata);              /*  Store application record in native record table */
-    herr_t (*compare)(const void *rec1, const void *rec2);          /*  Compare two native records */
-    herr_t (*encode)(uint8_t *raw, const void *record, void *ctx);  /*  Encode record from native form to disk storage form */
-    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, const H5F_t *f, hid_t dxpl_id,    /* Print a record for debugging */
-        int indent, int fwidth, const void *record, const void *udata);
-    void *(*crt_dbg_ctx)(H5F_t *f, hid_t dxpl_id, haddr_t obj_addr); /* Create debugging context */
+    herr_t (*store)(void *nrecord, const void *udata);              	/* Store application record in native record table */
+    herr_t (*compare)(const void *rec1, const void *rec2); 		/* Compare two native records */
+    herr_t (*encode)(uint8_t *raw, const void *record, void *ctx);  	/* Encode record from native form to disk storage form */
+    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, const H5F_t *f, hid_t dxpl_id,    	/* Print a record for debugging */
+        int indent, int fwidth, 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 */
 };
 
diff --git a/src/H5B2test.c b/src/H5B2test.c
index a0508fe..8076343 100644
--- a/src/H5B2test.c
+++ b/src/H5B2test.c
@@ -333,7 +333,6 @@ H5B2_test_crt_dbg_context(H5F_t *f, hid_t UNUSED dxpl_id, haddr_t UNUSED addr)
 
     /* Sanity check */
     HDassert(f);
-    HDassert(H5F_addr_defined(addr));
 
     /* Allocate callback context */
     if(NULL == (ctx = H5FL_MALLOC(H5B2_test_ctx_t)))
diff --git a/src/H5Dbtree2.c b/src/H5Dbtree2.c
new file mode 100644
index 0000000..1b014e5
--- /dev/null
+++ b/src/H5Dbtree2.c
@@ -0,0 +1,1769 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ * Copyright by The HDF Group.                                               *
+ * Copyright by the Board of Trustees of the University of Illinois.         *
+ * All rights reserved.                                                      *
+ *                                                                           *
+ * This file is part of HDF5.  The full HDF5 copyright notice, including     *
+ * terms governing use, modification, and redistribution, is contained in    *
+ * the files COPYING and Copyright.html.  COPYING can be found at the root   *
+ * of the source code distribution tree; Copyright.html can be found at the  *
+ * root level of an installed copy of the electronic HDF5 document set and   *
+ * is linked from the top-level documents page.  It can also be found at     *
+ * http://hdfgroup.org/HDF5/doc/Copyright.html.  If you do not have          *
+ * access to either file, you may request a copy from help@hdfgroup.org.     *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/* 
+ *
+ * Purpose: v2 B-tree indexing for chunked datasets with > 1 unlimited dimensions.
+ *   Each dataset chunk in the b-tree is identified by its dimensional offset.
+ *
+ */
+
+/****************/
+/* Module Setup */
+/****************/
+
+#define H5D_PACKAGE		/*suppress error about including H5Dpkg	  */
+
+
+/***********/
+/* Headers */
+/***********/
+#include "H5private.h"          /* Generic Functions                    */
+#include "H5Dpkg.h"		/* Datasets				*/
+#include "H5FLprivate.h"	/* Free Lists                           */
+#include "H5MFprivate.h"     	/* File space management                */
+#include "H5Vprivate.h"		/* Vector and array functions		*/
+
+/****************/
+/* Local Macros */
+/****************/
+
+/******************/
+/* Local Typedefs */
+/******************/
+/* Typedef for non-filtered object's records in v2 B-tree */
+typedef struct H5D_bt2_rec_t {
+    haddr_t addr;       		/* Address of the chunk in the file */
+    hsize_t offset[H5O_LAYOUT_NDIMS];   /* logical offset to start*/
+} H5D_bt2_rec_t;
+
+/* Typedef for filtered object's records in v2 B-tree */
+typedef struct H5D_bt2_filt_rec_t {
+    haddr_t addr;       	/* Address of the filtered object in the file */
+    uint32_t nbytes;        	/* Length of the filtered object in the file */
+    uint32_t filter_mask;   	/* I/O pipeline filter mask for filtered object in the file */
+    hsize_t offset[H5O_LAYOUT_NDIMS];       /* logical offset to start*/
+} H5D_bt2_filt_rec_t;
+
+/* User data for creating callback context */
+typedef struct H5D_bt2_ctx_ud_t {
+    const H5F_t *f;             /* Pointer to file info */
+    uint32_t chunk_size;        /* Size of chunk (bytes; for filtered object) */
+    unsigned ndims;		/* Number of dimensions */
+} H5D_bt2_ctx_ud_t;
+
+/* The callback context */
+typedef struct H5D_bt2_ctx_t {
+    size_t sizeof_addr;       	/* Size of file addresses in the file (bytes) */
+    size_t chunk_size_len;      /* Size of chunk sizes in the file (bytes) */
+    unsigned ndims;		/* Number of dimensions */
+} H5D_bt2_ctx_t;
+
+/* User data for the chunk's removal callback routine */
+typedef struct H5D_bt2_remove_ud_t {
+    H5F_t *f;                   /* File pointer for operation */
+    hid_t dxpl_id;              /* DXPL ID for operation */
+    uint32_t unfilt_size;       /* Size of unfiltered chunk in bytes */
+} H5D_bt2_remove_ud_t;
+
+/* Callback info for iteration over chunks in v2 B-tree */
+typedef struct H5D_bt2_it_ud_t {
+    H5D_chunk_common_ud_t common;       /* Common info for v2 B-tree user data (must be first) */
+    H5D_chunk_rec_t     chunk_rec;      /* Generic chunk record for callback */
+    hbool_t		filtered;	/* The chunk is filtered or not */
+    H5D_chunk_cb_func_t cb;             /* Callback routine for the chunk */
+    void                *udata;         /* User data for the chunk's callback routine */
+} H5D_bt2_it_ud_t;
+
+/* User data for compare callback */
+typedef struct H5D_bt2_find_ud_t {
+    void *rec;    	/* The record to search for */
+    unsigned ndims;	/* Number of dimensions for the chunked dataset */
+} H5D_bt2_find_ud_t;
+
+/********************/
+/* Local Prototypes */
+/********************/
+
+/* v2 B-tree class for indexing non-filtered chunked datasets */
+static void *H5D_bt2_crt_context(void *udata);
+static herr_t H5D_bt2_dst_context(void *ctx);
+static void *H5D_bt2_crt_dbg_context(H5F_t *f, hid_t dxpl_id, haddr_t obj_addr);
+static herr_t H5D_bt2_dst_dbg_context(void *_u_ctx);
+
+static herr_t H5D_bt2_store(void *native, const void *udata);
+static herr_t H5D_bt2_compare(const void *rec1, const void *rec2);
+static herr_t H5D_bt2_encode(uint8_t *raw, const void *native, void *ctx);
+static herr_t H5D_bt2_decode(const uint8_t *raw, void *native, void *ctx);
+static herr_t H5D_bt2_debug(FILE *stream, const H5F_t *f, hid_t dxpl_id,
+    int indent, int fwidth, const void *record, const void *u_ctx);
+
+/* v2 B-tree class for indexing filtered chunked datasets */
+static herr_t H5D_bt2_filt_store(void *native, const void *udata);
+static herr_t H5D_bt2_filt_compare(const void *rec1, const void *rec2);
+static herr_t H5D_bt2_filt_encode(uint8_t *raw, const void *native, void *ctx);
+static herr_t H5D_bt2_filt_decode(const uint8_t *raw, void *native, void *ctx);
+static herr_t H5D_bt2_filt_debug(FILE *stream, const H5F_t *f, hid_t dxpl_id,
+    int indent, int fwidth, const void *record, const void *u_ctx);
+
+/* Helper routine */
+static herr_t H5D_bt2_idx_open(const H5D_chk_idx_info_t *idx_info);
+
+/* Callback for H5B2_iterate() which is called in H5D_bt2_idx_iterate() */
+static int H5D_bt2_idx_iterate_cb(const void *_record, void *_udata);
+
+/* Callbacks for H5B2_find() which are called in H5D_bt2_idx_get_addr() and H5D_bt2_idx_insert() */
+static herr_t H5D_bt2_found_cb(const void *nrecord, void *op_data);
+static herr_t H5D_bt2_filt_found_cb(const void *nrecord, void *op_data);
+
+/*  
+ * Callbacks for H5B2_remove() and H5B2_delete() which are called
+ * in H5D_bt2_idx_remove() and H5D_bt2_idx_delete().
+ */
+static herr_t H5D_bt2_remove_cb(const void *nrecord, void *_udata);
+static herr_t H5D_bt2_filt_remove_cb(const void *nrecord, void *_udata);
+
+/* Callback for H5B2_modify() which is called in H5D_bt2_idx_insert() */
+static herr_t H5D_bt2_mod_filt_cb(void *_record, void *_op_data, hbool_t *changed);
+
+/* Chunked dataset I/O ops for v2 B-tree indexing */
+static herr_t H5D_bt2_idx_create(const H5D_chk_idx_info_t *idx_info);
+static hbool_t H5D_bt2_idx_is_space_alloc(const H5O_storage_chunk_t *storage);
+static herr_t H5D_bt2_idx_insert(const H5D_chk_idx_info_t *idx_info,
+    H5D_chunk_ud_t *udata);
+static herr_t H5D_bt2_idx_get_addr(const H5D_chk_idx_info_t *idx_info,
+    H5D_chunk_ud_t *udata);
+static int H5D_bt2_idx_iterate(const H5D_chk_idx_info_t *idx_info,
+    H5D_chunk_cb_func_t chunk_cb, void *chunk_udata);
+static herr_t H5D_bt2_idx_remove(const H5D_chk_idx_info_t *idx_info,
+    H5D_chunk_common_ud_t *udata);
+static herr_t H5D_bt2_idx_delete(const H5D_chk_idx_info_t *idx_info);
+static herr_t H5D_bt2_idx_copy_setup(const H5D_chk_idx_info_t *idx_info_src,
+    const H5D_chk_idx_info_t *idx_info_dst);
+static herr_t H5D_bt2_idx_copy_shutdown(H5O_storage_chunk_t *storage_src,
+    H5O_storage_chunk_t *storage_dst, hid_t dxpl_id);
+static herr_t H5D_bt2_idx_size(const H5D_chk_idx_info_t *idx_info, hsize_t *size);
+static herr_t H5D_bt2_idx_reset(H5O_storage_chunk_t *storage, hbool_t reset_addr);
+static herr_t H5D_bt2_idx_dump(const H5O_storage_chunk_t *storage,
+    FILE *stream);
+static herr_t H5D_bt2_idx_dest(const H5D_chk_idx_info_t *idx_info);
+
+/*********************/
+/* Package Variables */
+/*********************/
+
+/* Chunked dataset I/O ops for v2 B-tree indexing */
+const H5D_chunk_ops_t H5D_COPS_BT2[1] = {{
+    FALSE,
+    NULL, 
+    H5D_bt2_idx_create,
+    H5D_bt2_idx_is_space_alloc,
+    H5D_bt2_idx_insert,
+    H5D_bt2_idx_get_addr,
+    NULL,
+    H5D_bt2_idx_iterate,
+    H5D_bt2_idx_remove,
+    H5D_bt2_idx_delete,
+    H5D_bt2_idx_copy_setup,
+    H5D_bt2_idx_copy_shutdown,
+    H5D_bt2_idx_size,
+    H5D_bt2_idx_reset,
+    NULL,
+    NULL,
+    H5D_bt2_idx_dump, 
+    H5D_bt2_idx_dest 
+}};
+
+
+/*****************************/
+/* Library Private Variables */
+/*****************************/
+
+/* v2 B-tree class for indexing non-filtered chunked datasets */
+const H5B2_class_t H5D_BT2[1] = {{  	/* B-tree class information */
+    H5B2_CDSET_ID,             	/* Type of B-tree */
+    "H5B2_CDSET_ID",           	/* Name of B-tree class */
+    sizeof(H5D_bt2_rec_t),	/* Size of native record */
+    H5D_bt2_crt_context,      	/* Create client callback context */
+    H5D_bt2_dst_context,       	/* Destroy client callback context */
+    H5D_bt2_store,    		/* Record storage callback */
+    H5D_bt2_compare,   		/* Record comparison callback */
+    H5D_bt2_encode,    		/* Record encoding callback */
+    H5D_bt2_decode,    		/* Record decoding callback */
+    H5D_bt2_debug,  		/* Record debugging callback */
+    H5D_bt2_crt_dbg_context,  	/* Create debugging context */
+    H5D_bt2_dst_dbg_context      /* Destroy debugging context */
+}};
+
+/* v2 B-tree class for indexing filtered chunked datasets */
+const H5B2_class_t H5D_BT2_FILT[1] = {{	/* B-tree class information */
+    H5B2_CDSET_FILT_ID, 	/* Type of B-tree */
+    "H5B2_CDSET_FILT_ID",      	/* Name of B-tree class */
+    sizeof(H5D_bt2_filt_rec_t), 	/* Size of native record */
+    H5D_bt2_crt_context,       	/* Create client callback context */
+    H5D_bt2_dst_context,       	/* Destroy client callback context */
+    H5D_bt2_filt_store,        	/* Record storage callback */
+    H5D_bt2_filt_compare,      	/* Record comparison callback */
+    H5D_bt2_filt_encode,       	/* Record encoding callback */
+    H5D_bt2_filt_decode,       	/* Record decoding callback */
+    H5D_bt2_filt_debug,        	/* Record debugging callback */
+    H5D_bt2_crt_dbg_context,   	/* Create debugging context */
+    H5D_bt2_dst_dbg_context   	/* Destroy debugging context */
+}};
+
+/* Declare a free list to manage the H5D_bt2_ctx_t struct */
+H5FL_DEFINE_STATIC(H5D_bt2_ctx_t);
+/* Declare a free list to manage the H5D_bt2_ctx_ud_t struct */
+H5FL_DEFINE_STATIC(H5D_bt2_ctx_ud_t);
+
+/*-------------------------------------------------------------------------
+ * Function:    H5D_bt2_crt_context
+ *
+ * Purpose:     Create client callback context
+ *
+ * Return:      Success:        non-NULL
+ *              Failure:        NULL
+ *
+ * Programmer:  Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static void *
+H5D_bt2_crt_context(void *_udata)
+{
+    H5D_bt2_ctx_ud_t *udata = (H5D_bt2_ctx_ud_t *)_udata; /* User data for building callback context */
+    H5D_bt2_ctx_t *ctx;   	/* Callback context structure */
+    void *ret_value;            /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5D_bt2_crt_context)
+
+    /* Sanity check */
+    HDassert(udata);
+    HDassert(udata->f);
+    HDassert(udata->ndims > 0 && udata->ndims < H5O_LAYOUT_NDIMS);
+
+    /* Allocate callback context */
+    if(NULL == (ctx = H5FL_MALLOC(H5D_bt2_ctx_t)))
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, NULL, "can't allocate callback context")
+
+    /* Determine the size of addresses and # of dimensions for the dataset */
+    ctx->sizeof_addr = H5F_SIZEOF_ADDR(udata->f);
+    ctx->ndims = udata->ndims;
+
+    /* 
+     * Compute the size required for encoding the size of a chunk,
+     * allowing for an extra byte, in case the filter makes the chunk larger.
+     */
+    ctx->chunk_size_len = 1 + ((H5V_log2_gen((uint64_t)udata->chunk_size) + 8) / 8);
+    if(ctx->chunk_size_len > 8)
+        ctx->chunk_size_len = 8;
+
+    /* Set return value */
+    ret_value = ctx;
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5D_bt2_crt_context() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5D_bt2_dst_context
+ *
+ * Purpose:     Destroy client callback context
+ *
+ * Return:      Success:        non-negative
+ *              Failure:        negative
+ *
+ * Programmer:  Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_dst_context(void *_ctx)
+{
+    H5D_bt2_ctx_t *ctx = (H5D_bt2_ctx_t *)_ctx;       /* Callback context structure */
+
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_bt2_dst_context)
+
+    /* Sanity check */
+    HDassert(ctx);
+
+    /* Release callback context */
+    ctx = H5FL_FREE(H5D_bt2_ctx_t, ctx);
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* H5D_bt2_dst_context() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5D_bt2_store
+ *
+ * Purpose:     Store native information into record for v2 B-tree
+ *		(non-filtered)
+ *
+ * Return:      Success:        non-negative
+ *              Failure:        negative
+ *
+ * Programmer:  Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_store(void *record, const void *_udata)
+{
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_bt2_store)
+
+    const H5D_bt2_find_ud_t *udata = (const H5D_bt2_find_ud_t *)_udata;	/* User data */
+
+    *(H5D_bt2_rec_t *)record = *(const H5D_bt2_rec_t *)udata->rec;
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* H5D_bt2_store() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5D_bt2_filt_store
+ *
+ * Purpose:     Store native information into record for v2 B-tree
+ *		(filtered)
+ *
+ * Return:      Success:        non-negative
+ *              Failure:        negative
+ *
+ * Programmer:  Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_filt_store(void *record, const void *_udata)
+{
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_bt2_filt_store)
+
+    const H5D_bt2_find_ud_t *udata = (const H5D_bt2_find_ud_t *)_udata;	/* User data */
+
+    *(H5D_bt2_filt_rec_t *)record = *(const H5D_bt2_filt_rec_t *)udata->rec;
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* H5D_bt2_filt_store() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5D_bt2_compare
+ *
+ * Purpose:     Compare two native information records, according to some key
+ *		(non-filtered)
+ *
+ * Return:      <0 if rec1 < rec2
+ *              =0 if rec1 == rec2
+ *              >0 if rec1 > rec2
+ *
+ * Programmer:  Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_compare(const void *_udata, const void *_rec2)
+{
+    const H5D_bt2_find_ud_t *udata = (const H5D_bt2_find_ud_t *)_udata;	/* User data */
+
+    const H5D_bt2_rec_t *rec1 = (const H5D_bt2_rec_t *)udata->rec;	/* The native record */
+    const H5D_bt2_rec_t *rec2 = (const H5D_bt2_rec_t *)_rec2;		/* The native record */
+    herr_t ret_value; 	/* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_bt2_compare)
+
+    HDassert(rec1);
+    HDassert(rec2);
+
+    /* Compare the offsets but ignore the other fields */
+    ret_value = H5V_vector_cmp_u(udata->ndims, rec1->offset, rec2->offset);
+
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5D_bt2_compare() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5D_bt2_filt_compare
+ *
+ * Purpose:     Compare two native information records, according to some key
+ *		(filtered)
+ *
+ * Return:      <0 if rec1 < rec2
+ *              =0 if rec1 == rec2
+ *              >0 if rec1 > rec2
+ *
+ * Programmer:  Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_filt_compare(const void *_udata, const void *_rec2)
+{
+    const H5D_bt2_find_ud_t *udata = (const H5D_bt2_find_ud_t *)_udata;	/* User data */
+
+    const H5D_bt2_filt_rec_t *rec1 = (const H5D_bt2_filt_rec_t *)udata->rec;	/* The native record */
+    const H5D_bt2_filt_rec_t *rec2 = (const H5D_bt2_filt_rec_t *)_rec2;		/* The native record */
+    herr_t ret_value;	/* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_bt2_filt_compare)
+
+    HDassert(rec1);
+    HDassert(rec2);
+
+    /* Compare the offsets but ignore the other fields */
+    ret_value = H5V_vector_cmp_u(udata->ndims, rec1->offset, rec2->offset);
+
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5D_bt2_filt_compare() */
+
+/*-------------------------------------------------------------------------
+ * Function:    H5D_bt2_encode
+ *
+ * Purpose:     Encode native information into raw form for storing on disk
+ *		(non-filtered)
+ *
+ * Return:      Success:        non-negative
+ *              Failure:        negative
+ *
+ * Programmer:  Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_encode(uint8_t *raw, const void *_record, void *_ctx)
+{
+    H5D_bt2_ctx_t *ctx = (H5D_bt2_ctx_t *)_ctx;	/* Callback context structure */
+    const H5D_bt2_rec_t *record = (const H5D_bt2_rec_t *)_record; /* The native record */
+    unsigned	i;	/* Local index varible */
+
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_bt2_encode)
+
+    /* Sanity check */
+    HDassert(ctx);
+
+    /* Encode the record's fields */
+    H5F_addr_encode_len(ctx->sizeof_addr, &raw, record->addr);
+    for(i = 0; i < ctx->ndims; i++)
+	UINT64ENCODE(raw, record->offset[i]);
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* H5D_bt2_encode() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5D_bt2_filt_encode
+ *
+ * Purpose:     Encode native information into raw form for storing on disk
+ *		(filtered)
+ *
+ * Return:      Success:        non-negative
+ *              Failure:        negative
+ *
+ * Programmer:  Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_filt_encode(uint8_t *raw, const void *_record, void *_ctx)
+{
+    H5D_bt2_ctx_t *ctx = (H5D_bt2_ctx_t *)_ctx;	/* Callback context structure */
+    const H5D_bt2_filt_rec_t *record = (const H5D_bt2_filt_rec_t *)_record;  /* The native record */
+    unsigned i;	/* Local index variable */
+
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_bt2_filt_encode)
+
+    /* Sanity check */
+    HDassert(ctx);
+
+    /* Encode the record's fields */
+    H5F_addr_encode_len(ctx->sizeof_addr, &raw, record->addr);
+    UINT64ENCODE_VAR(raw, record->nbytes, ctx->chunk_size_len);
+    UINT32ENCODE(raw, record->filter_mask);
+    for(i = 0; i < ctx->ndims; i++)
+	UINT64ENCODE(raw, record->offset[i]);
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* H5D_bt2_filt_encode() */
+
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5D_bt2_decode
+ *
+ * Purpose:     Decode raw disk form of record into native form
+ *		(non-filtered)
+ *
+ * Return:      Success:        non-negative
+ *              Failure:        negative
+ *
+ * Programmer:  Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_decode(const uint8_t *raw, void *_record, void *_ctx)
+{
+    H5D_bt2_ctx_t *ctx = (H5D_bt2_ctx_t *)_ctx;       	/* Callback context structure */
+    H5D_bt2_rec_t *record = (H5D_bt2_rec_t *)_record;	/* The native record */
+    unsigned	i;	/* Local index variable */
+
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_bt2_decode)
+
+    /* Sanity check */
+    HDassert(ctx);
+
+    /* Decode the record's fields */
+    H5F_addr_decode_len(ctx->sizeof_addr, &raw, &record->addr);
+    for(i = 0; i < ctx->ndims; i++)
+	UINT64DECODE(raw, record->offset[i]);
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* H5D_bt2_decode() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5D_bt2_filt_decode
+ *
+ * Purpose:	Decode raw disk form of record into native form
+ *		(filtered)
+ *
+ * Return:	Success:	non-negative
+ *		Failure:	negative
+ *
+ * Programmer:	Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_filt_decode(const uint8_t *raw, void *_record, void *_ctx)
+{
+    H5D_bt2_ctx_t *ctx = (H5D_bt2_ctx_t *)_ctx;       		/* Callback context structure */
+    H5D_bt2_filt_rec_t *record = (H5D_bt2_filt_rec_t *)_record;	/* The native record */
+    unsigned i;	/* Local index variable */
+
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_bt2_filt_decode)
+
+    /* Sanity check */
+    HDassert(ctx);
+
+    /* Decode the record's fields */
+    H5F_addr_decode_len(ctx->sizeof_addr, &raw, &record->addr);
+    UINT64DECODE_VAR(raw, record->nbytes, ctx->chunk_size_len);
+    UINT32DECODE(raw, record->filter_mask);
+    for(i = 0; i < ctx->ndims; i++)
+	UINT64DECODE(raw, record->offset[i]);
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* H5D_bt2_filt_decode() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5D_bt2_debug
+ *
+ * Purpose:	Debug native form of record (non-filtered)
+ *
+ * Return:	Success:	non-negative
+ *		Failure:	negative
+ *
+ * Programmer:	Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_debug(FILE *stream, const H5F_t UNUSED *f, hid_t UNUSED dxpl_id,
+    int indent, int fwidth, const void *_record, const void *_u_ctx)
+{
+    const H5D_bt2_rec_t *record = (const H5D_bt2_rec_t *)_record; /* The native record */
+    const H5D_bt2_ctx_ud_t *u_ctx = (const H5D_bt2_ctx_ud_t *)_u_ctx; 	  /* User data for creating callback context */
+    unsigned u;		/* Local index variable */
+
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_bt2_debug)
+
+    HDassert(record);
+
+    HDfprintf(stream, "%*s%-*s %a\n", indent, "", fwidth, "Chunk address:", (unsigned)record->addr);
+    HDfprintf(stream, "%*s%-*s {", indent, "", fwidth, "Logical offset:");
+    for(u = 0; u < u_ctx->ndims; u++)
+        HDfprintf(stream, "%s%Hd", u?", ":"", record->offset[u]);
+    HDfputs("}\n", stream);
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* H5D_bt2_debug() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5D_bt2_filt_debug
+ *
+ * Purpose:	Debug native form of record (filterd)
+ *
+ * Return:	Success:	non-negative
+ *		Failure:	negative
+ *
+ * Programmer:	Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_filt_debug(FILE *stream, const H5F_t UNUSED *f, hid_t UNUSED dxpl_id,
+    int indent, int fwidth, const void *_record, const void *_u_ctx)
+{
+    const H5D_bt2_filt_rec_t *record = (const H5D_bt2_filt_rec_t *)_record; /* The native record */
+    const H5D_bt2_ctx_ud_t *u_ctx = (const H5D_bt2_ctx_ud_t *)_u_ctx; /* User data for creating callback context */
+    unsigned u;		/* Local index variable */
+ 
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_bt2_filt_debug)
+
+    HDassert(record);
+
+    HDfprintf(stream, "%*s%-*s %a\n", indent, "", fwidth, "Chunk address:", (unsigned)record->addr);
+    HDfprintf(stream, "%*s%-*s %u bytes\n", indent, "", fwidth, "Chunk size:", (unsigned)record->nbytes);
+    HDfprintf(stream, "%*s%-*s 0x%08x\n", indent, "", fwidth, "Filter mask:", record->filter_mask);
+
+    HDfprintf(stream, "%*s%-*s {", indent, "", fwidth, "Logical offset:");
+    for(u = 0; u < u_ctx->ndims; u++)
+        HDfprintf(stream, "%s%Hd", u?", ":"", record->offset[u]);
+    HDfputs("}\n", stream);
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* H5D_bt2_filt_debug() */
+
+/*-------------------------------------------------------------------------
+ * Function:    H5D_bt2_crt_dbg_context
+ *
+ * Purpose:     Create user data for debugged callback context 
+ *
+ * Return:      Success:        non-NULL
+ *              Failure:        NULL
+ *
+ * Programmer:  Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static void *
+H5D_bt2_crt_dbg_context(H5F_t *f, hid_t UNUSED dxpl_id, haddr_t obj_addr)
+{
+    H5D_bt2_ctx_ud_t *u_ctx;   	/* User data for creating callback context */
+    H5O_loc_t obj_loc;          /* Pointer to an object's location */
+    hbool_t obj_opened = FALSE; /* Flag to indicate that the object header was opened */
+    H5O_layout_t layout;        /* Layout message */
+    void *ret_value;      	/* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5D_bt2_crt_dbg_context)
+
+    /* Sanity check */
+    HDassert(f);
+    HDassert(H5F_addr_defined(obj_addr));
+
+    /* Set up the object header location info */
+    H5O_loc_reset(&obj_loc);
+    obj_loc.file = f;
+    obj_loc.addr = obj_addr;
+
+    /* Open the object header where the layout message resides */
+    if(H5O_open(&obj_loc) < 0)
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTOPENOBJ, NULL, "can't open object header")
+    obj_opened = TRUE;
+
+    /* Read the layout message */
+    if(NULL == H5O_msg_read(&obj_loc, H5O_LAYOUT_ID, &layout, dxpl_id))
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, NULL, "can't get layout info")
+
+    /* close the object header */
+    if(H5O_close(&obj_loc) < 0)
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, NULL, "can't close object header")
+
+    /* Allocate structure for storing user data to create callback context */
+    if(NULL == (u_ctx = H5FL_MALLOC(H5D_bt2_ctx_ud_t)))
+        HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, NULL, "can't allocate user data context structure ")
+
+    /* Set information for context structure */
+    u_ctx->f = f;
+    u_ctx->chunk_size = layout.u.chunk.size;
+    u_ctx->ndims = layout.u.chunk.ndims - 1;
+
+    /* Set return value */
+    ret_value = u_ctx;
+
+done:
+     /* Cleanup on error */
+    if(ret_value == NULL) {
+        /* Release context structure */
+        if(u_ctx)
+            u_ctx = H5FL_FREE(H5D_bt2_ctx_ud_t, u_ctx);
+
+        /* Close object header */
+        if(obj_opened) {
+            if(H5O_close(&obj_loc) < 0)
+                HDONE_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, NULL, "can't close object header")
+        } /* end if */
+    } /* end if */
+
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5D_bt2_crt_dbg_context() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5D_bt2_dst_dbg_context
+ *
+ * Purpose:     Destroy client callback context
+ *
+ * Return:      Success:        non-negative
+ *              Failure:        negative
+ *
+ * Programmer:  Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_dst_dbg_context(void *_u_ctx)
+{
+    H5D_bt2_ctx_ud_t *u_ctx = (H5D_bt2_ctx_ud_t *)_u_ctx; /* User data for creating callback context */
+
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_bt2_dst_dbg_context)
+
+    /* Sanity check */
+    HDassert(u_ctx);
+
+    /* Release user data for creating callback context */
+    u_ctx = H5FL_FREE(H5D_bt2_ctx_ud_t, u_ctx);
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* H5D_bt2_dst_dbg_context() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5D_bt2_idx_open()
+ *
+ * Purpose:	Opens an existing v2 B-tree.
+ *
+ * Note:	This information is passively initialized from each index
+ *              operation callback because those abstract chunk index operations
+ *              are designed to work with the v2 B-tree chunk indices also,
+ *              which don't require an 'open' for the data structure.
+ *
+ * Return:	Success:	non-negative
+ *		Failure:	negative
+ *
+ * Programmer:	Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_idx_open(const H5D_chk_idx_info_t *idx_info)
+{
+    H5D_bt2_ctx_ud_t u_ctx;	/* user data for creating context */
+    herr_t ret_value = SUCCEED; /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5D_bt2_idx_open)
+
+    /* Check args */
+    HDassert(idx_info);
+    HDassert(idx_info->f);
+    HDassert(idx_info->pline);
+    HDassert(idx_info->layout);
+    HDassert(H5D_CHUNK_IDX_BT2 == idx_info->layout->idx_type);
+    HDassert(idx_info->storage);
+    HDassert(H5F_addr_defined(idx_info->storage->idx_addr));
+    HDassert(NULL == idx_info->storage->u.btree2.bt2);
+
+    /* Set up the user data */
+    u_ctx.f = idx_info->f;
+    u_ctx.ndims = idx_info->layout->ndims - 1;
+    u_ctx.chunk_size = idx_info->layout->size;
+
+    /* Open v2 B-tree for the chunk index */
+    if(NULL == (idx_info->storage->u.btree2.bt2 = H5B2_open(idx_info->f, idx_info->dxpl_id, idx_info->storage->idx_addr , &u_ctx)))
+	HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "can't open v2 B-tree for tracking chunked dataset")
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5D_bt2_idx_open() */
+
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5D_bt2_idx_create 
+ *
+ * Purpose:	Create the v2 B-tree for tracking dataset chunks 
+ *
+ * Return:      SUCCEED/FAIL
+ *
+ * Programmer:	Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_idx_create(const H5D_chk_idx_info_t *idx_info)
+{
+    H5B2_create_t bt2_cparam;           /* v2 B-tree creation parameters */
+    H5D_bt2_ctx_ud_t u_ctx;		/* data for context call */
+    herr_t ret_value = SUCCEED;         /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5D_bt2_idx_create)
+
+    /* Check args */
+    HDassert(idx_info);
+    HDassert(idx_info->f);
+    HDassert(idx_info->pline);
+    HDassert(idx_info->layout);
+    HDassert(idx_info->storage);
+    HDassert(!H5F_addr_defined(idx_info->storage->idx_addr));
+    
+    bt2_cparam.rrec_size = H5F_SIZEOF_ADDR(idx_info->f)	/* Address of chunk */
+		  + (idx_info->layout->ndims - 1) * 8;	/* # of dimensions x 64-bit chunk offsets */
+
+    if(idx_info->pline->nused > 0) {
+	unsigned chunk_size_len;        /* Size of encoded chunk size */
+        /* 
+	 * Compute the size required for encoding the size of a chunk,
+         * allowing for an extra byte, in case the filter makes the chunk larger.
+         */
+        chunk_size_len = 1 + ((H5V_log2_gen((uint64_t)idx_info->layout->size) + 8) / 8);
+        if(chunk_size_len > 8)
+            chunk_size_len = 8;
+
+	bt2_cparam.rrec_size  += chunk_size_len	+ 4;	/* Size of encoded chunk size & filter mask */
+	bt2_cparam.cls = H5D_BT2_FILT;
+    } else
+	bt2_cparam.cls = H5D_BT2;
+
+    bt2_cparam.node_size = idx_info->layout->u.btree2.cparam.node_size;
+    bt2_cparam.split_percent = idx_info->layout->u.btree2.cparam.split_percent;
+    bt2_cparam.merge_percent = idx_info->layout->u.btree2.cparam.merge_percent;
+
+    u_ctx.f = idx_info->f;
+    u_ctx.ndims = idx_info->layout->ndims - 1;
+    u_ctx.chunk_size = idx_info->layout->size;
+
+    /* Create the v2 B-tree for the chunked dataset */
+    if(NULL == (idx_info->storage->u.btree2.bt2 = H5B2_create(idx_info->f, idx_info->dxpl_id, &bt2_cparam, &u_ctx)))
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTCREATE, FAIL, "can't create v2 B-tree for tracking chunked dataset")
+
+    /* Retrieve the v2 B-tree's address in the file */
+    if(H5B2_get_addr(idx_info->storage->u.btree2.bt2, &(idx_info->storage->idx_addr)) < 0)
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get v2 B-tree address for tracking chunked dataset")
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5D_bt2_idx_create() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5D_bt2_idx_is_space_alloc
+ *
+ * Purpose:	Query if space is allocated for index method
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static hbool_t
+H5D_bt2_idx_is_space_alloc(const H5O_storage_chunk_t *storage)
+{
+    hbool_t ret_value;          /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_bt2_idx_is_space_alloc)
+
+    /* Check args */
+    HDassert(storage);
+
+    /* Set return value */
+    ret_value = (hbool_t)H5F_addr_defined(storage->idx_addr);
+
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5D_bt2_idx_is_space_alloc() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5D_bt2_found_cb
+ *
+ * Purpose:	Retrieve record (non-filtered) for dataset chunk when it is found 
+ *		in the v2 B-tree.
+ * 		This is the callback for H5B2_find() which is called in 
+ *		H5D_bt2_idx_get_addr() and H5D_bt2_idx_insert().
+ *
+ * Return:	Success:	non-negative
+ *		Failure:	negative
+ *
+ * Programmer:	Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_found_cb(const void *nrecord, void *op_data)
+{
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_bt2_found_cb)
+
+    *(H5D_bt2_rec_t *)op_data = *(const H5D_bt2_rec_t *)nrecord;
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* H5D_bt2_found_cb() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5D_bt2_filt_found_cb
+ *
+ * Purpose:	Retrieve record (filtered) for dataset chunk when it is found 
+ *		in the v2 B-tree.
+ * 		This is the callback for H5B2_find() which is called in 
+ *		H5D_bt2_idx_get_addr() and H5D_bt2_idx_insert().
+ *
+ * Return:	Success:	non-negative
+ *		Failure:	negative
+ *
+ * Programmer:	Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_filt_found_cb(const void *nrecord, void *op_data)
+{
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_bt2_filt_found_cb)
+
+    *(H5D_bt2_filt_rec_t *)op_data = *(const H5D_bt2_filt_rec_t *)nrecord;
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* H5D_bt2_filt_found_cb() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5D_bt2_mod_filt_cb
+ *
+ * Purpose:	Modify record (filtered) for dataset chunk when it is found 
+ *		in the v2 B-tree.
+ * 		This is the callback for H5B2_modify() which is called in 
+ *		H5D_bt2_idx_insert().
+ *
+ * Return:	Success:	non-negative
+ *		Failure:	negative
+ *
+ * Programmer:	Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_mod_filt_cb(void *_record, void *_op_data, hbool_t *changed)
+{
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_bt2_mod_filt_cb)
+
+    *(H5D_bt2_filt_rec_t *)_record = *(H5D_bt2_filt_rec_t *)_op_data;
+
+    /* Note that the record changed */
+    *changed = TRUE;
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* end H5D_bt2_mod_filt_cb() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5D_bt2_idx_insert
+ *
+ * Purpose:	A non-filtered chunk: 
+ *		  Should not exist
+ *		  Allocate the chunk and pass chunk address back up
+ *		A filtered chunk:
+ *		  If it was not found, create the chunk and pass chunk address back up
+ *		  If it was found but its size changed, reallocate the chunk and pass chunk address back up
+ *		  If it was found but its size was the same, pass chunk address back up
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_idx_insert(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *udata)
+{
+    H5B2_t *bt2_cdset = NULL;           /* v2 B-tree handle for indexing chunks */
+    H5D_bt2_find_ud_t bt2_udata;
+    unsigned u;				/* local index variable */
+    herr_t ret_value = SUCCEED;		/* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5D_bt2_idx_insert)
+
+    HDassert(idx_info);
+    HDassert(idx_info->f);
+    HDassert(idx_info->pline);
+    HDassert(idx_info->layout);
+    HDassert(idx_info->storage);
+    HDassert(H5F_addr_defined(idx_info->storage->idx_addr));
+    HDassert(udata);
+
+    if(NULL == idx_info->storage->u.btree2.bt2) {
+	/* Open existing v2 B-tree */
+        if(H5D_bt2_idx_open(idx_info) < 0)
+            HGOTO_ERROR(H5E_DATASET, H5E_CANTOPENOBJ, FAIL, "can't open v2 B-tree")
+    } /* end if */
+
+    bt2_cdset = idx_info->storage->u.btree2.bt2;
+
+    /* Check for filters on chunks */
+    if(idx_info->pline->nused > 0) { /* filtered chunk */
+	unsigned allow_chunk_size_len;	/* Allowed size of encoded chunk size */
+        unsigned new_chunk_size_len;  	/* Size of encoded chunk size */
+	H5D_bt2_filt_rec_t rec;  	/* Record for searching object */
+	H5D_bt2_filt_rec_t found_rec;  	/* Record found from searching for object */
+
+	/* 
+	 * Compute the size required for encoding the size of a chunk,
+         * allowing for an extra byte, in case the filter makes the chunk larger.
+         */
+        allow_chunk_size_len = 1 + ((H5V_log2_gen((uint64_t)idx_info->layout->size) + 8) / 8);
+        if(allow_chunk_size_len > 8)
+            allow_chunk_size_len = 8;
+
+        /* Compute encoded size of chunk */
+        new_chunk_size_len = (H5V_log2_gen((uint64_t)udata->nbytes) + 8) / 8;
+        if(new_chunk_size_len > 8)
+            HGOTO_ERROR(H5E_DATASET, H5E_BADRANGE, FAIL, "encoded chunk size is more than 8 bytes?!?")
+
+        /* Check if the chunk became too large to be encoded */
+        if(new_chunk_size_len > allow_chunk_size_len)
+            HGOTO_ERROR(H5E_DATASET, H5E_BADRANGE, FAIL, "chunk size can't be encoded")
+
+	/* Initialize record information */
+        rec.nbytes = udata->nbytes;
+        rec.filter_mask = udata->filter_mask;
+	for(u = 0; u < (idx_info->layout->ndims - 1); u++)
+	    rec.offset[u] = udata->common.offset[u];
+
+	found_rec.addr = HADDR_UNDEF;
+	found_rec.nbytes = 0;
+	found_rec.filter_mask = 0;
+
+	/* Prepare user data for compare callback */
+	bt2_udata.rec = &rec;
+	bt2_udata.ndims = idx_info->layout->ndims - 1;
+
+	/* Try to find the chunked record */
+	if(H5B2_find(bt2_cdset, idx_info->dxpl_id, &bt2_udata, H5D_bt2_filt_found_cb, &found_rec) < 0)
+	    HGOTO_ERROR(H5E_DATASET, H5E_NOTFOUND, FAIL, "can't find object in v2 B-tree")
+
+        /* Check for previous chunk */
+        if(H5F_addr_defined(found_rec.addr)) { /* Found it */
+            /* Sanity check */
+            HDassert(!H5F_addr_defined(udata->addr) || H5F_addr_eq(udata->addr, found_rec.addr));
+
+            /* Check for chunk being same size */
+            if(udata->nbytes != found_rec.nbytes) {
+
+		H5_CHECK_OVERFLOW(found_rec.nbytes, uint32_t, hsize_t);
+
+		/* Free the original chunk */
+		if(H5MF_xfree(idx_info->f, H5FD_MEM_DRAW, idx_info->dxpl_id, found_rec.addr, (hsize_t)found_rec.nbytes) < 0)
+                    HGOTO_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "unable to free chunk")
+
+		/* Allocate a new chunk */
+		H5_CHECK_OVERFLOW(udata->nbytes, uint32_t, hsize_t);
+                rec.addr = udata->addr = H5MF_alloc(idx_info->f, H5FD_MEM_DRAW, idx_info->dxpl_id, (hsize_t)udata->nbytes);
+
+                if(!H5F_addr_defined(udata->addr))
+                    HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "unable to allocate chunk")
+
+		/* Modify record for object in v2 B-tree */
+                if(H5B2_modify(bt2_cdset, idx_info->dxpl_id, &bt2_udata, H5D_bt2_mod_filt_cb, &rec) < 0)
+                    HGOTO_ERROR(H5E_DATASET, H5E_CANTINSERT, FAIL, "unable to modify record in v2 B-tree")
+
+            } else
+                /* Don't need to reallocate chunk, but send its address back up */
+		udata->addr = found_rec.addr;
+        }  else { /* Not found */
+            H5_CHECK_OVERFLOW(udata->nbytes, uint32_t, hsize_t);
+
+	    /* Allocate a new chunk */
+            rec.addr = udata->addr = H5MF_alloc(idx_info->f, H5FD_MEM_DRAW, idx_info->dxpl_id, (hsize_t)udata->nbytes);
+            if(!H5F_addr_defined(udata->addr))
+                HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "unable to allocate chunk")
+
+	    /* Insert record for object in v2 B-tree */
+            if(H5B2_insert(bt2_cdset, idx_info->dxpl_id, &bt2_udata) < 0)                
+		HGOTO_ERROR(H5E_DATASET, H5E_CANTINSERT, FAIL, "couldn't insert record in v2 B-tree")
+	}
+    } else { /* non-filtered chunk */
+	H5D_bt2_rec_t rec;  	
+
+	/* The record should not be there */
+	HDassert(!H5F_addr_defined(udata->addr));
+        HDassert(udata->nbytes == idx_info->layout->size);
+
+	/* Prepare user data for compare callback */
+	bt2_udata.rec = &rec;
+	bt2_udata.ndims = idx_info->layout->ndims - 1;
+
+	for(u = 0; u < (idx_info->layout->ndims - 1); u++)
+	    rec.offset[u] = udata->common.offset[u];
+
+	/* Allocate storage for the new chunk */
+	H5_CHECK_OVERFLOW(udata->nbytes, uint32_t, hsize_t);
+        rec.addr = udata->addr = H5MF_alloc(idx_info->f, H5FD_MEM_DRAW, idx_info->dxpl_id, (hsize_t)udata->nbytes);
+
+	if(!H5F_addr_defined(udata->addr))
+	    HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "unable to allocate chunk")
+
+	/* Insert record for object in v2 B-tree */
+	if(H5B2_insert(bt2_cdset, idx_info->dxpl_id, &bt2_udata) < 0)                
+	    HGOTO_ERROR(H5E_DATASET, H5E_CANTINSERT, FAIL, "couldn't insert record in v2 B-tree")
+    } /* end else */
+    HDassert(H5F_addr_defined(udata->addr));
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5D_bt2_idx_insert() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5D_bt2_idx_get_addr
+ *
+ * Purpose:	Get the file address of a chunk if file space has been
+ *		assigned.  Save the retrieved information in the udata
+ *		supplied.
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_idx_get_addr(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *udata)
+{
+    H5B2_t 	*bt2_cdset = NULL;      /* v2 B-tree handle for indexing chunks */
+    unsigned	u;			/* Local index variable */
+    H5D_bt2_find_ud_t bt2_udata;
+    herr_t	ret_value = SUCCEED;	/* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5D_bt2_idx_get_addr)
+
+    HDassert(idx_info);
+    HDassert(idx_info->f);
+    HDassert(idx_info->pline);
+    HDassert(idx_info->layout);
+    HDassert(idx_info->layout->ndims > 0);
+    HDassert(idx_info->storage);
+    HDassert(H5F_addr_defined(idx_info->storage->idx_addr));
+    HDassert(udata);
+
+    if(NULL == idx_info->storage->u.btree2.bt2) {
+	/* Open existing v2 B-tree */
+        if(H5D_bt2_idx_open(idx_info) < 0)
+            HGOTO_ERROR(H5E_DATASET, H5E_CANTOPENOBJ, FAIL, "can't open v2 B-tree")
+    } /* end if */
+
+    bt2_cdset = idx_info->storage->u.btree2.bt2;
+
+    /* Check for filters on chunks */
+    if(idx_info->pline->nused > 0) { /* filtered chunk */
+	H5D_bt2_filt_rec_t search_rec;  /* Record for searching object */
+	H5D_bt2_filt_rec_t found_rec;  	/* Record found from searching for object */
+
+	/* Set the chunk offset to be searched for */
+	for(u = 0; u < (idx_info->layout->ndims - 1); u++)
+	    search_rec.offset[u] = udata->common.offset[u];
+
+	found_rec.addr = HADDR_UNDEF;
+	found_rec.nbytes = 0;
+	found_rec.filter_mask = 0;
+
+	/* Prepare user data for compare callback */
+	bt2_udata.rec = &search_rec;
+	bt2_udata.ndims = idx_info->layout->ndims - 1;
+
+	/* Go get chunk information from v2 B-tree */
+	if(H5B2_find(bt2_cdset, idx_info->dxpl_id, &bt2_udata, H5D_bt2_filt_found_cb, &found_rec) < 0)
+	    HGOTO_ERROR(H5E_HEAP, H5E_NOTFOUND, FAIL, "can't find object in v2 B-tree")
+
+	/* Set info for the chunk */
+        udata->addr = found_rec.addr;
+        udata->nbytes = found_rec.nbytes;
+        udata->filter_mask = found_rec.filter_mask;
+    } else { /* non-filtered chunk */
+	H5D_bt2_rec_t   search_rec; /* Record for searching object */
+	H5D_bt2_rec_t   found_rec;  /* Record found from searching for object */
+
+	/* Set the chunk offset to be searched for */
+	for(u = 0; u < (idx_info->layout->ndims - 1); u++)
+	    search_rec.offset[u] = udata->common.offset[u];
+
+	search_rec.addr = HADDR_UNDEF;
+	found_rec.addr = HADDR_UNDEF;
+
+	/* Prepare user data for compare callback */
+	bt2_udata.rec = &search_rec;
+	bt2_udata.ndims = idx_info->layout->ndims - 1;
+
+	/* Go get chunk information from v2 B-tree */
+	if(H5B2_find(bt2_cdset, idx_info->dxpl_id, &bt2_udata, H5D_bt2_found_cb, &found_rec) < 0)
+	    HGOTO_ERROR(H5E_HEAP, H5E_NOTFOUND, FAIL, "can't find object in v2 B-tree")
+
+	udata->addr = found_rec.addr;
+
+	/* Update the other (constant) information for the chunk */
+        udata->nbytes = idx_info->layout->size;
+        udata->filter_mask = 0;
+    }
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5D_bt2_idx_get_addr() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5D_bt2_idx_iterate_cb
+ *
+ * Purpose:	Translate the B-tree specific chunk record into a generic
+ *              form and make the callback to the generic chunk callback
+ *              routine.
+ * 		This is the callback for H5B2_iterate() which is called in 
+ *		H5D_bt2_idx_iterate().
+ *
+ * Return:	Success:	Non-negative
+ *		Failure:	Negative
+ *
+ * Programmer:	Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+/* ARGSUSED */
+static int
+H5D_bt2_idx_iterate_cb(const void *_record, void *_udata)
+{
+    H5D_bt2_it_ud_t	*udata = (H5D_bt2_it_ud_t *)_udata; /* User data */
+    unsigned u;		/* Local index variable */
+    int ret_value;      /* Return value */
+
+    FUNC_ENTER_NOAPI_NOERR(H5D_bt2_idx_iterate_cb, -)
+
+    /* Compose generic chunk record for callback */
+    if(udata->filtered) { /* filtered record */
+        const H5D_bt2_filt_rec_t *filt_rec = (const H5D_bt2_filt_rec_t *)_record;
+
+        udata->chunk_rec.chunk_addr = filt_rec->addr;
+        udata->chunk_rec.nbytes = filt_rec->nbytes;
+        udata->chunk_rec.filter_mask = filt_rec->filter_mask;
+	for(u = 0; u < (udata->common.layout->ndims - 1); u++)
+	    udata->chunk_rec.offset[u] = filt_rec->offset[u];
+    } else { /* non-filtered record */
+        const H5D_bt2_rec_t *rec = (const H5D_bt2_rec_t *)_record;
+
+        udata->chunk_rec.chunk_addr = rec->addr;
+        udata->chunk_rec.nbytes = udata->common.layout->size;
+        udata->chunk_rec.filter_mask = 0;
+	for(u = 0; u < (udata->common.layout->ndims - 1); u++)
+	    udata->chunk_rec.offset[u] = rec->offset[u];
+    }
+
+    /* Make "generic chunk" callback */
+    if((ret_value = (udata->cb)(&udata->chunk_rec, udata->udata)) < 0)
+        HERROR(H5E_DATASET, H5E_CALLBACK, "failure in generic chunk iterator callback");
+
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5D_bt2_idx_iterate_cb() */
+
+/*-------------------------------------------------------------------------
+ * Function:	H5D_bt2_idx_iterate
+ *
+ * Purpose:	Iterate over the chunks in an index, making a callback
+ *              for each one.
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+H5D_bt2_idx_iterate(const H5D_chk_idx_info_t *idx_info,
+    H5D_chunk_cb_func_t chunk_cb, void *chunk_udata)
+{
+    H5D_bt2_it_ud_t	udata; 	/* User data for B-tree iterator callback */
+    H5B2_t *bt2_cdset = NULL;	/* v2 B-tree handle for indexing chunks */
+    int ret_value;		/* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5D_bt2_idx_iterate)
+
+    HDassert(idx_info);
+    HDassert(idx_info->f);
+    HDassert(idx_info->pline);
+    HDassert(idx_info->layout);
+    HDassert(idx_info->storage);
+    HDassert(H5F_addr_defined(idx_info->storage->idx_addr));
+    HDassert(chunk_cb);
+    HDassert(chunk_udata);
+
+    /* Initialize user data */
+    HDmemset(&udata, 0, sizeof udata);
+    udata.common.layout = idx_info->layout;
+    udata.common.storage = idx_info->storage;
+    udata.filtered = idx_info->pline->nused > 0;
+    HDmemset(&udata.chunk_rec, 0, sizeof(udata.chunk_rec));
+
+    if(NULL == idx_info->storage->u.btree2.bt2) {
+	/* Open existing v2 B-tree */
+        if(H5D_bt2_idx_open(idx_info) < 0)
+            HGOTO_ERROR(H5E_DATASET, H5E_CANTOPENOBJ, FAIL, "can't open v2 B-tree")
+    } /* end if */
+
+    bt2_cdset = idx_info->storage->u.btree2.bt2;
+
+    udata.cb = chunk_cb;
+    udata.udata = chunk_udata;
+
+    /* Iterate over the records in the v2 B-tree */
+    if((ret_value = H5B2_iterate(bt2_cdset, idx_info->dxpl_id, H5D_bt2_idx_iterate_cb, &udata)) < 0)
+	HERROR(H5E_DATASET, H5E_BADITER, "unable to iterate over v2 B-tree for dataset chunks");
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5D_bt2_idx_iterate() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5D_bt2_remove_cb()
+ *
+ * Purpose:	Free space for 'dataset chunk' object as v2 B-tree
+ *             	is being deleted or v2 B-tree node is removed.
+ * 		This is the callback for H5B2_remove() and H5B2_delete() which 
+ *		which are called in H5D_bt2_idx_remove() and H5D_bt2_idx_delete().
+ *
+ * Return:	Success:	non-negative
+ *		Failure:	negative
+ *
+ * Programmer:	Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_remove_cb(const void *record, void *_udata)
+{
+    H5D_bt2_remove_ud_t *udata = (H5D_bt2_remove_ud_t *)_udata;	/* User data for removal callback */
+    herr_t ret_value = SUCCEED;         /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5D_bt2_remove_cb)
+
+    /* Free the space in the file for the object being removed */
+    H5_CHECK_OVERFLOW(udata->unfilt_size, uint32_t, hsize_t);
+    if(H5MF_xfree(udata->f, H5FD_MEM_DRAW, udata->dxpl_id, ((const H5D_bt2_rec_t *)record)->addr, (hsize_t)udata->unfilt_size) < 0)
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "unable to free chunk")
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5D_bt2_remove_cb() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5D_bt2_filt_remove_cb
+ *
+ * Purpose:	Free space for 'filtered dataset chunk' object as v2 B-tree
+ *              is being deleted or v2 B-tree node is removed
+ * 		This is the callback for H5B2_remove() and H5B2_delete() which 
+ *		which are called in H5D_bt2_idx_remove() and H5D_bt2_idx_delete().
+ *
+ * Return:	Success:	non-negative
+ *		Failure:	negative
+ *
+ * Programmer:	Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_filt_remove_cb(const void *_record, void *_udata)
+{
+    H5D_bt2_remove_ud_t *udata = (H5D_bt2_remove_ud_t *)_udata;			/* User data for removal callback */
+    const H5D_bt2_filt_rec_t *record = (const H5D_bt2_filt_rec_t *)_record;	/* The native record */
+    herr_t ret_value = SUCCEED;  	/* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5D_bt2_filt_remove_cb)
+
+    /* Free the space in the file for the object being removed */
+    H5_CHECK_OVERFLOW(record->nbytes, uint32_t, hsize_t);
+    if(H5MF_xfree(udata->f, H5FD_MEM_DRAW, udata->dxpl_id, record->addr, (hsize_t)record->nbytes) < 0)
+        HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to free chunk")
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5D_bt2_filt_remove_cb() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5D_bt2_idx_remove
+ *
+ * Purpose:	Remove chunk from index.
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_idx_remove(const H5D_chk_idx_info_t *idx_info, H5D_chunk_common_ud_t *udata)
+{
+    H5D_bt2_remove_ud_t remove_udata;	/* User data for removal callback */
+    H5B2_t 	*bt2_cdset = NULL;      /* v2 B-tree handle for indexing chunks */
+    H5D_bt2_find_ud_t bt2_udata;
+    unsigned 	u;			/* Local index variable */
+    herr_t	ret_value = SUCCEED;	/* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5D_bt2_idx_remove)
+
+    HDassert(idx_info);
+    HDassert(idx_info->f);
+    HDassert(idx_info->pline);
+    HDassert(idx_info->layout);
+    HDassert(idx_info->storage);
+    HDassert(H5F_addr_defined(idx_info->storage->idx_addr));
+    HDassert(udata);
+
+    if(NULL == idx_info->storage->u.btree2.bt2) {
+	/* Open existing v2 B-tree */
+        if(H5D_bt2_idx_open(idx_info) < 0)
+            HGOTO_ERROR(H5E_DATASET, H5E_CANTOPENOBJ, FAIL, "can't open v2 B-tree")
+    } /* end if */
+
+    bt2_cdset = idx_info->storage->u.btree2.bt2;
+
+    /* Initialize user data for removal callback */
+    remove_udata.f = idx_info->f;
+    remove_udata.dxpl_id = idx_info->dxpl_id;
+
+    /* Remove the record for the "dataset chunk" object from the v2 B-tree */
+    /* (space in the file for the object is freed in the 'remove' callback) */
+    if(idx_info->pline->nused > 0) { /* filtered chunk */
+	H5D_bt2_filt_rec_t   search_rec;	/* Record for searching for object */
+
+	/* Initialize the record to search for */
+	for(u = 0; u < (idx_info->layout->ndims - 1); u++)
+	    search_rec.offset[u] = udata->offset[u];
+
+	bt2_udata.rec = &search_rec;
+	bt2_udata.ndims = idx_info->layout->ndims - 1;
+
+	if(H5B2_remove(bt2_cdset, idx_info->dxpl_id, &bt2_udata, H5D_bt2_filt_remove_cb, &remove_udata) < 0)
+	    HGOTO_ERROR(H5E_DATASET, H5E_CANTREMOVE, FAIL, "can't remove object from B-tree")
+    } else { /* non-filtered chunk */
+	H5D_bt2_rec_t   search_rec; 	/* Record for searching for object */
+
+	remove_udata.unfilt_size = idx_info->layout->size;
+
+	/* Initialize the record to search for */
+	for(u = 0; u < (idx_info->layout->ndims - 1); u++)
+	    search_rec.offset[u] = udata->offset[u];
+
+	bt2_udata.rec = &search_rec;
+	bt2_udata.ndims = idx_info->layout->ndims - 1;
+
+	if(H5B2_remove(bt2_cdset, idx_info->dxpl_id, &bt2_udata, H5D_bt2_remove_cb, &remove_udata) < 0)
+	    HGOTO_ERROR(H5E_DATASET, H5E_CANTREMOVE, FAIL, "can't remove object from B-tree")
+    } /* end else */
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5D_bt2_idx_remove() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5D_bt2_idx_delete
+ *
+ * Purpose:	Delete index and raw data storage for entire dataset
+ *              (i.e. all chunks)
+ *
+ * Return:	Success:	Non-negative
+ *		Failure:	negative
+ *
+ * Programmer:	Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_idx_delete(const H5D_chk_idx_info_t *idx_info)
+{
+    H5D_bt2_remove_ud_t remove_udata;	/* User data for removal callback */
+    H5B2_remove_t remove_op;		/* The removal callback */
+    H5D_bt2_ctx_ud_t u_ctx;		/* data for context call */
+    herr_t ret_value = SUCCEED;     	/* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5D_bt2_idx_delete)
+
+    /* Sanity checks */
+    HDassert(idx_info);
+    HDassert(idx_info->f);
+    HDassert(idx_info->pline);
+    HDassert(idx_info->layout);
+    HDassert(idx_info->storage);
+
+    /* Check if the index data structure has been allocated */
+    if(H5F_addr_defined(idx_info->storage->idx_addr)) {
+
+	/* Set up user data for creating context */
+	u_ctx.f = idx_info->f;
+	u_ctx.ndims = idx_info->layout->ndims - 1;
+	u_ctx.chunk_size = idx_info->layout->size;
+
+	/* Initialize user data for removal callback */
+	remove_udata.f = idx_info->f;
+	remove_udata.dxpl_id = idx_info->dxpl_id;
+
+	remove_op = idx_info->pline->nused > 0 ? H5D_bt2_filt_remove_cb : H5D_bt2_remove_cb;
+
+	/* Delete the v2 B-tree */
+	/*(space in the file for each object is freed in the 'remove' callback) */
+	if(H5B2_delete(idx_info->f, idx_info->dxpl_id, idx_info->storage->idx_addr, &u_ctx, remove_op, &remove_udata) < 0)
+	    HGOTO_ERROR(H5E_DATASET, H5E_CANTDELETE, FAIL, "can't delete v2 B-tree")
+
+	idx_info->storage->idx_addr = HADDR_UNDEF;
+    } /* end if */
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5D_bt2_idx_delete() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5D_bt2_idx_copy_setup
+ *
+ * Purpose:	Set up any necessary information for copying chunks
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_idx_copy_setup(const H5D_chk_idx_info_t *idx_info_src,
+    const H5D_chk_idx_info_t *idx_info_dst)
+{
+    herr_t      ret_value = SUCCEED;        /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5D_bt2_idx_copy_setup)
+
+    /* Source file */
+    HDassert(idx_info_src);
+    HDassert(idx_info_src->f);
+    HDassert(idx_info_src->pline);
+    HDassert(idx_info_src->layout);
+    HDassert(idx_info_src->storage);
+
+    /* Destination file */
+    HDassert(idx_info_dst);
+    HDassert(idx_info_dst->f);
+    HDassert(idx_info_dst->pline);
+    HDassert(idx_info_dst->layout);
+    HDassert(idx_info_dst->storage);
+    HDassert(!H5F_addr_defined(idx_info_dst->storage->idx_addr));
+
+    /* Check if the source v2 B-tree is open yet */
+    if(NULL == idx_info_src->storage->u.btree2.bt2) {
+        if(H5D_bt2_idx_open(idx_info_src) < 0)
+            HGOTO_ERROR(H5E_DATASET, H5E_CANTOPENOBJ, FAIL, "can't open v2 B-tree")
+    } /* end if */
+
+    /* Set copied metadata tag */
+    H5_BEGIN_TAG(idx_info_dst->dxpl_id, H5AC__COPIED_TAG, FAIL);
+
+    /* Create v2 B-tree that describes the chunked dataset in the destination file */
+    if(H5D_bt2_idx_create(idx_info_dst) < 0)
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to initialize chunked storage")
+    HDassert(H5F_addr_defined(idx_info_dst->storage->idx_addr));
+    
+    /* Reset metadata tag */
+    H5_END_TAG(FAIL);
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5D_bt2_idx_copy_setup() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5D_bt2_idx_copy_shutdown
+ *
+ * Purpose:	Shutdown any information from copying chunks
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_idx_copy_shutdown(H5O_storage_chunk_t *storage_src,
+    H5O_storage_chunk_t *storage_dst, hid_t UNUSED dxpl_id)
+{
+    herr_t      ret_value = SUCCEED;       /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5D_bt2_idx_copy_shutdown)
+
+    /* Check args */
+    HDassert(storage_src);
+    HDassert(storage_src->u.btree2.bt2);
+    HDassert(storage_dst);
+    HDassert(storage_dst->u.btree2.bt2);
+
+    /* Close v2 B-tree for source file */
+    if(H5B2_close(storage_src->u.btree2.bt2, dxpl_id) < 0)
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, FAIL, "unable to close v2 B-tree")
+    storage_src->u.btree2.bt2 = NULL;
+
+    /* Close v2 B-tree for destination file */
+    if(H5B2_close(storage_dst->u.btree2.bt2, dxpl_id) < 0)
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, FAIL, "unable to close v2 B-tree")
+    storage_dst->u.btree2.bt2 = NULL;
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5D_bt2_idx_copy_shutdown() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5D_bt2_idx_size
+ *
+ * Purpose:     Retrieve the amount of index storage for chunked dataset
+ *
+ * Return:      Success:        Non-negative
+ *              Failure:        negative
+ *
+ * Programmer:  Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_idx_size(const H5D_chk_idx_info_t *idx_info, hsize_t *index_size)
+{
+    H5B2_t *bt2_cdset = NULL;		/* Pointer to v2 B-tree structure */
+    herr_t ret_value = SUCCEED;         /* Return value */
+
+    FUNC_ENTER_NOAPI(H5D_bt2_idx_size, FAIL)
+
+    /* Check args */
+    HDassert(idx_info);
+    HDassert(idx_info->f);
+    HDassert(idx_info->pline);
+    HDassert(idx_info->layout);
+    HDassert(idx_info->storage);
+    HDassert(H5F_addr_defined(idx_info->storage->idx_addr));
+    HDassert(index_size);
+
+    /* Open v2 B-tree */
+    if(H5D_bt2_idx_open(idx_info) < 0)
+	HGOTO_ERROR(H5E_DATASET, H5E_CANTOPENOBJ, FAIL, "can't open v2 B-tree")
+
+    /* Set convenience pointer to v2 B-tree structure */
+    bt2_cdset = idx_info->storage->u.btree2.bt2;
+
+    /* Get v2 B-tree size for indexing chunked dataset */
+    if(H5B2_size(bt2_cdset, idx_info->dxpl_id, index_size) < 0)
+	HGOTO_ERROR(H5E_SYM, H5E_CANTGET, FAIL, "can't retrieve v2 B-tree storage info for chunked dataset")
+done:
+    /* Close v2 B-tree index */
+    if(bt2_cdset && H5B2_close(bt2_cdset, idx_info->dxpl_id) < 0)
+        HDONE_ERROR(H5E_SYM, H5E_CLOSEERROR, FAIL, "can't close v2 B-tree for tracking chunked dataset")
+    idx_info->storage->u.btree2.bt2 = NULL;
+
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5D_bt2_idx_size() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5D_bt2_idx_reset
+ *
+ * Purpose:	Reset indexing information.
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_idx_reset(H5O_storage_chunk_t *storage, hbool_t reset_addr)
+{
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_bt2_idx_reset)
+
+    HDassert(storage);
+
+    /* Reset index info */
+    if(reset_addr)
+	storage->idx_addr = HADDR_UNDEF;
+    storage->u.btree2.bt2 = NULL;
+    
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* end H5D_bt2_idx_reset() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5D_bt2_idx_dump
+ *
+ * Purpose:	Dump indexing information to a stream.
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_idx_dump(const H5O_storage_chunk_t *storage, FILE *stream)
+{
+    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5D_bt2_idx_dump)
+
+    HDassert(storage);
+    HDassert(stream);
+
+    HDfprintf(stream, "    Address: %a\n", storage->idx_addr);
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* end H5D_bt2_idx_dump() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5D_bt2_idx_dest
+ *
+ * Purpose:	Release indexing information in memory.
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Vailin Choi; June 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D_bt2_idx_dest(const H5D_chk_idx_info_t *idx_info)
+{
+    herr_t      ret_value = SUCCEED;       /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT(H5D_bt2_idx_dest)
+
+    /* Check args */
+    HDassert(idx_info);
+    HDassert(idx_info->f);
+    HDassert(idx_info->storage);
+
+    /* Check if the v2-btree is open */
+    if(idx_info->storage->u.btree2.bt2) {
+        /* Close v2 B-tree */
+	if(H5B2_close(idx_info->storage->u.btree2.bt2, idx_info->dxpl_id) < 0)
+            HGOTO_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, FAIL, "can't close v2 B-tree")
+        idx_info->storage->u.btree2.bt2 = NULL;
+    } /* end if */
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5D_bt2_idx_dest() */
+
diff --git a/src/H5Dchunk.c b/src/H5Dchunk.c
index 0deb578..e70a7b0 100644
--- a/src/H5Dchunk.c
+++ b/src/H5Dchunk.c
@@ -464,6 +464,10 @@ done:
  * Programmer:	Robb Matzke
  *              Monday, May 18, 1998
  *
+ * Modifications:
+ *	Vailin Choi; August 2010
+ *	Added v2-btree indexing
+ *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -483,6 +487,8 @@ H5D_chunk_init(H5F_t *f, hid_t dxpl_id, const H5D_t *dset, hid_t dapl_id)
                 H5D_COPS_EARRAY == dset->shared->layout.storage.u.chunk.ops) ||
             (H5D_CHUNK_IDX_FARRAY == dset->shared->layout.storage.u.chunk.idx_type && 
                 H5D_COPS_FARRAY == dset->shared->layout.storage.u.chunk.ops) ||
+	    (H5D_CHUNK_IDX_BT2 == dset->shared->layout.storage.u.chunk.idx_type &&
+                H5D_COPS_BT2 == dset->shared->layout.storage.u.chunk.ops) ||
             (H5D_CHUNK_IDX_BTREE == dset->shared->layout.storage.u.chunk.idx_type && 
                 H5D_COPS_BTREE == dset->shared->layout.storage.u.chunk.ops));
 
@@ -547,6 +553,10 @@ done:
  * Programmer:	Quincey Koziol
  *              Thursday, January 15, 2009
  *
+ * Modifications:
+ *	Vailin Choi; August 2010
+ *	Added v2-btree indexing
+ *
  *-------------------------------------------------------------------------
  */
 hbool_t
@@ -562,6 +572,8 @@ H5D_chunk_is_space_alloc(const H5O_storage_t *storage)
                 H5D_COPS_EARRAY == storage->u.chunk.ops) ||
             (H5D_CHUNK_IDX_FARRAY == storage->u.chunk.idx_type && 
                 H5D_COPS_FARRAY == storage->u.chunk.ops) ||
+	    (H5D_CHUNK_IDX_BT2 == storage->u.chunk.idx_type &&
+                H5D_COPS_BT2 == storage->u.chunk.ops) ||
             (H5D_CHUNK_IDX_BTREE == storage->u.chunk.idx_type && 
                 H5D_COPS_BTREE == storage->u.chunk.ops));
 
@@ -2044,6 +2056,10 @@ done:
  * Programmer:	Quincey Koziol
  *              Thursday, January 15, 2009
  *
+ * Modifications:
+ *	Vailin Choi; August 2010
+ *	Added v2-btree indexing
+ *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -2060,6 +2076,8 @@ H5D_chunk_idx_reset(H5O_storage_chunk_t *storage, hbool_t reset_addr)
                 H5D_COPS_EARRAY == storage->ops) ||
             (H5D_CHUNK_IDX_FARRAY == storage->idx_type && 
                 H5D_COPS_FARRAY == storage->ops) ||
+	    (H5D_CHUNK_IDX_BT2 == storage->idx_type &&
+                H5D_COPS_BT2 == storage->ops) ||
             (H5D_CHUNK_IDX_BTREE == storage->idx_type && 
                 H5D_COPS_BTREE == storage->ops));
 
@@ -2201,6 +2219,10 @@ done:
  * Programmer:	Quincey Koziol
  *		Thursday, May 22, 2008
  *
+ * Modifications:
+ *	Vailin Choi; August 2010
+ *	Added v2-btree indexing
+ *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -2219,6 +2241,8 @@ H5D_chunk_create(H5D_t *dset /*in,out*/, hid_t dxpl_id)
                 H5D_COPS_EARRAY == dset->shared->layout.storage.u.chunk.ops) ||
             (H5D_CHUNK_IDX_FARRAY == dset->shared->layout.storage.u.chunk.idx_type && 
                 H5D_COPS_FARRAY == dset->shared->layout.storage.u.chunk.ops) ||
+	    (H5D_CHUNK_IDX_BT2 == dset->shared->layout.storage.u.chunk.idx_type &&
+                H5D_COPS_BT2 == dset->shared->layout.storage.u.chunk.ops) ||
             (H5D_CHUNK_IDX_BTREE == dset->shared->layout.storage.u.chunk.idx_type && 
                 H5D_COPS_BTREE == dset->shared->layout.storage.u.chunk.ops));
 #ifndef NDEBUG
@@ -2257,6 +2281,10 @@ done:
  * Programmer:	Albert Cheng
  *              June 27, 1998
  *
+ * Modifications:
+ *	Vailin Choi; August 2010
+ *	Added v2-btree indexing
+ *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -2276,6 +2304,8 @@ H5D_chunk_lookup(const H5D_t *dset, hid_t dxpl_id, const hsize_t *chunk_offset,
                 H5D_COPS_EARRAY == dset->shared->layout.storage.u.chunk.ops) ||
             (H5D_CHUNK_IDX_FARRAY == dset->shared->layout.storage.u.chunk.idx_type && 
                 H5D_COPS_FARRAY == dset->shared->layout.storage.u.chunk.ops) ||
+	    (H5D_CHUNK_IDX_BT2 == dset->shared->layout.storage.u.chunk.idx_type &&
+                H5D_COPS_BT2 == dset->shared->layout.storage.u.chunk.ops) ||
             (H5D_CHUNK_IDX_BTREE == dset->shared->layout.storage.u.chunk.idx_type && 
                 H5D_COPS_BTREE == dset->shared->layout.storage.u.chunk.ops));
     HDassert(chunk_offset);
@@ -2350,6 +2380,10 @@ done:
  * Programmer:	Robb Matzke
  *              Thursday, May 21, 1998
  *
+ * Modifications:
+ *	Vailin Choi; August 2010
+ *	Added v2-btree indexing
+ *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -2368,6 +2402,8 @@ H5D_chunk_flush_entry(const H5D_t *dset, hid_t dxpl_id, const H5D_dxpl_cache_t *
                 H5D_COPS_EARRAY == dset->shared->layout.storage.u.chunk.ops) ||
             (H5D_CHUNK_IDX_FARRAY == dset->shared->layout.storage.u.chunk.idx_type && 
                 H5D_COPS_FARRAY == dset->shared->layout.storage.u.chunk.ops) ||
+	    (H5D_CHUNK_IDX_BT2 == dset->shared->layout.storage.u.chunk.idx_type &&
+                H5D_COPS_BT2 == dset->shared->layout.storage.u.chunk.ops) ||
             (H5D_CHUNK_IDX_BTREE == dset->shared->layout.storage.u.chunk.idx_type && 
                 H5D_COPS_BTREE == dset->shared->layout.storage.u.chunk.ops));
     HDassert(dxpl_cache);
@@ -3279,6 +3315,10 @@ H5D_chunk_allocated_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
  * Programmer:	Quincey Koziol
  *              Tuesday, May 20, 2008
  *
+ * Modifications:
+ *	Vailin Choi; August 2010
+ *	Added v2-btree indexing
+ *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -3300,6 +3340,8 @@ H5D_chunk_allocated(H5D_t *dset, hid_t dxpl_id, hsize_t *nbytes)
                 H5D_COPS_EARRAY == dset->shared->layout.storage.u.chunk.ops) ||
             (H5D_CHUNK_IDX_FARRAY == dset->shared->layout.storage.u.chunk.idx_type && 
                 H5D_COPS_FARRAY == dset->shared->layout.storage.u.chunk.ops) ||
+	    (H5D_CHUNK_IDX_BT2 == dset->shared->layout.storage.u.chunk.idx_type &&
+                H5D_COPS_BT2 == dset->shared->layout.storage.u.chunk.ops) ||
             (H5D_CHUNK_IDX_BTREE == dset->shared->layout.storage.u.chunk.idx_type && 
                 H5D_COPS_BTREE == dset->shared->layout.storage.u.chunk.ops));
 
@@ -3345,6 +3387,10 @@ done:
  * Programmer:	Albert Cheng
  *		June 26, 1998
  *
+ * Modifications:
+ *	Vailin Choi; August 2010
+ *	Added v2-btree indexing
+ *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -3399,6 +3445,8 @@ H5D_chunk_allocate(H5D_t *dset, hid_t dxpl_id, hbool_t full_overwrite,
                 H5D_COPS_EARRAY == layout->storage.u.chunk.ops) ||
             (H5D_CHUNK_IDX_FARRAY == layout->storage.u.chunk.idx_type && 
                 H5D_COPS_FARRAY == layout->storage.u.chunk.ops) ||
+	    (H5D_CHUNK_IDX_BT2 == layout->storage.u.chunk.idx_type &&
+                H5D_COPS_BT2 == layout->storage.u.chunk.ops) ||
             (H5D_CHUNK_IDX_BTREE == layout->storage.u.chunk.idx_type && 
                 H5D_COPS_BTREE == layout->storage.u.chunk.ops));
     HDassert(TRUE == H5P_isa_class(dxpl_id, H5P_DATASET_XFER));
@@ -3846,6 +3894,8 @@ H5D_chunk_update_old_edge_chunks(H5D_t *dset, hid_t dxpl_id, hsize_t old_dim[])
                 H5D_COPS_EARRAY == layout->storage.u.chunk.ops) ||
             (H5D_CHUNK_IDX_FARRAY == layout->storage.u.chunk.idx_type &&
                 H5D_COPS_FARRAY == layout->storage.u.chunk.ops) ||
+	    (H5D_CHUNK_IDX_BT2 == layout->storage.u.chunk.idx_type &&
+                H5D_COPS_BT2 == layout->storage.u.chunk.ops) ||
             (H5D_CHUNK_IDX_BTREE == layout->storage.u.chunk.idx_type &&
                 H5D_COPS_BTREE == layout->storage.u.chunk.ops));
     HDassert(TRUE == H5P_isa_class(dxpl_id, H5P_DATASET_XFER));
@@ -4214,6 +4264,9 @@ done:
  * To release the chunks, we traverse the B-tree to obtain a list of unused
  * allocated chunks, and then call H5B_remove() for each chunk.
  *
+ *	Vailin Choi; August 2010
+ *	Added v2-btree indexing
+ *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -4264,6 +4317,8 @@ H5D_chunk_prune_by_extent(H5D_t *dset, hid_t dxpl_id, const hsize_t *old_dim)
                 H5D_COPS_EARRAY == layout->storage.u.chunk.ops) ||
             (H5D_CHUNK_IDX_FARRAY == layout->storage.u.chunk.idx_type && 
                 H5D_COPS_FARRAY == layout->storage.u.chunk.ops) ||
+	    (H5D_CHUNK_IDX_BT2 == layout->storage.u.chunk.idx_type &&
+                H5D_COPS_BT2 == layout->storage.u.chunk.ops) ||
             (H5D_CHUNK_IDX_BTREE == layout->storage.u.chunk.idx_type && 
                 H5D_COPS_BTREE == layout->storage.u.chunk.ops));
     HDassert(dxpl_cache);
@@ -4441,7 +4496,7 @@ H5D_chunk_prune_by_extent(H5D_t *dset, hid_t dxpl_id, const hsize_t *old_dim)
                     dims_outside_fill[i] = FALSE;
 
             carry = FALSE;
-        } /* end if */
+         } /* end if */
 
         while(!carry) {
             /* Calculate the index of this chunk */
@@ -4629,6 +4684,10 @@ done:
  * Programmer:  Kent Yang
  *              November 15, 2005
  *
+ * Modifications:
+ *	Vailin Choi; August 2010
+ *	Added v2-btree indexing
+ *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -4647,6 +4706,8 @@ H5D_chunk_addrmap(const H5D_io_info_t *io_info, haddr_t chunk_addr[])
                 H5D_COPS_EARRAY == dset->shared->layout.storage.u.chunk.ops) ||
             (H5D_CHUNK_IDX_FARRAY == dset->shared->layout.storage.u.chunk.idx_type && 
                 H5D_COPS_FARRAY == dset->shared->layout.storage.u.chunk.ops) ||
+	    (H5D_CHUNK_IDX_BT2 == dset->shared->layout.storage.u.chunk.idx_type &&
+                H5D_COPS_BT2 == dset->shared->layout.storage.u.chunk.ops) ||
             (H5D_CHUNK_IDX_BTREE == dset->shared->layout.storage.u.chunk.idx_type && 
                 H5D_COPS_BTREE == dset->shared->layout.storage.u.chunk.ops));
     HDassert(chunk_addr);
@@ -4685,6 +4746,10 @@ done:
  * Programmer:	Quincey Koziol
  *              Thursday, March 20, 2003
  *
+ * Modifications:
+ *	Vailin Choi; August 2010
+ *	Added v2-btree indexing
+ *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -4708,6 +4773,8 @@ H5D_chunk_delete(H5F_t *f, hid_t dxpl_id, H5O_t *oh, H5O_storage_t *storage)
                 H5D_COPS_EARRAY == storage->u.chunk.ops) ||
             (H5D_CHUNK_IDX_FARRAY == storage->u.chunk.idx_type && 
                 H5D_COPS_FARRAY == storage->u.chunk.ops) ||
+	    (H5D_CHUNK_IDX_BT2 == storage->u.chunk.idx_type &&
+                H5D_COPS_BT2 == storage->u.chunk.ops) ||
             (H5D_CHUNK_IDX_BTREE == storage->u.chunk.idx_type && 
                 H5D_COPS_BTREE == storage->u.chunk.ops));
 
@@ -5049,6 +5116,9 @@ done:
  * Programmer:  Peter Cao
  *	        August 20, 2005
  *
+ *	Vailin Choi; August 2010
+ *	Added v2-btree indexing
+ *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -5090,6 +5160,8 @@ H5D_chunk_copy(H5F_t *f_src, H5O_storage_chunk_t *storage_src,
                 H5D_COPS_EARRAY == storage_src->ops) ||
             (H5D_CHUNK_IDX_FARRAY == storage_src->idx_type && 
                 H5D_COPS_FARRAY == storage_src->ops) ||
+	    (H5D_CHUNK_IDX_BT2 == storage_src->idx_type &&
+                H5D_COPS_BT2 == storage_src->ops) ||
             (H5D_CHUNK_IDX_BTREE == storage_src->idx_type && 
                 H5D_COPS_BTREE == storage_src->ops));
     HDassert(layout_src);
@@ -5099,6 +5171,8 @@ H5D_chunk_copy(H5F_t *f_src, H5O_storage_chunk_t *storage_src,
                 H5D_COPS_EARRAY == storage_dst->ops) ||
             (H5D_CHUNK_IDX_FARRAY == storage_dst->idx_type && 
                 H5D_COPS_FARRAY == storage_dst->ops) ||
+	    (H5D_CHUNK_IDX_BT2 == storage_dst->idx_type &&
+                H5D_COPS_BT2 == storage_dst->ops) ||
             (H5D_CHUNK_IDX_BTREE == storage_dst->idx_type && 
                 H5D_COPS_BTREE == storage_dst->ops));
     HDassert(ds_extent_src);
@@ -5324,6 +5398,10 @@ done:
  * Programmer:  Vailin Choi
  *              June 8, 2007
  *
+ * Modifications:
+ *	Vailin Choi; August 2010
+ *	Added v2-btree indexing
+ *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -5342,6 +5420,8 @@ H5D_chunk_bh_info(H5F_t *f, hid_t dxpl_id, H5O_layout_t *layout,
                 H5D_COPS_EARRAY == layout->storage.u.chunk.ops) ||
             (H5D_CHUNK_IDX_FARRAY == layout->storage.u.chunk.idx_type && 
                 H5D_COPS_FARRAY == layout->storage.u.chunk.ops) ||
+	    (H5D_CHUNK_IDX_BT2 == layout->storage.u.chunk.idx_type &&
+                H5D_COPS_BT2 == layout->storage.u.chunk.ops) ||
             (H5D_CHUNK_IDX_BTREE == layout->storage.u.chunk.idx_type && 
                 H5D_COPS_BTREE == layout->storage.u.chunk.ops));
     HDassert(pline);
@@ -5421,6 +5501,10 @@ H5D_chunk_dump_index_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
  * Programmer:	Robb Matzke
  *              Wednesday, April 28, 1999
  *
+ * Modifications:
+ *	Vailin Choi; August 2010
+ *	Added v2-btree indexing
+ *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -5436,6 +5520,8 @@ H5D_chunk_dump_index(H5D_t *dset, hid_t dxpl_id, FILE *stream)
                 H5D_COPS_EARRAY == dset->shared->layout.storage.u.chunk.ops) ||
             (H5D_CHUNK_IDX_FARRAY == dset->shared->layout.storage.u.chunk.idx_type && 
                 H5D_COPS_FARRAY == dset->shared->layout.storage.u.chunk.ops) ||
+	    (H5D_CHUNK_IDX_BT2 == dset->shared->layout.storage.u.chunk.idx_type &&
+                H5D_COPS_BT2 == dset->shared->layout.storage.u.chunk.ops) ||
             (H5D_CHUNK_IDX_BTREE == dset->shared->layout.storage.u.chunk.idx_type && 
                 H5D_COPS_BTREE == dset->shared->layout.storage.u.chunk.ops));
 
@@ -5481,6 +5567,10 @@ done:
  * Programmer:	Robb Matzke
  *              Thursday, May 21, 1998
  *
+ * Modifications:
+ *	Vailin Choi; August 2010
+ *	Added v2-btree indexing
+ *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -5502,6 +5592,8 @@ H5D_chunk_dest(H5F_t *f, hid_t dxpl_id, H5D_t *dset)
                 H5D_COPS_EARRAY == dset->shared->layout.storage.u.chunk.ops) ||
             (H5D_CHUNK_IDX_FARRAY == dset->shared->layout.storage.u.chunk.idx_type && 
                 H5D_COPS_FARRAY == dset->shared->layout.storage.u.chunk.ops) ||
+	    (H5D_CHUNK_IDX_BT2 == dset->shared->layout.storage.u.chunk.idx_type &&
+                H5D_COPS_BT2 == dset->shared->layout.storage.u.chunk.ops) ||
             (H5D_CHUNK_IDX_BTREE == dset->shared->layout.storage.u.chunk.idx_type && 
                 H5D_COPS_BTREE == dset->shared->layout.storage.u.chunk.ops));
 
diff --git a/src/H5Dint.c b/src/H5Dint.c
index 8c4d8cd..381323c 100644
--- a/src/H5Dint.c
+++ b/src/H5Dint.c
@@ -1116,6 +1116,7 @@ H5D_create(H5F_t *file, hid_t type_id, const H5S_t *space, hid_t dcpl_id,
             HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, NULL, "can't retrieve external file list")
     } /* end if */
 
+
     /* Set the latest version of the layout, pline & fill messages, if requested */
     if(H5F_USE_LATEST_FORMAT(file)) {
         /* Set the latest version for the I/O pipeline message */
@@ -1129,7 +1130,11 @@ H5D_create(H5F_t *file, hid_t type_id, const H5S_t *space, hid_t dcpl_id,
         /* Set the latest version for the layout message */
         if(H5D_layout_set_latest_version(&new_dset->shared->layout, new_dset->shared->space) < 0)
             HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, NULL, "can't set latest version of layout")
-    } /* end if */
+    } else if(new_dset->shared->layout.version >= H5O_LAYOUT_VERSION_4) {
+	/* Use latest indexing type for layout message version >= 4 */
+        if(H5D_layout_set_latest_indexing(&new_dset->shared->layout, new_dset->shared->space) < 0)
+            HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, NULL, "can't set latest indexing")
+    }
 
     /* Check if this dataset is going into a parallel file and set space allocation time */
     if(IS_H5FD_MPI(file))
diff --git a/src/H5Dlayout.c b/src/H5Dlayout.c
index 1505f0e..bc3a77f 100644
--- a/src/H5Dlayout.c
+++ b/src/H5Dlayout.c
@@ -71,6 +71,9 @@
  * Programmer:	Quincey Koziol
  *		Thursday, March 20, 2008
  *
+ * Modifications:
+ *	Vailin Choi; August 2010
+ *	Added v2 B-tree indexing.
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -101,6 +104,10 @@ H5D_layout_set_io_ops(const H5D_t *dataset)
                     dataset->shared->layout.storage.u.chunk.ops = H5D_COPS_BTREE;
                     break;
 
+		case H5D_CHUNK_IDX_BT2:
+                    dataset->shared->layout.storage.u.chunk.ops = H5D_COPS_BT2;
+                    break;
+
                 case H5D_CHUNK_IDX_FARRAY:
                     dataset->shared->layout.storage.u.chunk.ops = H5D_COPS_FARRAY;
                     break;
@@ -143,6 +150,10 @@ done:
  * Programmer:  Raymond Lu
  *              August 14, 2002
  *
+ * Modifications:
+ *	Vailin Choi; August 2010
+ *	Added v2 B-tree indexing.
+ *	Removed v1 B-tree support for layout message version >= 4.
  *-------------------------------------------------------------------------
  */
 size_t
@@ -209,18 +220,19 @@ H5D_layout_meta_size(const H5F_t *f, const H5O_layout_t *layout, hbool_t include
                 ret_value++;
 
                 switch(layout->u.chunk.idx_type) {
-                    case H5D_CHUNK_IDX_BTREE:   /* Remove this when v2 B-tree indices added */
-                        /* Nothing to do */
+		    case H5D_CHUNK_IDX_BT2:
+                        /* v2 B-tree creation parameters */
+                        ret_value += H5D_BT2_CREATE_PARAM_SIZE;
                         break;
 
                     case H5D_CHUNK_IDX_FARRAY:
                         /* Fixed array creation parameters */
-                        ret_value += 1;
+                        ret_value += H5D_FARRAY_CREATE_PARAM_SIZE;
                         break;
 
                     case H5D_CHUNK_IDX_EARRAY:
                         /* Extensible array creation parameters */
-                        ret_value += 5;
+                        ret_value += H5D_EARRAY_CREATE_PARAM_SIZE;
                         break;
 
                     default:
@@ -244,6 +256,42 @@ done:
  * Function:    H5D_layout_set_latest_version
  *
  * Purpose:     Set the encoding for a layout to the latest version.
+ *		Part of the coding in this routine is moved to
+ *		H5D_layout_set_latest_indexing().
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:  Quincey Koziol
+ *              Thursday, January 15, 2009
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5D_layout_set_latest_version(H5O_layout_t *layout, const H5S_t *space)
+{
+    herr_t ret_value = SUCCEED;         /* Return value */
+
+    FUNC_ENTER_NOAPI(H5D_layout_set_latest_version, FAIL)
+
+    /* Sanity check */
+    HDassert(layout);
+
+    /* Set encoding of layout to latest version */
+    layout->version = H5O_LAYOUT_VERSION_LATEST;
+
+    /* Set the latest indexing type for the layout message */
+    ret_value = H5D_layout_set_latest_indexing(layout, space);
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5D_layout_set_latest_version() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5D_layout_set_latest_indexing
+ *
+ * Purpose:     Set the latest indexing type for a layout message
+ *		This is moved from H5D_layout_set_latest_version().
  *
  * Return:	Non-negative on success/Negative on failure
  *
@@ -255,23 +303,22 @@ done:
  *	Modified to use Fixed Array indexing for extendible chunked dataset.
  *	(fixed max. dim. setting but exclude H5S_UNLIMITED)
  *
+ *	Vailin Choi; August 2010
+ *	Added v2 B-tree indexing for chunked dataset >1 unlimited dimensions.
  *-------------------------------------------------------------------------
  */
 herr_t
-H5D_layout_set_latest_version(H5O_layout_t *layout, const H5S_t *space)
+H5D_layout_set_latest_indexing(H5O_layout_t *layout, const H5S_t *space)
 {
     int sndims;                         /* Rank of dataspace */
     unsigned ndims;                     /* Rank of dataspace */
     herr_t ret_value = SUCCEED;         /* Return value */
 
-    FUNC_ENTER_NOAPI(H5D_layout_set_latest_version, FAIL)
+    FUNC_ENTER_NOAPI(H5D_layout_set_latest_indexing, FAIL)
 
     /* Sanity check */
     HDassert(layout);
 
-    /* Set encoding of layout to latest version */
-    layout->version = H5O_LAYOUT_VERSION_LATEST;
-
     /* Query the dimensionality of the dataspace */
     if((sndims = H5S_GET_EXTENT_NDIMS(space)) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "invalid dataspace rank")
@@ -299,6 +346,7 @@ H5D_layout_set_latest_version(H5O_layout_t *layout, const H5S_t *space)
                 HGOTO_ERROR(H5E_DATASET, H5E_BADTYPE, FAIL, "dataset with unlimited dimensions is not chunked")
 
 	    if(1 == unlim_count) { /* Chunked dataset with only 1 unlimited dimension */
+		/* Set the chunk index type to an extensible array */
 		layout->u.chunk.idx_type = H5D_CHUNK_IDX_EARRAY;
 		layout->storage.u.chunk.idx_type = H5D_CHUNK_IDX_EARRAY;
 		layout->storage.u.chunk.ops = H5D_COPS_EARRAY;
@@ -313,8 +361,16 @@ H5D_layout_set_latest_version(H5O_layout_t *layout, const H5S_t *space)
 		layout->u.chunk.u.earray.cparam.data_blk_min_elmts = H5D_EARRAY_DATA_BLK_MIN_ELMTS;
 		layout->u.chunk.u.earray.cparam.max_dblk_page_nelmts_bits = H5D_EARRAY_MAX_DBLOCK_PAGE_NELMTS_BITS;
 	    } else { /* Chunked dataset with > 1 unlimited dimensions */
-		/* Add setup to use v2 B-tree chunk indices here */
-	    }
+                /* Set the chunk index type to v2 B-tree */
+                layout->u.chunk.idx_type = H5D_CHUNK_IDX_BT2;
+                layout->storage.u.chunk.idx_type = H5D_CHUNK_IDX_BT2;
+                layout->storage.u.chunk.ops = H5D_COPS_BT2;
+
+		/* Set the v2 B-tree creation parameters */
+		layout->u.chunk.u.btree2.cparam.node_size = H5D_BT2_NODE_SIZE;
+		layout->u.chunk.u.btree2.cparam.split_percent = H5D_BT2_SPLIT_PERC;
+		layout->u.chunk.u.btree2.cparam.merge_percent =  H5D_BT2_MERGE_PERC;
+            }
         } else if(layout->type == H5D_CHUNKED) {
 	    /* Chunked dataset with fixed dimensions (with or without max. dimension setting)  */
             /* Set the chunk index type to Fixed Array */
@@ -332,7 +388,7 @@ H5D_layout_set_latest_version(H5O_layout_t *layout, const H5S_t *space)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5D_layout_set_latest_version() */
+} /* end H5D_layout_set_latest_indexing() */
 
 
 /*-------------------------------------------------------------------------
diff --git a/src/H5Dpkg.h b/src/H5Dpkg.h
index 63cc010..fa7eacf 100644
--- a/src/H5Dpkg.h
+++ b/src/H5Dpkg.h
@@ -34,6 +34,7 @@
 /* Other private headers needed by this file */
 #include "H5ACprivate.h"	/* Metadata cache			*/
 #include "H5Gprivate.h"		/* Groups 			  	*/
+#include "H5B2private.h"        /* v2 B-trees                           */
 #include "H5SLprivate.h"	/* Skip lists				*/
 #include "H5Tprivate.h"		/* Datatypes         			*/
 
@@ -66,17 +67,25 @@
 #define H5D_CHUNK_HASH(D, ADDR) H5F_addr_hash(ADDR, (D)->cache.chunk.nslots)
 
 /* Default creation parameters for chunk index data structures */
+/* See H5O_layout_chunk_t */
 
 /* Fixed array creation values */
-#define H5D_FARRAY_MAX_DBLK_PAGE_NELMTS_BITS  10  /* i.e. 1024 elements per data block page */
+#define H5D_FARRAY_CREATE_PARAM_SIZE		1	/* Size of the creation parameters in bytes */
+#define H5D_FARRAY_MAX_DBLK_PAGE_NELMTS_BITS 	10  	/* i.e. 1024 elements per data block page */
 
 /* Extensible array creation values */
-#define H5D_EARRAY_MAX_NELMTS_BITS         32                      /* i.e. 4 giga-elements */
-#define H5D_EARRAY_IDX_BLK_ELMTS           4
-#define H5D_EARRAY_SUP_BLK_MIN_DATA_PTRS   4
-#define H5D_EARRAY_DATA_BLK_MIN_ELMTS      16
-#define H5D_EARRAY_MAX_DBLOCK_PAGE_NELMTS_BITS     10              /* i.e. 1024 elements per data block page */
-
+#define H5D_EARRAY_CREATE_PARAM_SIZE		5	/* Size of the creation parameters in bytes */
+#define H5D_EARRAY_MAX_NELMTS_BITS         	32	/* i.e. 4 giga-elements */
+#define H5D_EARRAY_IDX_BLK_ELMTS           	4
+#define H5D_EARRAY_SUP_BLK_MIN_DATA_PTRS   	4
+#define H5D_EARRAY_DATA_BLK_MIN_ELMTS      	16
+#define H5D_EARRAY_MAX_DBLOCK_PAGE_NELMTS_BITS 	10 	/* i.e. 1024 elements per data block page */
+
+/* v2 B-tree creation values for raw meta_size */
+#define H5D_BT2_CREATE_PARAM_SIZE	6		/* Size of the creation parameters in bytes */
+#define H5D_BT2_NODE_SIZE       	512
+#define H5D_BT2_SPLIT_PERC      	100
+#define H5D_BT2_MERGE_PERC      	40
 
 /****************************/
 /* Package Private Typedefs */
@@ -554,6 +563,12 @@ H5_DLLVAR const H5D_layout_ops_t H5D_LOPS_CHUNK[1];
 H5_DLLVAR const H5D_chunk_ops_t H5D_COPS_BTREE[1];
 H5_DLLVAR const H5D_chunk_ops_t H5D_COPS_EARRAY[1];
 H5_DLLVAR const H5D_chunk_ops_t H5D_COPS_FARRAY[1];
+H5_DLLVAR const H5D_chunk_ops_t H5D_COPS_BT2[1];
+
+/* The v2 B-tree class for indexing chunked datasets with >1 unlimited dimensions */
+H5_DLLVAR const H5B2_class_t H5D_BT2[1];
+H5_DLLVAR const H5B2_class_t H5D_BT2_FILT[1];
+
 
 
 /******************************/
@@ -606,6 +621,8 @@ H5_DLL size_t H5D_layout_meta_size(const H5F_t *f, const H5O_layout_t *layout,
     hbool_t include_compact_data);
 H5_DLL herr_t H5D_layout_set_latest_version(H5O_layout_t *layout,
     const H5S_t *space);
+H5_DLL herr_t H5D_layout_set_latest_indexing(H5O_layout_t *layout,
+    const H5S_t *space);
 H5_DLL herr_t H5D_layout_oh_create(H5F_t *file, hid_t dxpl_id, H5O_t *oh,
     H5D_t *dset, hid_t dapl_id);
 H5_DLL herr_t H5D_layout_oh_read(H5D_t *dset, hid_t dxpl_id, hid_t dapl_id,
diff --git a/src/H5Dpublic.h b/src/H5Dpublic.h
index 972b33b..f4c62c9 100644
--- a/src/H5Dpublic.h
+++ b/src/H5Dpublic.h
@@ -53,9 +53,10 @@ typedef enum H5D_layout_t {
 
 /* Types of chunk index data structures */
 typedef enum H5D_chunk_index_t {
-    H5D_CHUNK_IDX_BTREE	= 0,	/* v1 B-tree index (default)		     */
+    H5D_CHUNK_IDX_BTREE	= 0,	/* v1 B-tree index (default)                 */
     H5D_CHUNK_IDX_FARRAY = 1,	/* Fixed array (for 0 unlimited dims)	     */
     H5D_CHUNK_IDX_EARRAY = 2,	/* Extensible array (for 1 unlimited dim)    */
+    H5D_CHUNK_IDX_BT2 = 3,   	/* v2 B-tree index (for >1 unlimited dims)   */
     H5D_CHUNK_IDX_NTYPES	/*this one must be last!		     */
 } H5D_chunk_index_t;
 
diff --git a/src/H5HFbtree2.c b/src/H5HFbtree2.c
index 3f208e7..bce58b7 100644
--- a/src/H5HFbtree2.c
+++ b/src/H5HFbtree2.c
@@ -287,7 +287,6 @@ H5HF_huge_bt2_crt_dbg_context(H5F_t *f, hid_t UNUSED dxpl_id, haddr_t UNUSED add
 
     /* Sanity check */
     HDassert(f);
-    HDassert(H5F_addr_defined(addr));
 
     /* Allocate callback context */
     if(NULL == (ctx = H5FL_MALLOC(H5HF_huge_bt2_ctx_t)))
diff --git a/src/H5Olayout.c b/src/H5Olayout.c
index debc169..bbebb8e 100644
--- a/src/H5Olayout.c
+++ b/src/H5Olayout.c
@@ -96,6 +96,11 @@ H5FL_DEFINE(H5O_layout_t);
  * Programmer:  Robb Matzke
  *              Wednesday, October  8, 1997
  *
+ * Modifications:
+ *	Vailin Choi; Aug 2010
+ *	Added v2 B-tree index.
+ *	Removed v1 B-tree support for layout message version > 4.
+ *
  *-------------------------------------------------------------------------
  */
 static void *
@@ -306,8 +311,10 @@ H5O_layout_decode(H5F_t *f, hid_t UNUSED dxpl_id, H5O_t UNUSED *open_oh,
                     mesg->storage.u.chunk.idx_type = mesg->u.chunk.idx_type;
 
                     switch(mesg->u.chunk.idx_type) {
-                        case H5D_CHUNK_IDX_BTREE:       /* Remove this when v2 B-tree indices added */
-                            /* Nothing to do */
+			case H5D_CHUNK_IDX_BT2:       /* v2 B-tree index */
+			    UINT32DECODE(p, mesg->u.chunk.u.btree2.cparam.node_size);
+                            mesg->u.chunk.u.btree2.cparam.split_percent = *p++;
+                            mesg->u.chunk.u.btree2.cparam.merge_percent = *p++;
                             break;
 
                         case H5D_CHUNK_IDX_FARRAY:
@@ -394,6 +401,10 @@ done:
  *      Added version number 4 case to allow different kinds of indices for
  *      looking up chunks.
  *
+ *	Vailin Choi; Aug 2010
+ *	Added v2 B-tree index.
+ *	Removed v1 B-tree support for layout message version > 4.
+ *
  *-------------------------------------------------------------------------
  */
 static herr_t
@@ -480,8 +491,10 @@ H5O_layout_encode(H5F_t *f, hbool_t UNUSED disable_shared, uint8_t *p, const voi
                 *p++ = (uint8_t)mesg->u.chunk.idx_type;
 
                 switch(mesg->u.chunk.idx_type) {
-                    case H5D_CHUNK_IDX_BTREE:       /* Remove this when v2 B-tree indices added */
-                        /* Nothing to do */
+		    case H5D_CHUNK_IDX_BT2:       /* v2 B-tree index */
+			UINT32ENCODE(p, mesg->u.chunk.u.btree2.cparam.node_size);
+                        *p++ = mesg->u.chunk.u.btree2.cparam.split_percent;
+                        *p++ = mesg->u.chunk.u.btree2.cparam.merge_percent;
                         break;
 
                     case H5D_CHUNK_IDX_FARRAY:
@@ -887,6 +900,8 @@ done:
  *              Wednesday, October  8, 1997
  *
  * Modifications:
+ *	Vailin Choi; Aug 2010
+ *	Added v2 B-tree index.
  *
  *-------------------------------------------------------------------------
  */
@@ -929,6 +944,11 @@ H5O_layout_debug(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, const void *_mesg,
                               "Index Type:", "v1 B-tree");
                     break;
 
+		case H5D_CHUNK_IDX_BT2:
+                    HDfprintf(stream, "%*s%-*s %s\n", indent, "", fwidth,
+                              "Index Type:", "v2 B-tree");
+                    break;
+
                 case H5D_CHUNK_IDX_FARRAY:
                     HDfprintf(stream, "%*s%-*s %s\n", indent, "", fwidth,
                               "Index Type:", "Fixed Array");
diff --git a/src/H5Oprivate.h b/src/H5Oprivate.h
index b062b95..a736e7c 100644
--- a/src/H5Oprivate.h
+++ b/src/H5Oprivate.h
@@ -396,6 +396,13 @@ typedef struct H5O_storage_chunk_btree_t {
 } H5O_storage_chunk_btree_t;
 
 /* Forward declaration of structs used below */
+struct H5B2_t;                          /* Defined in H5B2pkg.h          */
+
+typedef struct H5O_storage_chunk_bt2_t {
+    struct H5B2_t *bt2;
+} H5O_storage_chunk_bt2_t;
+
+/* Forward declaration of structs used below */
 struct H5FA_t;                          /* Defined in H5FAprivate.h          */
 
 typedef struct H5O_storage_chunk_farray_t {
@@ -416,6 +423,7 @@ typedef struct H5O_storage_chunk_t {
     const struct H5D_chunk_ops_t *ops;  /* Pointer to chunked storage operations */
     union {
         H5O_storage_chunk_btree_t btree; /* Information for v1 B-tree index   */
+	H5O_storage_chunk_bt2_t btree2;  /* Information for v2 B-tree index */	
         H5O_storage_chunk_farray_t farray; /* Information for fixed array index   */
         H5O_storage_chunk_earray_t earray; /* Information for extensible array index   */
     } u;
@@ -436,6 +444,15 @@ typedef struct H5O_storage_t {
     } u;
 } H5O_storage_t;
 
+typedef struct H5O_layout_chunk_bt2_t {
+    /* Creation parameters for v2 B-tree data structure */
+    struct {
+	uint32_t node_size;	/* Size of each node (in bytes) */
+	uint8_t split_percent;	/* % full to split nodes */
+	uint8_t merge_percent; 	/* % full to merge nodes */
+    } cparam;
+} H5O_layout_chunk_bt2_t;
+
 typedef struct H5O_layout_chunk_farray_t {
     /* Creation parameters for fixed array data structure */
     struct {
@@ -475,6 +492,7 @@ typedef struct H5O_layout_chunk_t {
     union {
         H5O_layout_chunk_farray_t farray; /* Information for fixed array index */
         H5O_layout_chunk_earray_t earray; /* Information for extensible array index */
+        H5O_layout_chunk_bt2_t btree2; /* Information for v2 B-tree index */
     } u;
 } H5O_layout_chunk_t;
 
diff --git a/src/H5Ostorage.c b/src/H5Ostorage.c
index f6891d7..2995e47 100644
--- a/src/H5Ostorage.c
+++ b/src/H5Ostorage.c
@@ -103,6 +103,11 @@ H5FL_DEFINE_STATIC(H5O_storage_t);
  * Programmer:  Quincey Koziol
  *              Wednesday, July 29, 2009
  *
+ * Modifications:
+ *	Vailin Choi; Aug 2010
+ *	Added v2 B-tree index.
+ *	Removed v1 B-tree support.
+ *
  *-------------------------------------------------------------------------
  */
 static void *
@@ -173,9 +178,9 @@ H5O_storage_decode(H5F_t *f, hid_t UNUSED dxpl_id, H5O_t UNUSED *open_oh,
                     /* Chunk index type */
                     mesg->u.chunk.idx_type = (H5D_chunk_index_t)*p++;
                     switch(mesg->u.chunk.idx_type) {
-                        case H5D_CHUNK_IDX_BTREE:       /* Remove this when v2 B-tree indices added */
+			case H5D_CHUNK_IDX_BT2:       /* v2 B-tree index */
                             /* Set the chunk operations */
-                            mesg->u.chunk.ops = H5D_COPS_BTREE;
+                            mesg->u.chunk.ops = H5D_COPS_BT2;
                             break;
 
                         case H5D_CHUNK_IDX_FARRAY:
@@ -603,6 +608,10 @@ done:
  * Programmer:  Quincey Koziol
  *              Thursday, July 30, 2009
  *
+ * Modifications:
+ *	Vailin Choi; Aug 2010
+ *	Added v2 B-tree index.
+ *
  *-------------------------------------------------------------------------
  */
 static herr_t
@@ -634,6 +643,11 @@ H5O_storage_debug(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, const void *_mesg,
                               "Index Type:", "v1 B-tree");
                     break;
 
+		case H5D_CHUNK_IDX_BT2:
+                    HDfprintf(stream, "%*s%-*s %s\n", indent, "", fwidth,
+                              "Index Type:", "v2 B-tree");
+                    break;
+
                 case H5D_CHUNK_IDX_FARRAY:
                     HDfprintf(stream, "%*s%-*s %s\n", indent, "", fwidth,
                               "Index Type:", "Fixed Array");
diff --git a/src/H5SMbtree2.c b/src/H5SMbtree2.c
index 95527f9..156a6c5 100755
--- a/src/H5SMbtree2.c
+++ b/src/H5SMbtree2.c
@@ -240,7 +240,6 @@ H5SM_bt2_crt_dbg_context(H5F_t *f, hid_t UNUSED dxpl_id, haddr_t UNUSED addr)
 
     /* Sanity check */
     HDassert(f);
-    HDassert(H5F_addr_defined(addr));
 
     /* Allocate callback context */
     if(NULL == (ctx = H5FL_MALLOC(H5SM_bt2_ctx_t)))
diff --git a/src/Makefile.am b/src/Makefile.am
index 5dd6b36..6f93c4e 100755
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -46,7 +46,7 @@ libhdf5_la_SOURCES= H5.c H5checksum.c H5dbg.c H5system.c H5timer.c H5trace.c \
         H5AC.c H5B.c H5Bcache.c H5Bdbg.c \
         H5B2.c H5B2cache.c H5B2dbg.c H5B2hdr.c H5B2int.c H5B2stat.c H5B2test.c \
         H5C.c H5CS.c \
-        H5D.c H5Dbtree.c H5Dchunk.c H5Dcompact.c H5Dcontig.c H5Ddbg.c \
+        H5D.c H5Dbtree.c H5Dbtree2.c H5Dchunk.c H5Dcompact.c H5Dcontig.c H5Ddbg.c \
         H5Ddeprec.c H5Dearray.c H5Defl.c H5Dfarray.c H5Dfill.c H5Dint.c \
         H5Dio.c H5Dlayout.c H5Dmpio.c H5Doh.c H5Dproxy.c H5Dscatgath.c \
         H5Dselect.c H5Dtest.c \
diff --git a/src/Makefile.in b/src/Makefile.in
index 1fa47ad..8dbba32 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -100,14 +100,14 @@ am_libhdf5_la_OBJECTS = H5.lo H5checksum.lo H5dbg.lo H5system.lo \
 	H5Adeprec.lo H5Aint.lo H5Atest.lo H5AC.lo H5B.lo H5Bcache.lo \
 	H5Bdbg.lo H5B2.lo H5B2cache.lo H5B2dbg.lo H5B2hdr.lo \
 	H5B2int.lo H5B2stat.lo H5B2test.lo H5C.lo H5CS.lo H5D.lo \
-	H5Dbtree.lo H5Dchunk.lo H5Dcompact.lo H5Dcontig.lo H5Ddbg.lo \
-	H5Ddeprec.lo H5Dearray.lo H5Defl.lo H5Dfarray.lo H5Dfill.lo \
-	H5Dint.lo H5Dio.lo H5Dlayout.lo H5Dmpio.lo H5Doh.lo \
-	H5Dproxy.lo H5Dscatgath.lo H5Dselect.lo H5Dtest.lo H5E.lo \
-	H5Edeprec.lo H5Eint.lo H5EA.lo H5EAcache.lo H5EAdbg.lo \
-	H5EAdblkpage.lo H5EAdblock.lo H5EAhdr.lo H5EAiblock.lo \
-	H5EAint.lo H5EAsblock.lo H5EAstat.lo H5EAtest.lo H5F.lo \
-	H5Faccum.lo H5Fdbg.lo H5Fdeprec.lo H5Ffake.lo H5Fio.lo \
+	H5Dbtree.lo H5Dbtree2.lo H5Dchunk.lo H5Dcompact.lo \
+	H5Dcontig.lo H5Ddbg.lo H5Ddeprec.lo H5Dearray.lo H5Defl.lo \
+	H5Dfarray.lo H5Dfill.lo H5Dint.lo H5Dio.lo H5Dlayout.lo \
+	H5Dmpio.lo H5Doh.lo H5Dproxy.lo H5Dscatgath.lo H5Dselect.lo \
+	H5Dtest.lo H5E.lo H5Edeprec.lo H5Eint.lo H5EA.lo H5EAcache.lo \
+	H5EAdbg.lo H5EAdblkpage.lo H5EAdblock.lo H5EAhdr.lo \
+	H5EAiblock.lo H5EAint.lo H5EAsblock.lo H5EAstat.lo H5EAtest.lo \
+	H5F.lo H5Faccum.lo H5Fdbg.lo H5Fdeprec.lo H5Ffake.lo H5Fio.lo \
 	H5Fmount.lo H5Fmpi.lo H5Fquery.lo H5Fsfile.lo H5Fsuper.lo \
 	H5Fsuper_cache.lo H5Ftest.lo H5FA.lo H5FAcache.lo H5FAdbg.lo \
 	H5FAdblock.lo H5FAdblkpage.lo H5FAhdr.lo H5FAstat.lo \
@@ -468,7 +468,7 @@ libhdf5_la_SOURCES = H5.c H5checksum.c H5dbg.c H5system.c H5timer.c H5trace.c \
         H5AC.c H5B.c H5Bcache.c H5Bdbg.c \
         H5B2.c H5B2cache.c H5B2dbg.c H5B2hdr.c H5B2int.c H5B2stat.c H5B2test.c \
         H5C.c H5CS.c \
-        H5D.c H5Dbtree.c H5Dchunk.c H5Dcompact.c H5Dcontig.c H5Ddbg.c \
+        H5D.c H5Dbtree.c H5Dbtree2.c H5Dchunk.c H5Dcompact.c H5Dcontig.c H5Ddbg.c \
         H5Ddeprec.c H5Dearray.c H5Defl.c H5Dfarray.c H5Dfill.c H5Dint.c \
         H5Dio.c H5Dlayout.c H5Dmpio.c H5Doh.c H5Dproxy.c H5Dscatgath.c \
         H5Dselect.c H5Dtest.c \
@@ -694,6 +694,7 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5CS.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5D.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Dbtree.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Dbtree2.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Dchunk.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Dcompact.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Dcontig.Plo@am__quote@