[svn-r18917] Description:

	Bring r18911 (plus some adaptions to match the code on the trunk)
from the metadata journaling "merging" branch to the trunk:

	More general changes to align trunk with eventual changes from
metadata journaling branch.

Tested on:
        FreeBSD/32 6.3 (duty) in debug mode
        FreeBSD/64 6.3 (liberty) w/C++ & FORTRAN, in debug mode
        Linux/32 2.6 (jam) w/PGI compilers, w/default API=1.8.x,
                w/C++ & FORTRAN, w/threadsafe, in debug mode
        Linux/64-amd64 2.6 (amani) w/Intel compilers, w/default API=1.6.x,
                w/C++ & FORTRAN, in production mode
        Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
                w/szip filter, in production mode
        Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
                in production mode
        Linux/64-amd64 2.6 (abe) w/parallel, w/FORTRAN, in debug mode
        Mac OS X/32 10.6.3 (amazon) in debug mode
        Mac OS X/32 10.6.3 (amazon) w/C++ & FORTRAN, w/threadsafe,
                in production mode

1 files changed, 26 insertions, 40 deletions

diff --git a/src/H5SMcache.c b/src/H5SMcache.c
index cc22dcd..4a9338b 100644
--- a/src/H5SMcache.c
+++ b/src/H5SMcache.c
@@ -119,7 +119,6 @@ static H5SM_master_table_t *
 H5SM_table_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void UNUSED *udata)
 {
     H5SM_master_table_t *table = NULL;
-    size_t        size;                 /* Size of SOHM master table on disk */
     H5WB_t        *wb = NULL;           /* Wrapped buffer for table data */
     uint8_t       tbl_buf[H5SM_TBL_BUF_SIZE]; /* Buffer for table */
     uint8_t       *buf;                 /* Reading buffer */
@@ -151,17 +150,17 @@ H5SM_table_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void UNUSED *udata)
     if(NULL == (wb = H5WB_wrap(tbl_buf, sizeof(tbl_buf))))
         HGOTO_ERROR(H5E_SOHM, H5E_CANTINIT, NULL, "can't wrap buffer")
 
-    /* Compute the size of the SOHM table header on disk.  This is the "table" itself
-     * plus each index within the table
+    /* Compute the size of the SOHM table header on disk.  This is the "table"
+     * itself plus each index within the table
      */
-    size = H5SM_TABLE_SIZE(f) + (table->num_indexes * H5SM_INDEX_HEADER_SIZE(f));
+    table->table_size = H5SM_TABLE_SIZE(f);
 
     /* Get a pointer to a buffer that's large enough for serialized table */
-    if(NULL == (buf = (uint8_t *)H5WB_actual(wb, size)))
+    if(NULL == (buf = (uint8_t *)H5WB_actual(wb, table->table_size)))
         HGOTO_ERROR(H5E_SOHM, H5E_NOSPACE, NULL, "can't get actual buffer")
 
     /* Read header from disk */
-    if(H5F_block_read(f, H5FD_MEM_SOHM_TABLE, addr, size, dxpl_id, buf) < 0)
+    if(H5F_block_read(f, H5FD_MEM_SOHM_TABLE, addr, table->table_size, dxpl_id, buf) < 0)
 	HGOTO_ERROR(H5E_SOHM, H5E_READERROR, NULL, "can't read SOHM table")
 
     /* Get temporary pointer to serialized table */
@@ -172,11 +171,6 @@ H5SM_table_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void UNUSED *udata)
 	HGOTO_ERROR(H5E_SOHM, H5E_CANTLOAD, NULL, "bad SOHM table signature")
     p += H5_SIZEOF_MAGIC;
 
-    /* Don't count the checksum in the table size yet, since it comes after
-     * all of the index headers
-     */
-    HDassert((size_t)(p - (const uint8_t *)buf) == H5SM_TABLE_SIZE(f) - H5SM_SIZEOF_CHECKSUM);
-
     /* Allocate space for the index headers in memory*/
     if(NULL == (table->indexes = (H5SM_index_header_t *)H5FL_ARR_MALLOC(H5SM_index_header_t, (size_t)table->num_indexes)))
 	HGOTO_ERROR(H5E_SOHM, H5E_NOSPACE, NULL, "memory allocation failed for SOHM indexes")
@@ -210,16 +204,19 @@ H5SM_table_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void UNUSED *udata)
 
         /* Address of the index's heap */
         H5F_addr_decode(f, &p, &(table->indexes[x].heap_addr));
+
+        /* Compute the size of a list index for this SOHM index */
+        table->indexes[x].list_size = H5SM_LIST_SIZE(f, table->indexes[x].list_max);
     } /* end for */
 
     /* Read in checksum */
     UINT32DECODE(p, stored_chksum);
 
     /* Sanity check */
-    HDassert((size_t)(p - (const uint8_t *)buf) == size);
+    HDassert((size_t)(p - (const uint8_t *)buf) == table->table_size);
 
     /* Compute checksum on entire header */
