/src/hdf5/src/H5Ochunk.c

Source (jump to first uncovered line)
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * Copyright by The HDF Group.                                               *
 * 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 COPYING file, which can be found at the root of the source code       *
 * distribution tree, or in https://www.hdfgroup.org/licenses.               *
 * If you do not have access to either file, you may request a copy from     *
 * help@hdfgroup.org.                                                        *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

/*-------------------------------------------------------------------------
 *
 * Created:   H5Ochunk.c
 *
 * Purpose:   Object header chunk routines.
 *
 *-------------------------------------------------------------------------
 */

/****************/
/* Module Setup */
/****************/

#include "H5Omodule.h" /* This source code file is part of the H5O module */

/***********/
/* Headers */
/***********/
#include "H5private.h"   /* Generic Functions     */
#include "H5Eprivate.h"  /* Error handling        */
#include "H5FLprivate.h" /* Free Lists                               */
#include "H5Opkg.h"      /* Object headers      */

/****************/
/* Local Macros */
/****************/

/******************/
/* Local Typedefs */
/******************/

/********************/
/* Package Typedefs */
/********************/

/********************/
/* Local Prototypes */
/********************/

/*********************/
/* Package Variables */
/*********************/

/* Declare the free list for H5O_chunk_proxy_t's */
H5FL_DEFINE(H5O_chunk_proxy_t);

/*****************************/
/* Library Private Variables */
/*****************************/

/*******************/
/* Local Variables */
/*******************/

/*-------------------------------------------------------------------------
 * Function:    H5O__chunk_add
 *
 * Purpose:     Add new chunk for object header to metadata cache
 *
 * Return:      SUCCEED/FAIL
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5O__chunk_add(H5F_t *f, H5O_t *oh, unsigned idx, unsigned cont_chunkno)
{
    H5O_chunk_proxy_t *chk_proxy = NULL; /* Proxy for chunk, to mark it dirty in the cache */
    H5O_chunk_proxy_t *cont_chk_proxy =
        NULL; /* Proxy for chunk containing continuation message that points to this chunk, if not chunk 0 */
    herr_t ret_value = SUCCEED; /* Return value */

    FUNC_ENTER_PACKAGE_TAG(oh->cache_info.addr)

    /* check args */
    assert(f);
    assert(oh);
    assert(idx < oh->nchunks);
    assert(idx > 0);

    /* Allocate space for the object header data structure */
    if (NULL == (chk_proxy = H5FL_CALLOC(H5O_chunk_proxy_t)))
        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");

    /* Increment reference count on object header */
    if (H5O__inc_rc(oh) < 0)
        HGOTO_ERROR(H5E_OHDR, H5E_CANTINC, FAIL, "can't increment reference count on object header");

    /* Set the values in the chunk proxy */
    chk_proxy->f       = f;
    chk_proxy->oh      = oh;
    chk_proxy->chunkno = idx;

    /* Determine the parent of the chunk */
    if (cont_chunkno != 0) {
        if (NULL == (cont_chk_proxy = H5O__chunk_protect(f, oh, cont_chunkno)))
            HGOTO_ERROR(H5E_OHDR, H5E_CANTPROTECT, FAIL, "unable to load object header chunk");
        chk_proxy->fd_parent = cont_chk_proxy;
    } /* end else */

    /* Insert the chunk proxy into the cache */
    if (H5AC_insert_entry(f, H5AC_OHDR_CHK, oh->chunk[idx].addr, chk_proxy, H5AC__NO_FLAGS_SET) < 0)
        HGOTO_ERROR(H5E_OHDR, H5E_CANTINSERT, FAIL, "unable to cache object header chunk");

    chk_proxy = NULL;

done:
    /* Cleanup on failure */
    if (ret_value < 0)
        if (chk_proxy && H5O__chunk_dest(chk_proxy) < 0)
            HDONE_ERROR(H5E_OHDR, H5E_CANTRELEASE, FAIL, "unable to destroy object header chunk");

    /* Release resources */
    if (cont_chk_proxy)
        if (H5O__chunk_unprotect(f, cont_chk_proxy, false) < 0)
            HDONE_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to unprotect object header chunk");

    FUNC_LEAVE_NOAPI_TAG(ret_value)
} /* end H5O__chunk_add() */

