summaryrefslogtreecommitdiffstats
path: root/src/H5O.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/H5O.c')
-rw-r--r--src/H5O.c531
1 files changed, 470 insertions, 61 deletions
diff --git a/src/H5O.c b/src/H5O.c
index 2a3f39c..7522b4a 100644
--- a/src/H5O.c
+++ b/src/H5O.c
@@ -64,6 +64,12 @@ typedef struct {
typedef herr_t (*H5O_operator_int_t)(H5O_mesg_t *mesg/*in,out*/, unsigned idx,
unsigned * oh_flags_ptr, void *operator_data/*in,out*/);
+/* Node in skip list to map addresses from one file to another during object header copy */
+typedef struct H5O_addr_map_t {
+ haddr_t src_addr; /* Address of object in source file */
+ haddr_t dst_addr; /* Address of object in destination file */
+} H5O_addr_map_t;
+
/* PRIVATE PROTOTYPES */
static herr_t H5O_init(H5F_t *f, hid_t dxpl_id, size_t size_hint,
H5G_entry_t *ent/*out*/, haddr_t header);
@@ -107,6 +113,14 @@ static herr_t H5O_write_mesg(H5O_t *oh, unsigned idx, const H5O_class_t *type,
unsigned * oh_flags_ptr);
static herr_t H5O_iterate_real(const H5G_entry_t *ent, const H5O_class_t *type,
H5AC_protect_t prot, hbool_t internal, void *op, void *op_data, hid_t dxpl_id);
+static void * H5O_copy_mesg_file(const H5O_class_t *type, H5F_t *file_src,
+ void *mesg_src, H5F_t *file_dst, hid_t dxpl_id, H5SL_t *map_list, void *udata);
+static herr_t H5O_post_copy_mesg_file(const H5O_class_t *type, H5F_t *file_src,
+ const void *mesg_src, H5G_entry_t *loc_dst,
+ hid_t dxpl_id, H5SL_t *map_list);
+static herr_t H5O_copy_header_real(const H5G_entry_t *ent_src,
+ H5G_entry_t *ent_dst /*out */, hid_t dxpl_id, H5SL_t *map_list);
+static herr_t H5O_copy_free_addrmap_cb(void *item, void *key, void *op_data);
/* Metadata cache callbacks */
static H5O_t *H5O_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void *_udata1,
@@ -153,6 +167,8 @@ static const H5O_class_t *const message_type_g[] = {
H5O_MTIME_NEW, /*0x0012 New Object modification date and time */
};
+/* Library private variables */
+
/*
* An array of functions indexed by symbol table entry cache type
* (H5G_type_t) that are called to retrieve constant messages cached in the
@@ -180,6 +196,9 @@ H5FL_EXTERN(time_t);
/* Declare extern the free list for H5O_cont_t's */
H5FL_EXTERN(H5O_cont_t);
+/* Declare a free list to manage the H5O_addr_map_t struct */
+H5FL_DEFINE_STATIC(H5O_addr_map_t);
+
/*-------------------------------------------------------------------------
* Function: H5O_init_interface
@@ -584,12 +603,8 @@ H5O_load(H5F_t *f, hid_t dxpl_id, haddr_t addr, const void UNUSED * _udata1,
p += 3; /*reserved*/
/* Try to detect invalidly formatted object header messages */
- if (p + mesg_size > oh->chunk[chunkno].image + chunk_size) {
-
- HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, NULL, \
- "corrupt object header");
- }
-
+ if (p + mesg_size > oh->chunk[chunkno].image + chunk_size)
+ HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, NULL, "corrupt object header");
/* Skip header messages we don't know about */
/* (Usually from future versions of the library */
@@ -680,7 +695,6 @@ H5O_flush(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H5O_t *oh)
int id;
unsigned u;
H5O_mesg_t *curr_msg; /* Pointer to current message being operated on */
- H5O_cont_t *cont = NULL;
herr_t (*encode)(H5F_t*, uint8_t*, const void*) = NULL;
unsigned combine=0; /* Whether to combine the object header prefix & the first chunk */
herr_t ret_value=SUCCEED; /* Return value */
@@ -2259,8 +2273,7 @@ H5O_new_mesg(H5F_t *f, H5O_t *oh, unsigned *flags, const H5O_class_t *orig_type,
HGOTO_ERROR (H5E_OHDR, H5E_CANTINIT, UFAIL, "object header message is too large (16k max)");
/* Allocate space in the object headed for the message */
- if ((ret_value = H5O_alloc(f, dxpl_id, oh,
- orig_type, size, oh_flags_ptr)) == UFAIL)
+ if ((ret_value = H5O_alloc(f, dxpl_id, oh, orig_type, size, oh_flags_ptr)) == UFAIL)
HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, UFAIL, "unable to allocate space for message");
/* Increment any links in message */
@@ -3045,8 +3058,8 @@ H5O_alloc_new_chunk(H5F_t *f,
H5O_cont_t *cont = NULL; /*native continuation message */
int chunkno;
unsigned u;
- unsigned ret_value; /*return value */
haddr_t new_chunk_addr;
+ unsigned ret_value; /*return value */
FUNC_ENTER_NOAPI_NOINIT(H5O_alloc_new_chunk);
@@ -3088,10 +3101,8 @@ H5O_alloc_new_chunk(H5F_t *f,
* message, then make sure the new chunk has enough room for that
* other message.
*/
- if ( found_null < 0 ) {
-
+ if (found_null < 0)
size += H5O_SIZEOF_MSGHDR(f) + oh->mesg[found_other].raw_size;
- }
/*
* The total chunk size must include the requested space plus enough
@@ -3103,11 +3114,8 @@ H5O_alloc_new_chunk(H5F_t *f,
/* allocate space in file to hold the new chunk */
new_chunk_addr = H5MF_alloc(f, H5FD_MEM_OHDR, dxpl_id, (hsize_t)size);
- if ( HADDR_UNDEF == new_chunk_addr ) {
-
- HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, UFAIL, \
- "unable to allocate space for new chunk");
- }
+ if(HADDR_UNDEF == new_chunk_addr)
+ HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, UFAIL, "unable to allocate space for new chunk")
/*
* Create the new chunk giving it a file address.
@@ -3117,11 +3125,8 @@ H5O_alloc_new_chunk(H5F_t *f,
unsigned na = oh->alloc_nchunks + H5O_NCHUNKS;
H5O_chunk_t *x = H5FL_SEQ_REALLOC (H5O_chunk_t, oh->chunk, (size_t)na);
- if ( !x ) {
-
- HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, UFAIL, \
- "memory allocation failed");
- }
+ if (!x)
+ HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, UFAIL, "memory allocation failed");
oh->alloc_nchunks = na;
oh->chunk = x;
}
@@ -3142,11 +3147,8 @@ H5O_alloc_new_chunk(H5F_t *f,
unsigned na = oh->alloc_nmesgs + MAX (H5O_NMESGS, 3);
H5O_mesg_t *x = H5FL_SEQ_REALLOC (H5O_mesg_t, oh->mesg, (size_t)na);
- if ( !x ) {
-
- HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, UFAIL, \
- "memory allocation failed");
- }
+ if (!x)
+ HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, UFAIL, "memory allocation failed");
oh->alloc_nmesgs = na;
oh->mesg = x;
@@ -3211,11 +3213,8 @@ H5O_alloc_new_chunk(H5F_t *f,
*/
oh->mesg[found_null].type = H5O_CONT;
oh->mesg[found_null].dirty = TRUE;
- if (NULL==(cont = H5FL_MALLOC(H5O_cont_t))) {
-
- HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, UFAIL, \
- "memory allocation failed");
- }
+ if (NULL==(cont = H5FL_MALLOC(H5O_cont_t)))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, UFAIL, "memory allocation failed")
cont->addr = oh->chunk[chunkno].addr;
cont->size = oh->chunk[chunkno].size;
cont->chunkno = chunkno;
@@ -3226,7 +3225,6 @@ H5O_alloc_new_chunk(H5F_t *f,
done:
FUNC_LEAVE_NOAPI(ret_value);
-
} /* H5O_alloc_new_chunk() */
@@ -3270,7 +3268,7 @@ H5O_alloc(H5F_t *f,
size_t size,
unsigned * oh_flags_ptr)
{
- unsigned idx = UFAIL;
+ unsigned idx;
H5O_mesg_t *msg; /* Pointer to newly allocated message */
size_t aligned_size = H5O_ALIGN(size);
htri_t tri_result;
@@ -3310,8 +3308,7 @@ H5O_alloc(H5F_t *f,
* Note that in this new version of this function, all chunks
* must have file space allocated to them.
*/
- for ( chunkno = 0; chunkno < oh->nchunks; chunkno++ )
- {
+ for (chunkno = 0; chunkno < oh->nchunks; chunkno++) {
HDassert( H5F_addr_defined(oh->chunk[chunkno].addr) );
tri_result = H5O_alloc_extend_chunk(f, oh, chunkno, size, &idx);
@@ -3334,13 +3331,9 @@ H5O_alloc(H5F_t *f,
/* if idx is still UFAIL, we were not able to extend a chunk.
* Create a new one.
*/
- if (idx == UFAIL) {
-
- if ( (idx = H5O_alloc_new_chunk(f, dxpl_id, oh, size)) == UFAIL ) {
-
- HGOTO_ERROR(H5E_OHDR, H5E_NOSPACE, UFAIL, \
- "unable to create a new object header data chunk");
- }
+ if(idx == UFAIL) {
+ if((idx = H5O_alloc_new_chunk(f, dxpl_id, oh, size)) == UFAIL)
+ HGOTO_ERROR(H5E_OHDR, H5E_NOSPACE, UFAIL, "unable to create a new object header data chunk")
}
}
@@ -3349,35 +3342,26 @@ H5O_alloc(H5F_t *f,
/* do we need to split the null message? */
if (msg->raw_size > aligned_size) {
-
H5O_mesg_t *null_msg; /* Pointer to null message */
+ size_t mesg_size = aligned_size+ H5O_SIZEOF_MSGHDR(f); /* Total size of newly allocated message */
- size_t mesg_size = aligned_size + H5O_SIZEOF_MSGHDR(f);
- /* Total size of newly allocated message */
-
- HDassert( msg->raw_size - aligned_size >= H5O_SIZEOF_MSGHDR(f) );
+ HDassert(msg->raw_size - aligned_size >= H5O_SIZEOF_MSGHDR(f));
if (oh->nmesgs >= oh->alloc_nmesgs) {
-
int old_alloc=oh->alloc_nmesgs;
unsigned na = oh->alloc_nmesgs + H5O_NMESGS;
H5O_mesg_t *x = H5FL_SEQ_REALLOC(H5O_mesg_t, oh->mesg, (size_t)na);
- if (!x) {
-
- HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, UFAIL, \
- "memory allocation failed");
- }
- oh->alloc_nmesgs = na;
- oh->mesg = x;
+ if (!x)
+ HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, UFAIL, "memory allocation failed");
+ oh->alloc_nmesgs = na;
+ oh->mesg = x;
/* Set new object header info to zeros */
HDmemset(&oh->mesg[old_alloc],0,
(oh->alloc_nmesgs-old_alloc)*sizeof(H5O_mesg_t));
- /* "Retarget" local 'msg' pointer into newly allocated array
- * of messages
- */
+ /* "Retarget" local 'msg' pointer into newly allocated array of messages */
msg=&oh->mesg[idx];
}
null_msg = &(oh->mesg[oh->nmesgs++]);
@@ -3402,7 +3386,6 @@ H5O_alloc(H5F_t *f,
done:
FUNC_LEAVE_NOAPI(ret_value);
-
} /* H5O_alloc() */
#ifdef NOT_YET
@@ -4078,6 +4061,432 @@ done:
/*-------------------------------------------------------------------------
+ * Function: H5O_copy_mesg_file
+ *
+ * Purpose: Copies a message to file. If MESG is is the null pointer then a null
+ * pointer is returned with no error.
+ *
+ * Return: Success: Ptr to the new message
+ *
+ * Failure: NULL
+ *
+ * Programmer: Peter Cao
+ * June 4, 2005
+ *
+ *-------------------------------------------------------------------------
+ */
+static void *
+H5O_copy_mesg_file(const H5O_class_t *type, H5F_t *file_src,
+ void *native_src, H5F_t *file_dst, hid_t dxpl_id, H5SL_t *map_list, void *udata)
+{
+ void *ret_value;
+
+ FUNC_ENTER_NOAPI_NOINIT(H5O_copy_mesg_file)
+
+ /* check args */
+ HDassert(type);
+ HDassert(type->copy_file);
+ HDassert(file_src);
+ HDassert(native_src);
+ HDassert(file_dst);
+ HDassert(map_list);
+
+ if(NULL == (ret_value = (type->copy_file)(file_src, native_src, file_dst, dxpl_id, map_list, udata)))
+ HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, NULL, "unable to copy object header message to file")
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5O_copy_mesg_file() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5O_post_copy_mesg_file
+ *
+ * Purpose: Copies what's left to file after the object a meesage is copied.
+ * This function is need for situations like copying symbol tables.
+ * Copying a member of symbol table requires the parent object header
+ * exists in file. For this case, the first round of the message will
+ * create symbol table enttries but will not go deep copying member
+ * objects in the symbol table. The post copy will do that.
+ *
+ * Return: Non-negative on success/Negative on failure
+ *
+ * Programmer: Peter Cao
+ * September 28, 2005
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5O_post_copy_mesg_file (const H5O_class_t *type, H5F_t *file_src,
+ const void *mesg_src, H5G_entry_t *loc_dst,
+ hid_t dxpl_id, H5SL_t *map_list)
+{
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER_NOAPI_NOINIT(H5O_post_copy_mesg_file)
+
+ /* check args */
+ HDassert(type);
+ HDassert(file_src);
+ HDassert(mesg_src);
+ HDassert(loc_dst->file);
+ HDassert(map_list);
+
+ if(type->post_copy_file && (type->post_copy_file)(file_src, mesg_src, loc_dst, dxpl_id, map_list) < 0)
+ HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, FAIL, "unable to copy object header message to file")
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value)
+} /* H5O_post_copy_mesg_file */
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5O_copy_header_real
+ *
+ * Purpose: copy header object from one location to another.
+ *
+ * Return: Non-negative on success/Negative on failure
+ *
+ * Programmer: Peter Cao
+ * May 30, 2005
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5O_copy_header_real(const H5G_entry_t *ent_src,
+ H5G_entry_t *ent_dst /*out */, hid_t dxpl_id, H5SL_t *map_list)
+{
+ H5O_addr_map_t *addr_map; /* Address mapping of object copied */
+ uint8_t buf[16], *p;
+ H5O_t *oh = NULL;
+ unsigned chunkno = 0, mesgno = 0;
+ size_t chunk_size, hdr_size;
+ haddr_t addr_new;
+ H5O_mesg_t *mesg_src;
+ H5O_chunk_t *chunk;
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER_NOAPI_NOINIT(H5O_copy_header_real)
+
+ HDassert(ent_src);
+ HDassert(ent_src->file);
+ HDassert(H5F_addr_defined(ent_src->header));
+ HDassert(ent_dst->file);
+ HDassert(map_list);
+
+ if(NULL == (oh = H5AC_protect(ent_src->file, dxpl_id, H5AC_OHDR, ent_src->header, NULL, NULL, H5AC_READ)))
+ HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, FAIL, "unable to load object header")
+
+ /* get the size of the file header of the destination file */
+ hdr_size = H5O_SIZEOF_HDR(ent_dst->file);
+
+ /* allocate memory space for the destitnation chunks */
+ if(NULL == (chunk = H5FL_SEQ_MALLOC(H5O_chunk_t, (size_t)oh->nchunks)))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
+
+ /* Allocate space for the first chunk */
+ if(HADDR_UNDEF == (addr_new = H5MF_alloc(ent_dst->file, H5FD_MEM_OHDR, dxpl_id, (hsize_t)hdr_size + oh->chunk[0].size)))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "file allocation failed for object header")
+
+ /* Return the first chunk address */
+ ent_dst->header = addr_new;
+
+ /* Set chunk's address */
+ chunk[0].addr = addr_new + (hsize_t)hdr_size;
+
+ /* Encode header information */
+ p = buf;
+
+ /* encode version */
+ *p++ = H5O_VERSION;
+
+ /* reserved */
+ *p++ = 0;
+
+ /* encode number of messages */
+ UINT16ENCODE(p, oh->nmesgs);
+
+ /* encode link count (at zero initially) */
+ UINT32ENCODE(p, 0);
+
+ /* encode body size */
+ UINT32ENCODE(p, oh->chunk[0].size);
+
+ /* zero to alignment */
+ HDmemset(p, 0, (size_t)(hdr_size-12));
+
+ /* need to allocate all the chunks for the destination before copy the chunk message
+ because continuation chunk message will need to know the chunk address of address of
+ continuation block.
+ */
+ for(chunkno = 1; chunkno < oh->nchunks; chunkno++) {
+ if(HADDR_UNDEF == (chunk[chunkno].addr = H5MF_alloc(ent_dst->file, H5FD_MEM_OHDR, dxpl_id, (hsize_t)oh->chunk[chunkno].size)))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "file allocation failed for object header")
+ } /* end for */
+
+ /* Loop through chunks to copy chunk information */
+ for(chunkno = 0; chunkno < oh->nchunks; chunkno++) {
+ chunk_size = oh->chunk[chunkno].size;
+
+ /* copy chunk information */
+ chunk[chunkno].dirty = oh->chunk[chunkno].dirty;
+ chunk[chunkno].size = chunk_size;
+
+ /* create memory image for the new chunk */
+ if(NULL == (chunk[chunkno].image = H5FL_BLK_MALLOC(chunk_image,chunk_size)))
+ HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
+
+ /* copy the chunk image from source to destination in memory */
+ /* (This copies over all the messages which don't require special
+ * callbacks to fix them up.)
+ */
+ HDmemcpy(chunk[chunkno].image, oh->chunk[chunkno].image, chunk_size);
+
+ /* Loop through messages, to fix up any which refer to addresses in the source file, etc. */
+ for(mesgno = 0; mesgno < oh->nmesgs; mesgno++) {
+ const H5O_class_t *copy_type;
+
+ mesg_src = &(oh->mesg[mesgno]);
+
+ /* check if the message belongs to this chunk */
+ if(mesg_src->chunkno != chunkno)
+ continue;
+
+ if (mesg_src->flags & H5O_FLAG_SHARED)
+ copy_type = H5O_SHARED;
+ else
+ copy_type = mesg_src->type;
+
+ /* copy this message into destination file */
+ HDassert(copy_type);
+ if(copy_type->copy_file) {
+ void *dst_native; /* Pointer to copy of native information for current message */
+
+ /*
+ * Decode the message if necessary. If the message is shared then d
+ * a shared message, ignoring the message type.
+ */
+ if(NULL == mesg_src->native) {
+ /* Decode the message if necessary */
+ HDassert(copy_type->decode);
+ if(NULL == (mesg_src->native = (copy_type->decode)(ent_src->file, dxpl_id, mesg_src->raw, NULL)))
+ HGOTO_ERROR(H5E_OHDR, H5E_CANTDECODE, FAIL, "unable to decode a message")
+ } /* end if (NULL == mesg_src->native) */
+
+ /* Copy the source message */
+ if(H5O_CONT_ID == copy_type->id) {
+ if((dst_native = H5O_copy_mesg_file(copy_type, ent_src->file, mesg_src->native,
+ ent_dst->file, dxpl_id, map_list, chunk)) == NULL)
+ HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, FAIL, "unable to copy object header message")
+ } /* end if */
+ else {
+ if((dst_native = H5O_copy_mesg_file(copy_type, ent_src->file, mesg_src->native,
+ ent_dst->file, dxpl_id, map_list, NULL)) == NULL)
+ HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, FAIL, "unable to copy object header message")
+ } /* end else */
+
+ /* Calculate address in destination raw chunk */
+ p = chunk[chunkno].image + (mesg_src->raw - oh->chunk[chunkno].image);
+
+ /*
+ * Encode the message. If the message is shared then we
+ * encode a Shared Object message instead of the object
+ * which is being shared.
+ */
+ if((copy_type->encode)(ent_dst->file, p, dst_native) < 0)
+ HGOTO_ERROR(H5E_OHDR, H5E_CANTENCODE, FAIL, "unable to encode object header message")
+
+ /* Release native destination info */
+ H5O_free_real(copy_type, dst_native);
+ } /* end if (mesg_src->type && mesg_src->type->copy_file) */
+ } /* end of mesgno loop */
+
+ /* Write the object header to the file if this is the first chunk */
+ if(chunkno == 0)
+ if(H5F_block_write(ent_dst->file, H5FD_MEM_OHDR, addr_new, hdr_size, dxpl_id, buf) < 0)
+ HGOTO_ERROR(H5E_OHDR, H5E_WRITEERROR, FAIL, "unable to write object header hdr to disk")
+
+ /* Write this chunk into disk */
+ if(H5F_block_write(ent_dst->file, H5FD_MEM_OHDR, chunk[chunkno].addr, chunk[chunkno].size, dxpl_id, chunk[chunkno].image) < 0)
+ HGOTO_ERROR(H5E_OHDR, H5E_WRITEERROR, FAIL, "unable to write object header data to disk")
+ } /* end of chunkno loop */
+
+ /* Allocate space for the address mapping of the object copied */
+ if(NULL == (addr_map = H5FL_MALLOC(H5O_addr_map_t)))
+ HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
+
+ /* Insert the address mapping for the new object into the copied list */
+ /* (Do this here, because "post copy" possibly checks it) */
+ addr_map->src_addr = ent_src->header;
+ addr_map->dst_addr = ent_dst->header;
+ if(H5SL_insert(map_list, addr_map, &(addr_map->src_addr)) < 0)
+ HGOTO_ERROR(H5E_OHDR, H5E_CANTINSERT, FAIL, "can't insert object into skip list")
+
+ /* "post copy" loop over messages */
+ for(mesgno = 0; mesgno < oh->nmesgs; mesgno++) {
+ const H5O_class_t *copy_type;
+
+ mesg_src = &(oh->mesg[mesgno]);
+
+ if (mesg_src->flags & H5O_FLAG_SHARED)
+ copy_type = H5O_SHARED;
+ else
+ copy_type = mesg_src->type;
+
+ HDassert(copy_type);
+ if(mesg_src->native) {
+ if((H5O_post_copy_mesg_file(copy_type, ent_src->file, mesg_src->native,
+ ent_dst, dxpl_id, map_list)) < 0)
+ HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, FAIL, "unable to copy object header message")
+ } /* end if */
+ } /* end for */
+
+done:
+ /* Release pointer to object header itself */
+ if(oh != NULL) {
+ for(chunkno = 0; chunkno < oh->nchunks; chunkno++)
+ H5FL_BLK_FREE(chunk_image, chunk[chunkno].image);
+ H5FL_SEQ_FREE(H5O_chunk_t, chunk);
+
+ if(H5AC_unprotect(ent_src->file, dxpl_id, H5AC_OHDR, ent_src->header, oh, H5AC__NO_FLAGS_SET) < 0)
+ HDONE_ERROR(H5E_OHDR, H5E_PROTECT, FAIL, "unable to release object header")
+ } /* end if */
+
+ FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5O_copy_header_real() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5O_copy_header_map
+ *
+ * Purpose: Copy header object from one location to another, detecting
+ * already mapped objects, etc.
+ *
+ * Return: Non-negative on success/Negative on failure
+ *
+ * Programmer: Quincey Koziol
+ * November 1, 2005
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5O_copy_header_map(const H5G_entry_t *ent_src,
+ H5G_entry_t *ent_dst /*out */, hid_t dxpl_id, H5SL_t *map_list)
+{
+ H5O_addr_map_t *addr_map; /* Address mapping of object copied */
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER_NOAPI(H5O_copy_header_map, FAIL)
+
+ /* Sanity check */
+ HDassert(ent_src);
+ HDassert(ent_dst);
+ HDassert(ent_dst->file);
+ HDassert(map_list);
+
+ /* Look up the address of the object to copy in the skip list */
+ addr_map = (H5O_addr_map_t *)H5SL_search(map_list, &(ent_src->header));
+
+ /* Check if address is already in list of objects copied */
+ if(addr_map == NULL) {
+ /* Copy object for the first time */
+
+ /* Copy object referred to */
+ if(H5O_copy_header_real(ent_src, ent_dst, dxpl_id, map_list) < 0)
+ HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, FAIL, "unable to copy object")
+ } /* end if */
+ else {
+ /* Object has already been copied, set it's address in destination file */
+ ent_dst->header = addr_map->dst_addr;
+ } /* end else */
+
+ /* Increment destination object's link count */
+ if(H5O_link(ent_dst, 1, dxpl_id) < 0)
+ HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, FAIL, "unable to increment object link count")
+
+done:
+ FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5O_copy_header_map() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
+ H5O_copy_free_addrmap_cb
+ PURPOSE
+ Internal routine to free address maps from the skip list for copying objects
+ USAGE
+ herr_t H5O_copy_free_addrmap_cb(item, key, op_data)
+ void *item; IN/OUT: Pointer to addr
+ void *key; IN/OUT: (unused)
+ void *op_data; IN: (unused)
+ RETURNS
+ Returns zero on success, negative on failure.
+ DESCRIPTION
+ Releases the memory for the address.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+static herr_t
+H5O_copy_free_addrmap_cb(void *item, void UNUSED *key, void UNUSED *op_data)
+{
+ FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5O_copy_free_addrmap_cb)
+
+ HDassert(item);
+
+ /* Release the item */
+ H5FL_FREE(H5O_addr_map_t, item);
+
+ FUNC_LEAVE_NOAPI(0)
+} /* H5O_copy_free_addrmap_cb() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5O_copy_header
+ *
+ * Purpose: copy header object from one location to another.
+ *
+ * Return: Non-negative on success/Negative on failure
+ *
+ * Programmer: Peter Cao
+ * May 30, 2005
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5O_copy_header(const H5G_entry_t *ent_src,
+ H5G_entry_t *ent_dst /*out */, hid_t dxpl_id)
+{
+ H5SL_t *map_list = NULL; /* Skip list to hold address mappings */
+ herr_t ret_value = SUCCEED;
+
+ FUNC_ENTER_NOAPI(H5O_copy_header, FAIL)
+
+ HDassert(ent_src);
+ HDassert(ent_src->file);
+ HDassert(H5F_addr_defined(ent_src->header));
+ HDassert(ent_dst->file);
+
+ /* Create a skip list to keep track of which objects are copied */
+ if((map_list = H5SL_create(H5SL_TYPE_HADDR, 0.5, 16)) == NULL)
+ HGOTO_ERROR(H5E_SLIST, H5E_CANTCREATE, FAIL, "cannot make skip list")
+
+ /* copy the object from the source file to the destination file */
+ if(H5O_copy_header_real(ent_src, ent_dst, dxpl_id, map_list) < 0)
+ HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, FAIL, "unable to copy object")
+
+done:
+ if(map_list)
+ H5SL_destroy(map_list, H5O_copy_free_addrmap_cb, NULL);
+
+ FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5O_copy_header() */
+
+
+/*-------------------------------------------------------------------------
* Function: H5O_debug_id
*
* Purpose: Act as a proxy for calling the 'debug' method for a
generated by cgit v0.12 at 2024-11-06 08:44:50 (GMT)