-    computed_chksum = H5_checksum_metadata(buf, (size - H5SM_SIZEOF_CHECKSUM), 0);
+    computed_chksum = H5_checksum_metadata(buf, (table->table_size - H5SM_SIZEOF_CHECKSUM), 0);
 
     /* Verify checksum */
     if(stored_chksum != computed_chksum)
@@ -270,7 +267,6 @@ H5SM_table_flush(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5SM_ma
     if(table->cache_info.is_dirty) {
         uint8_t  *buf;               /* Temporary buffer */
         uint8_t  *p;                 /* Pointer into raw data buffer */
-        size_t	 size;               /* Header size on disk */
         uint32_t computed_chksum;    /* Computed metadata checksum value */
         size_t   x;                  /* Counter variable */
 
@@ -283,11 +279,8 @@ H5SM_table_flush(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5SM_ma
         if(NULL == (wb = H5WB_wrap(tbl_buf, sizeof(tbl_buf))))
             HGOTO_ERROR(H5E_SOHM, H5E_CANTINIT, FAIL, "can't wrap buffer")
 
-        /* Encode the master table and all of the index headers as one big blob */
-        size = H5SM_TABLE_SIZE(f) + (H5SM_INDEX_HEADER_SIZE(f) * table->num_indexes);
-
         /* Get a pointer to a buffer that's large enough for serialized table */
-        if(NULL == (buf = (uint8_t *)H5WB_actual(wb, size)))
+        if(NULL == (buf = (uint8_t *)H5WB_actual(wb, table->table_size)))
             HGOTO_ERROR(H5E_SOHM, H5E_NOSPACE, FAIL, "can't get actual buffer")
 
         /* Get temporary pointer to buffer for serialized table */
@@ -328,12 +321,12 @@ H5SM_table_flush(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5SM_ma
         } /* end for */
 
         /* Compute checksum on buffer */
-        computed_chksum = H5_checksum_metadata(buf, (size - H5SM_SIZEOF_CHECKSUM), 0);
+        computed_chksum = H5_checksum_metadata(buf, (table->table_size - H5SM_SIZEOF_CHECKSUM), 0);
         UINT32ENCODE(p, computed_chksum);
 
         /* Write the table to disk */
-        HDassert((size_t)(p - buf) == size);
-	if(H5F_block_write(f, H5FD_MEM_SOHM_TABLE, addr, size, dxpl_id, buf) < 0)
+        HDassert((size_t)(p - buf) == table->table_size);
+	if(H5F_block_write(f, H5FD_MEM_SOHM_TABLE, addr, table->table_size, dxpl_id, buf) < 0)
 	    HGOTO_ERROR(H5E_SOHM, H5E_CANTFLUSH, FAIL, "unable to save sohm table to disk")
 
 	table->cache_info.is_dirty = FALSE;
@@ -433,7 +426,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5SM_table_size(const H5F_t *f, const H5SM_master_table_t *table, size_t *size_ptr)
+H5SM_table_size(const H5F_t UNUSED *f, const H5SM_master_table_t *table, size_t *size_ptr)
 {
     FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5SM_table_size)
 
@@ -443,7 +436,7 @@ H5SM_table_size(const H5F_t *f, const H5SM_master_table_t *table, size_t *size_p
     HDassert(size_ptr);
 
     /* Set size value */
-    *size_ptr = H5SM_TABLE_SIZE(f) + (table->num_indexes * H5SM_INDEX_HEADER_SIZE(f));
+    *size_ptr = table->table_size;
 
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5SM_table_size() */
@@ -467,7 +460,6 @@ H5SM_list_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_udata)
     H5SM_list_t *list;          /* The SOHM list being read in */
     H5SM_list_cache_ud_t *udata = (H5SM_list_cache_ud_t *)_udata; /* User data for callback */
     H5SM_bt2_ctx_t ctx;         /* Message encoding context */
-    size_t size;                /* Size of SOHM list on disk */
     H5WB_t *wb = NULL;          /* Wrapped buffer for list index data */
     uint8_t lst_buf[H5SM_LST_BUF_SIZE]; /* Buffer for list index */
     uint8_t *buf;               /* Reading buffer */
@@ -497,15 +489,12 @@ H5SM_list_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_udata)
     if(NULL == (wb = H5WB_wrap(lst_buf, sizeof(lst_buf))))
         HGOTO_ERROR(H5E_SOHM, H5E_CANTINIT, NULL, "can't wrap buffer")
 
-    /* Compute the size of the SOHM list on disk */
-    size = H5SM_LIST_SIZE(udata->f, udata->header->num_messages);
-
     /* Get a pointer to a buffer that's large enough for serialized list index */
-    if(NULL == (buf = (uint8_t *)H5WB_actual(wb, size)))
+    if(NULL == (buf = (uint8_t *)H5WB_actual(wb, udata->header->list_size)))
         HGOTO_ERROR(H5E_SOHM, H5E_NOSPACE, NULL, "can't get actual buffer")
 
     /* Read list from disk */
-    if(H5F_block_read(f, H5FD_MEM_SOHM_INDEX, addr, size, dxpl_id, buf) < 0)
+    if(H5F_block_read(f, H5FD_MEM_SOHM_INDEX, addr, udata->header->list_size, dxpl_id, buf) < 0)
 	HGOTO_ERROR(H5E_SOHM, H5E_READERROR, NULL, "can't read SOHM list")
 
     /* Get temporary pointer to serialized list index */
@@ -528,10 +517,10 @@ H5SM_list_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_udata)
     UINT32DECODE(p, stored_chksum);
 
     /* Sanity check */
-    HDassert((size_t)(p - buf) == size);
+    HDassert((size_t)(p - buf) <= udata->header->list_size);
 
     /* Compute checksum on entire header */
-    computed_chksum = H5_checksum_metadata(buf, (size - H5SM_SIZEOF_CHECKSUM), 0);
+    computed_chksum = H5_checksum_metadata(buf, ((size_t)(p - buf) - H5SM_SIZEOF_CHECKSUM), 0);
 
     /* Verify checksum */
     if(stored_chksum != computed_chksum)
@@ -589,7 +578,6 @@ H5SM_list_flush(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5SM_lis
         H5SM_bt2_ctx_t ctx;         /* Message encoding context */
         uint8_t *buf;               /* Temporary buffer */
         uint8_t *p;                 /* Pointer into raw data buffer */
-        size_t size;                /* Header size on disk */
         uint32_t computed_chksum;   /* Computed metadata checksum value */
         size_t mesgs_written;       /* Number of messages written to list */
         size_t x;                   /* Local index variable */
@@ -598,10 +586,8 @@ H5SM_list_flush(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5SM_lis
         if(NULL == (wb = H5WB_wrap(lst_buf, sizeof(lst_buf))))
             HGOTO_ERROR(H5E_SOHM, H5E_CANTINIT, FAIL, "can't wrap buffer")
 
-        size = H5SM_LIST_SIZE(f, list->header->num_messages);
-
         /* Get a pointer to a buffer that's large enough for serialized list index */
-        if(NULL == (buf = (uint8_t *)H5WB_actual(wb, size)))
+        if(NULL == (buf = (uint8_t *)H5WB_actual(wb, list->header->list_size)))
             HGOTO_ERROR(H5E_SOHM, H5E_NOSPACE, FAIL, "can't get actual buffer")
 
         /* Get temporary pointer to buffer for serialized list index */
@@ -626,12 +612,12 @@ H5SM_list_flush(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5SM_lis
         HDassert(mesgs_written == list->header->num_messages);
 
         /* Compute checksum on buffer */
-        computed_chksum = H5_checksum_metadata(buf, (size - H5SM_SIZEOF_CHECKSUM), 0);
+        computed_chksum = H5_checksum_metadata(buf, (size_t)(p - buf), 0);
         UINT32ENCODE(p, computed_chksum);
 
         /* Write the list to disk */
-        HDassert((size_t)(p - buf) == size);
-	if(H5F_block_write(f, H5FD_MEM_SOHM_INDEX, addr, size, dxpl_id, buf) < 0)
+        HDassert((size_t)(p - buf) <= list->header->list_size);
+	if(H5F_block_write(f, H5FD_MEM_SOHM_INDEX, addr, list->header->list_size, dxpl_id, buf) < 0)
 	    HGOTO_ERROR(H5E_SOHM, H5E_CANTFLUSH, FAIL, "unable to save sohm table to disk")
 
         list->cache_info.is_dirty = FALSE;
@@ -681,7 +667,7 @@ H5SM_list_dest(H5F_t *f, H5SM_list_t* list)
     if(list->cache_info.free_file_space_on_destroy) {
         /* Release the space on disk */
         /* (XXX: Nasty usage of internal DXPL value! -QAK) */
-        if(H5MF_xfree(f, H5FD_MEM_SOHM_INDEX, H5AC_dxpl_id, list->cache_info.addr, (hsize_t)H5SM_LIST_SIZE(f, list->header->list_max)) < 0)
+        if(H5MF_xfree(f, H5FD_MEM_SOHM_INDEX, H5AC_dxpl_id, list->cache_info.addr, (hsize_t)list->header->list_size) < 0)
             HGOTO_ERROR(H5E_SOHM, H5E_NOSPACE, FAIL, "unable to free shared message list")
     } /* end if */
 
@@ -754,7 +740,7 @@ H5SM_list_size(const H5F_t UNUSED *f, const H5SM_list_t *list, size_t *size_ptr)
     HDassert(size_ptr);
 
     /* Set size value */
-    *size_ptr = H5SM_LIST_SIZE(f, list->header->list_max);
+    *size_ptr = list->header->list_size;
 
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5SM_list_size() */