/*-------------------------------------------------------------------------
 * Function:    H5O__chunk_protect
 *
 * Purpose:     Protect an object header chunk for modifications
 *
 * Return:      SUCCEED/FAIL
 *
 *-------------------------------------------------------------------------
 */
H5O_chunk_proxy_t *
H5O__chunk_protect(H5F_t *f, H5O_t *oh, unsigned idx)
{
    H5O_chunk_proxy_t *chk_proxy = NULL; /* Proxy for protected chunk */
    H5O_chunk_proxy_t *ret_value = NULL; /* Return value */

    FUNC_ENTER_PACKAGE_TAG(oh->cache_info.addr)

    /* check args */
    assert(f);
    assert(oh);
    assert(idx < oh->nchunks);

    /* Check for protecting first chunk */
    if (0 == idx) {
        /* Create new "fake" chunk proxy for first chunk */
        /* (since the first chunk is already handled by the H5O_t object) */
        if (NULL == (chk_proxy = H5FL_CALLOC(H5O_chunk_proxy_t)))
            HGOTO_ERROR(H5E_OHDR, H5E_CANTALLOC, NULL, "memory allocation failed");

        /* Increment reference count on object header */
        if (H5O__inc_rc(oh) < 0)
            HGOTO_ERROR(H5E_OHDR, H5E_CANTINC, NULL, "can't increment reference count on object header");

        /* Set chunk proxy fields */
        chk_proxy->f       = f;
        chk_proxy->oh      = oh;
        chk_proxy->chunkno = idx;
    } /* end if */
    else {
        H5O_chk_cache_ud_t chk_udata; /* User data for loading chunk */

        /* Construct the user data for protecting chunk proxy */
        /* (and _not_ decoding it) */
        memset(&chk_udata, 0, sizeof(chk_udata));
        chk_udata.oh      = oh;
        chk_udata.chunkno = idx;
        chk_udata.size    = oh->chunk[idx].size;

        /* Get the chunk proxy */
        if (NULL == (chk_proxy = (H5O_chunk_proxy_t *)H5AC_protect(f, H5AC_OHDR_CHK, oh->chunk[idx].addr,
                                                                   &chk_udata, H5AC__NO_FLAGS_SET)))
            HGOTO_ERROR(H5E_OHDR, H5E_CANTPROTECT, NULL, "unable to load object header chunk");

        /* Sanity check */
        assert(chk_proxy->oh == oh);
        assert(chk_proxy->chunkno == idx);
    } /* end else */

    /* Set return value */
    ret_value = chk_proxy;

done:
    /* Cleanup on error */
    if (!ret_value)
        if (0 == idx && chk_proxy && H5O__chunk_dest(chk_proxy) < 0)
            HDONE_ERROR(H5E_OHDR, H5E_CANTRELEASE, NULL, "unable to destroy object header chunk");

    FUNC_LEAVE_NOAPI_TAG(ret_value)
} /* end H5O__chunk_protect() */

/*-------------------------------------------------------------------------
 * Function:    H5O__chunk_unprotect
 *
 * Purpose:     Unprotect an object header chunk after modifications
 *
 * Return:      SUCCEED/FAIL
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5O__chunk_unprotect(H5F_t *f, H5O_chunk_proxy_t *chk_proxy, bool dirtied)
{
    herr_t ret_value = SUCCEED; /* Return value */

    FUNC_ENTER_PACKAGE

    /* check args */
    assert(f);
    assert(chk_proxy);

    /* Check for releasing first chunk */
    if (0 == chk_proxy->chunkno) {
        /* Check for dirtying the first chunk */
        if (dirtied) {
            /* Mark object header as dirty in cache */
            if (H5AC_mark_entry_dirty(chk_proxy->oh) < 0)
                HGOTO_ERROR(H5E_OHDR, H5E_CANTMARKDIRTY, FAIL, "unable to mark object header as dirty");
        } /* end else/if */

        /* Decrement reference count of object header */
        if (H5O__dec_rc(chk_proxy->oh) < 0)
            HGOTO_ERROR(H5E_OHDR, H5E_CANTDEC, FAIL, "can't decrement reference count on object header");

        /* Free fake chunk proxy */
        chk_proxy = H5FL_FREE(H5O_chunk_proxy_t, chk_proxy);
    } /* end if */
    else {
        /* Release the chunk proxy from the cache, possibly marking it dirty */
        if (H5AC_unprotect(f, H5AC_OHDR_CHK, chk_proxy->oh->chunk[chk_proxy->chunkno].addr, chk_proxy,
                           (dirtied ? H5AC__DIRTIED_FLAG : H5AC__NO_FLAGS_SET)) < 0)
            HGOTO_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to release object header chunk");
    } /* end else */

done:
    FUNC_LEAVE_NOAPI(ret_value)
} /* end H5O__chunk_unprotect() */

/*-------------------------------------------------------------------------
 * Function:    H5O__chunk_resize
 *
 * Purpose:     Resize an object header chunk
 *
 * Return:      SUCCEED/FAIL
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5O__chunk_resize(H5O_t *oh, H5O_chunk_proxy_t *chk_proxy)
{
    herr_t ret_value = SUCCEED; /* Return value */

    FUNC_ENTER_PACKAGE

    /* check args */
    assert(oh);
    assert(chk_proxy);

    /* Check for resizing first chunk */
    if (0 == chk_proxy->chunkno) {
        /* Resize object header in cache */
        if (H5AC_resize_entry(oh, oh->chunk[0].size) < 0)
            HGOTO_ERROR(H5E_OHDR, H5E_CANTRESIZE, FAIL, "unable to resize chunk in cache");
    } /* end if */
    else {
        /* Resize chunk in cache */
        if (H5AC_resize_entry(chk_proxy, oh->chunk[chk_proxy->chunkno].size) < 0)
            HGOTO_ERROR(H5E_OHDR, H5E_CANTRESIZE, FAIL, "unable to resize chunk in cache");
    } /* end else */

done:
    FUNC_LEAVE_NOAPI(ret_value)
} /* end H5O__chunk_resize() */

/*-------------------------------------------------------------------------
 * Function:    H5O__chunk_update_idx
 *
 * Purpose:     Update the chunk index for a chunk proxy
 *
 * Return:      SUCCEED/FAIL
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5O__chunk_update_idx(H5F_t *f, H5O_t *oh, unsigned idx)
{
    H5O_chunk_proxy_t *chk_proxy = NULL;    /* Proxy for chunk, to mark it dirty in the cache */
    H5O_chk_cache_ud_t chk_udata;           /* User data for loading chunk */
    herr_t             ret_value = SUCCEED; /* Return value */

    FUNC_ENTER_PACKAGE_TAG(oh->cache_info.addr)

    /* check args */
    assert(f);
    assert(oh);
    assert(idx < oh->nchunks);
    assert(idx > 0);

    /* Construct the user data for protecting chunk proxy */
    /* (and _not_ decoding it) */
    memset(&chk_udata, 0, sizeof(chk_udata));
    chk_udata.oh      = oh;
    chk_udata.chunkno = idx;
    chk_udata.size    = oh->chunk[idx].size;

    /* Get the chunk proxy */
    if (NULL == (chk_proxy = (H5O_chunk_proxy_t *)H5AC_protect(f, H5AC_OHDR_CHK, oh->chunk[idx].addr,
                                                               &chk_udata, H5AC__NO_FLAGS_SET)))
        HGOTO_ERROR(H5E_OHDR, H5E_CANTPROTECT, FAIL, "unable to load object header chunk");

    /* Update index for chunk proxy in cache */
    chk_proxy->chunkno = idx;

    /* Release the chunk proxy from the cache, marking it deleted */
    if (H5AC_unprotect(f, H5AC_OHDR_CHK, oh->chunk[idx].addr, chk_proxy, H5AC__DIRTIED_FLAG) < 0)
        HGOTO_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to release object header chunk");

done:
    FUNC_LEAVE_NOAPI_TAG(ret_value)
} /* end H5O__chunk_update_idx() */

/*-------------------------------------------------------------------------
 * Function:    H5O__chunk_delete
 *
 * Purpose:     Notify metadata cache that a chunk has been deleted
 *
 * Return:      SUCCEED/FAIL
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5O__chunk_delete(H5F_t *f, H5O_t *oh, unsigned idx)
{
    H5O_chunk_proxy_t *chk_proxy   = NULL;               /* Proxy for chunk, to mark it dirty in the cache */
    unsigned           cache_flags = H5AC__DELETED_FLAG; /* Flags for unprotecting proxy */
    herr_t             ret_value   = SUCCEED;            /* Return value */

    FUNC_ENTER_PACKAGE_TAG(oh->cache_info.addr)

    /* check args */
    assert(f);
    assert(oh);
    assert(idx < oh->nchunks);
    assert(idx > 0);

    /* Get the chunk proxy */
    if (NULL == (chk_proxy = H5O__chunk_protect(f, oh, idx)))
        HGOTO_ERROR(H5E_OHDR, H5E_CANTPROTECT, FAIL, "unable to load object header chunk");

    /* Only free file space if not doing SWMR writes */
    if (!oh->swmr_write)
        cache_flags |= H5AC__DIRTIED_FLAG | H5AC__FREE_FILE_SPACE_FLAG;

done:
    /* Release the chunk proxy from the cache, marking it deleted */
    if (chk_proxy && H5AC_unprotect(f, H5AC_OHDR_CHK, oh->chunk[idx].addr, chk_proxy, cache_flags) < 0)
        HDONE_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to release object header chunk");

    FUNC_LEAVE_NOAPI_TAG(ret_value)
} /* end H5O__chunk_delete() */

/*-------------------------------------------------------------------------
 * Function:    H5O__chunk_dest
 *
 * Purpose:     Destroy a chunk proxy object
 *
 * Return:      SUCCEED/FAIL
 *
 *-------------------------------------------------------------------------
 */
herr_t
H5O__chunk_dest(H5O_chunk_proxy_t *chk_proxy)
{
    herr_t ret_value = SUCCEED; /* Return value */

    FUNC_ENTER_PACKAGE

    /* Check arguments */
    assert(chk_proxy);

    /* Decrement reference count of object header */
    if (H5O__dec_rc(chk_proxy->oh) < 0)
        HGOTO_ERROR(H5E_OHDR, H5E_CANTDEC, FAIL, "can't decrement reference count on object header");

done:
    /* Release the chunk proxy object */
    chk_proxy = H5FL_FREE(H5O_chunk_proxy_t, chk_proxy);

    FUNC_LEAVE_NOAPI(ret_value)
} /* H5O__chunk_dest() */

Coverage Report

Created: 2024-06-18 06:29

Line	Count	Source (jump to first uncovered line)
1		/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2		* Copyright by The HDF Group. *
3		* All rights reserved. *
4		* *
5		* This file is part of HDF5. The full HDF5 copyright notice, including *
6		* terms governing use, modification, and redistribution, is contained in *
7		* the COPYING file, which can be found at the root of the source code *
8		* distribution tree, or in https://www.hdfgroup.org/licenses. *
9		* If you do not have access to either file, you may request a copy from *
10		* help@hdfgroup.org. *
11		* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
12
13		/*-------------------------------------------------------------------------
14		*
15		* Created: H5Ochunk.c
16		*
17		* Purpose: Object header chunk routines.
18		*
19		*-------------------------------------------------------------------------
20		*/
21
22		/****************/
23		/* Module Setup */
24		/****************/
25
26		#include "H5Omodule.h" /* This source code file is part of the H5O module */
27
28		/***********/
29		/* Headers */
30		/***********/
31		#include "H5private.h" /* Generic Functions */
32		#include "H5Eprivate.h" /* Error handling */
33		#include "H5FLprivate.h" /* Free Lists */
34		#include "H5Opkg.h" /* Object headers */
35
36		/****************/
37		/* Local Macros */
38		/****************/
39
40		/******************/
41		/* Local Typedefs */
42		/******************/
43
44		/********************/
45		/* Package Typedefs */
46		/********************/
47
48		/********************/
49		/* Local Prototypes */
50		/********************/
51
52		/*********************/
53		/* Package Variables */
54		/*********************/
55
56		/* Declare the free list for H5O_chunk_proxy_t's */
57		H5FL_DEFINE(H5O_chunk_proxy_t);
58
59		/*****************************/
60		/* Library Private Variables */
61		/*****************************/
62
63		/*******************/
64		/* Local Variables */
65		/*******************/
66
67		/*-------------------------------------------------------------------------
68		* Function: H5O__chunk_add
69		*
70		* Purpose: Add new chunk for object header to metadata cache
71		*
72		* Return: SUCCEED/FAIL
73		*
74		*-------------------------------------------------------------------------
75		*/
76		herr_t
77		H5O__chunk_add(H5F_t f, H5O_t oh, unsigned idx, unsigned cont_chunkno)
78	0	{
79	0	H5O_chunk_proxy_t chk_proxy = NULL; / Proxy for chunk, to mark it dirty in the cache */
80	0	H5O_chunk_proxy_t *cont_chk_proxy =
81	0	NULL; /* Proxy for chunk containing continuation message that points to this chunk, if not chunk 0 */
82	0	herr_t ret_value = SUCCEED; /* Return value */
83
84	0	FUNC_ENTER_PACKAGE_TAG(oh->cache_info.addr)
85
86		/* check args */
87	0	assert(f);
88	0	assert(oh);
89	0	assert(idx < oh->nchunks);
90	0	assert(idx > 0);
91
92		/* Allocate space for the object header data structure */
93	0	if (NULL == (chk_proxy = H5FL_CALLOC(H5O_chunk_proxy_t)))
94	0	HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
95
96		/* Increment reference count on object header */
97	0	if (H5O__inc_rc(oh) < 0)
98	0	HGOTO_ERROR(H5E_OHDR, H5E_CANTINC, FAIL, "can't increment reference count on object header");
99
100		/* Set the values in the chunk proxy */
101	0	chk_proxy->f = f;
102	0	chk_proxy->oh = oh;
103	0	chk_proxy->chunkno = idx;
104
105		/* Determine the parent of the chunk */
106	0	if (cont_chunkno != 0) {
107	0	if (NULL == (cont_chk_proxy = H5O__chunk_protect(f, oh, cont_chunkno)))
108	0	HGOTO_ERROR(H5E_OHDR, H5E_CANTPROTECT, FAIL, "unable to load object header chunk");
109	0	chk_proxy->fd_parent = cont_chk_proxy;
110	0	} /* end else */
111
112		/* Insert the chunk proxy into the cache */
113	0	if (H5AC_insert_entry(f, H5AC_OHDR_CHK, oh->chunk[idx].addr, chk_proxy, H5AC__NO_FLAGS_SET) < 0)
114	0	HGOTO_ERROR(H5E_OHDR, H5E_CANTINSERT, FAIL, "unable to cache object header chunk");
115
116	0	chk_proxy = NULL;
117
118	0	done:
119		/* Cleanup on failure */
120	0	if (ret_value < 0)
121	0	if (chk_proxy && H5O__chunk_dest(chk_proxy) < 0)
122	0	HDONE_ERROR(H5E_OHDR, H5E_CANTRELEASE, FAIL, "unable to destroy object header chunk");
123
124		/* Release resources */
125	0	if (cont_chk_proxy)
126	0	if (H5O__chunk_unprotect(f, cont_chk_proxy, false) < 0)
127	0	HDONE_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to unprotect object header chunk");
128
129	0	FUNC_LEAVE_NOAPI_TAG(ret_value)
130	0	} /* end H5O__chunk_add() */
131
132		/*-------------------------------------------------------------------------
133		* Function: H5O__chunk_protect
134		*
135		* Purpose: Protect an object header chunk for modifications
136		*
137		* Return: SUCCEED/FAIL
138		*
139		*-------------------------------------------------------------------------
140		*/
141		H5O_chunk_proxy_t *
142		H5O__chunk_protect(H5F_t f, H5O_t oh, unsigned idx)
143	0	{
144	0	H5O_chunk_proxy_t chk_proxy = NULL; / Proxy for protected chunk */
145	0	H5O_chunk_proxy_t ret_value = NULL; / Return value */
146
147	0	FUNC_ENTER_PACKAGE_TAG(oh->cache_info.addr)
148
149		/* check args */
150	0	assert(f);
151	0	assert(oh);
152	0	assert(idx < oh->nchunks);
153
154		/* Check for protecting first chunk */
155	0	if (0 == idx) {
156		/* Create new "fake" chunk proxy for first chunk */
157		/* (since the first chunk is already handled by the H5O_t object) */
158	0	if (NULL == (chk_proxy = H5FL_CALLOC(H5O_chunk_proxy_t)))
159	0	HGOTO_ERROR(H5E_OHDR, H5E_CANTALLOC, NULL, "memory allocation failed");
160
161		/* Increment reference count on object header */
162	0	if (H5O__inc_rc(oh) < 0)
163	0	HGOTO_ERROR(H5E_OHDR, H5E_CANTINC, NULL, "can't increment reference count on object header");
164
165		/* Set chunk proxy fields */
166	0	chk_proxy->f = f;
167	0	chk_proxy->oh = oh;
168	0	chk_proxy->chunkno = idx;
169	0	} /* end if */
170	0	else {
171	0	H5O_chk_cache_ud_t chk_udata; /* User data for loading chunk */
172
173		/* Construct the user data for protecting chunk proxy */
174		/* (and _not_ decoding it) */
175	0	memset(&chk_udata, 0, sizeof(chk_udata));
176	0	chk_udata.oh = oh;
177	0	chk_udata.chunkno = idx;
178	0	chk_udata.size = oh->chunk[idx].size;
179
180		/* Get the chunk proxy */
181	0	if (NULL == (chk_proxy = (H5O_chunk_proxy_t *)H5AC_protect(f, H5AC_OHDR_CHK, oh->chunk[idx].addr,
182	0	&chk_udata, H5AC__NO_FLAGS_SET)))
183	0	HGOTO_ERROR(H5E_OHDR, H5E_CANTPROTECT, NULL, "unable to load object header chunk");
184
185		/* Sanity check */
186	0	assert(chk_proxy->oh == oh);
187	0	assert(chk_proxy->chunkno == idx);
188	0	} /* end else */
189
190		/* Set return value */
191	0	ret_value = chk_proxy;
192
193	0	done:
194		/* Cleanup on error */
195	0	if (!ret_value)
196	0	if (0 == idx && chk_proxy && H5O__chunk_dest(chk_proxy) < 0)
197	0	HDONE_ERROR(H5E_OHDR, H5E_CANTRELEASE, NULL, "unable to destroy object header chunk");
198
199	0	FUNC_LEAVE_NOAPI_TAG(ret_value)
200	0	} /* end H5O__chunk_protect() */
201
202		/*-------------------------------------------------------------------------
203		* Function: H5O__chunk_unprotect
204		*
205		* Purpose: Unprotect an object header chunk after modifications
206		*
207		* Return: SUCCEED/FAIL
208		*
209		*-------------------------------------------------------------------------
210		*/
211		herr_t
212		H5O__chunk_unprotect(H5F_t f, H5O_chunk_proxy_t chk_proxy, bool dirtied)
213	0	{
214	0	herr_t ret_value = SUCCEED; /* Return value */
215
216	0	FUNC_ENTER_PACKAGE
217
218		/* check args */
219	0	assert(f);
220	0	assert(chk_proxy);
221
222		/* Check for releasing first chunk */
223	0	if (0 == chk_proxy->chunkno) {
224		/* Check for dirtying the first chunk */
225	0	if (dirtied) {
226		/* Mark object header as dirty in cache */
227	0	if (H5AC_mark_entry_dirty(chk_proxy->oh) < 0)
228	0	HGOTO_ERROR(H5E_OHDR, H5E_CANTMARKDIRTY, FAIL, "unable to mark object header as dirty");
229	0	} /* end else/if */
230
231		/* Decrement reference count of object header */
232	0	if (H5O__dec_rc(chk_proxy->oh) < 0)
233	0	HGOTO_ERROR(H5E_OHDR, H5E_CANTDEC, FAIL, "can't decrement reference count on object header");
234
235		/* Free fake chunk proxy */
236	0	chk_proxy = H5FL_FREE(H5O_chunk_proxy_t, chk_proxy);
237	0	} /* end if */
238	0	else {
239		/* Release the chunk proxy from the cache, possibly marking it dirty */
240	0	if (H5AC_unprotect(f, H5AC_OHDR_CHK, chk_proxy->oh->chunk[chk_proxy->chunkno].addr, chk_proxy,
241	0	(dirtied ? H5AC__DIRTIED_FLAG : H5AC__NO_FLAGS_SET)) < 0)
242	0	HGOTO_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to release object header chunk");
243	0	} /* end else */
244
245	0	done:
246	0	FUNC_LEAVE_NOAPI(ret_value)
247	0	} /* end H5O__chunk_unprotect() */
248
249		/*-------------------------------------------------------------------------
250		* Function: H5O__chunk_resize
251		*
252		* Purpose: Resize an object header chunk
253		*
254		* Return: SUCCEED/FAIL
255		*
256		*-------------------------------------------------------------------------
257		*/
258		herr_t
259		H5O__chunk_resize(H5O_t oh, H5O_chunk_proxy_t chk_proxy)
260	0	{
261	0	herr_t ret_value = SUCCEED; /* Return value */
262
263	0	FUNC_ENTER_PACKAGE
264
265		/* check args */
266	0	assert(oh);
267	0	assert(chk_proxy);
268
269		/* Check for resizing first chunk */
270	0	if (0 == chk_proxy->chunkno) {
271		/* Resize object header in cache */
272	0	if (H5AC_resize_entry(oh, oh->chunk[0].size) < 0)
273	0	HGOTO_ERROR(H5E_OHDR, H5E_CANTRESIZE, FAIL, "unable to resize chunk in cache");
274	0	} /* end if */
275	0	else {
276		/* Resize chunk in cache */
277	0	if (H5AC_resize_entry(chk_proxy, oh->chunk[chk_proxy->chunkno].size) < 0)
278	0	HGOTO_ERROR(H5E_OHDR, H5E_CANTRESIZE, FAIL, "unable to resize chunk in cache");
279	0	} /* end else */
280
281	0	done:
282	0	FUNC_LEAVE_NOAPI(ret_value)
283	0	} /* end H5O__chunk_resize() */
284
285		/*-------------------------------------------------------------------------
286		* Function: H5O__chunk_update_idx
287		*
288		* Purpose: Update the chunk index for a chunk proxy
289		*
290		* Return: SUCCEED/FAIL
291		*
292		*-------------------------------------------------------------------------
293		*/
294		herr_t
295		H5O__chunk_update_idx(H5F_t f, H5O_t oh, unsigned idx)
296	0	{
297	0	H5O_chunk_proxy_t chk_proxy = NULL; / Proxy for chunk, to mark it dirty in the cache */
298	0	H5O_chk_cache_ud_t chk_udata; /* User data for loading chunk */
299	0	herr_t ret_value = SUCCEED; /* Return value */
300
301	0	FUNC_ENTER_PACKAGE_TAG(oh->cache_info.addr)
302
303		/* check args */
304	0	assert(f);
305	0	assert(oh);
306	0	assert(idx < oh->nchunks);
307	0	assert(idx > 0);
308
309		/* Construct the user data for protecting chunk proxy */
310		/* (and _not_ decoding it) */
311	0	memset(&chk_udata, 0, sizeof(chk_udata));
312	0	chk_udata.oh = oh;
313	0	chk_udata.chunkno = idx;
314	0	chk_udata.size = oh->chunk[idx].size;
315
316		/* Get the chunk proxy */
317	0	if (NULL == (chk_proxy = (H5O_chunk_proxy_t *)H5AC_protect(f, H5AC_OHDR_CHK, oh->chunk[idx].addr,
318	0	&chk_udata, H5AC__NO_FLAGS_SET)))
319	0	HGOTO_ERROR(H5E_OHDR, H5E_CANTPROTECT, FAIL, "unable to load object header chunk");
320
321		/* Update index for chunk proxy in cache */
322	0	chk_proxy->chunkno = idx;
323
324		/* Release the chunk proxy from the cache, marking it deleted */
325	0	if (H5AC_unprotect(f, H5AC_OHDR_CHK, oh->chunk[idx].addr, chk_proxy, H5AC__DIRTIED_FLAG) < 0)
326	0	HGOTO_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to release object header chunk");
327
328	0	done:
329	0	FUNC_LEAVE_NOAPI_TAG(ret_value)
330	0	} /* end H5O__chunk_update_idx() */
331
332		/*-------------------------------------------------------------------------
333		* Function: H5O__chunk_delete
334		*
335		* Purpose: Notify metadata cache that a chunk has been deleted
336		*
337		* Return: SUCCEED/FAIL
338		*
339		*-------------------------------------------------------------------------
340		*/
341		herr_t
342		H5O__chunk_delete(H5F_t f, H5O_t oh, unsigned idx)
343	0	{
344	0	H5O_chunk_proxy_t chk_proxy = NULL; / Proxy for chunk, to mark it dirty in the cache */
345	0	unsigned cache_flags = H5AC__DELETED_FLAG; /* Flags for unprotecting proxy */
346	0	herr_t ret_value = SUCCEED; /* Return value */
347
348	0	FUNC_ENTER_PACKAGE_TAG(oh->cache_info.addr)
349
350		/* check args */
351	0	assert(f);
352	0	assert(oh);
353	0	assert(idx < oh->nchunks);
354	0	assert(idx > 0);
355
356		/* Get the chunk proxy */
357	0	if (NULL == (chk_proxy = H5O__chunk_protect(f, oh, idx)))
358	0	HGOTO_ERROR(H5E_OHDR, H5E_CANTPROTECT, FAIL, "unable to load object header chunk");
359
360		/* Only free file space if not doing SWMR writes */
361	0	if (!oh->swmr_write)
362	0	cache_flags \|= H5AC__DIRTIED_FLAG \| H5AC__FREE_FILE_SPACE_FLAG;
363
364	0	done:
365		/* Release the chunk proxy from the cache, marking it deleted */
366	0	if (chk_proxy && H5AC_unprotect(f, H5AC_OHDR_CHK, oh->chunk[idx].addr, chk_proxy, cache_flags) < 0)
367	0	HDONE_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to release object header chunk");
368
369	0	FUNC_LEAVE_NOAPI_TAG(ret_value)
370	0	} /* end H5O__chunk_delete() */
371
372		/*-------------------------------------------------------------------------
373		* Function: H5O__chunk_dest
374		*
375		* Purpose: Destroy a chunk proxy object
376		*
377		* Return: SUCCEED/FAIL
378		*
379		*-------------------------------------------------------------------------
380		*/
381		herr_t
382		H5O__chunk_dest(H5O_chunk_proxy_t *chk_proxy)
383	10	{
384	10	herr_t ret_value = SUCCEED; /* Return value */
385
386	10	FUNC_ENTER_PACKAGE
387
388		/* Check arguments */
389	10	assert(chk_proxy);
390
391		/* Decrement reference count of object header */
392	10	if (H5O__dec_rc(chk_proxy->oh) < 0)
393	3	HGOTO_ERROR(H5E_OHDR, H5E_CANTDEC, FAIL, "can't decrement reference count on object header");
394
395	10	done:
396		/* Release the chunk proxy object */
397	10	chk_proxy = H5FL_FREE(H5O_chunk_proxy_t, chk_proxy);
398
399	10	FUNC_LEAVE_NOAPI(ret_value)
400	10	} /* H5O__chunk_dest() */