This is an automated email from the git hooks/post-receive script.

pini pushed a commit to branch master
in repository hdf5.

commit bc0473deab576f6b5ed222f83664344b52963c21
Author: Gilles Filippini <p...@debian.org>
Date:   Fri Oct 17 07:53:29 2014 +0200

    New patch HDFFV-8917.patch
    
    from upstream changeset r25681 to fix resource exhaustion bug.
---
 debian/changelog                |   7 +
 debian/patches/HDFFV-8917.patch | 301 ++++++++++++++++++++++++++++++++++++++++
 debian/patches/series           |   1 +
 3 files changed, 309 insertions(+)

diff --git a/debian/changelog b/debian/changelog
index 7f16df9..98e9952 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,10 @@
+hdf5 (1.8.13+docs-15) unstable; urgency=medium
+
+  * New patch HDFFV-8917.patch from upstream to fix a resource
+    exhaustion bug (closes: #765511).
+
+ -- Gilles Filippini <p...@debian.org>  Fri, 17 Oct 2014 07:51:24 +0200
+
 hdf5 (1.8.13+docs-14) unstable; urgency=medium
 
   * Use legacy library names in pkg-config files, to be consistent with
diff --git a/debian/patches/HDFFV-8917.patch b/debian/patches/HDFFV-8917.patch
new file mode 100644
index 0000000..0a158f3
--- /dev/null
+++ b/debian/patches/HDFFV-8917.patch
@@ -0,0 +1,301 @@
+Description: Merge upstream fix for issue HDFFV-8917
+ Changeset from upstream SVN r25681 (branches/hdf5_1_8).
+Index: hdf5/src/H5T.c
+===================================================================
+--- hdf5.orig/src/H5T.c
++++ hdf5/src/H5T.c
+@@ -529,7 +529,7 @@ H5FL_DEFINE_STATIC(H5T_path_t);
+ /* Datatype ID class */
+ static const H5I_class_t H5I_DATATYPE_CLS[1] = {{
+     H5I_DATATYPE,             /* ID class value */
+-    0,                                /* Class flags */
++    H5I_CLASS_REUSE_IDS,      /* Class flags */
+     8,                                /* # of reserved IDs for class */
+     (H5I_free_t)H5T_close     /* Callback routine for closing objects of this 
class */
+ }};
+Index: hdf5/src/H5E.c
+===================================================================
+--- hdf5.orig/src/H5E.c
++++ hdf5/src/H5E.c
+@@ -122,7 +122,7 @@ H5FL_DEFINE_STATIC(H5E_msg_t);
+ /* Error class ID class */
+ static const H5I_class_t H5I_ERRCLS_CLS[1] = {{
+     H5I_ERROR_CLASS,          /* ID class value */
+-    0,                                /* Class flags */
++    H5I_CLASS_REUSE_IDS,      /* Class flags */
+     0,                                /* # of reserved IDs for class */
+     (H5I_free_t)H5E_unregister_class /* Callback routine for closing objects 
of this class */
+ }};
+@@ -130,7 +130,7 @@ static const H5I_class_t H5I_ERRCLS_CLS[
+ /* Error message ID class */
+ static const H5I_class_t H5I_ERRMSG_CLS[1] = {{
+     H5I_ERROR_MSG,            /* ID class value */
+-    0,                                /* Class flags */
++    H5I_CLASS_REUSE_IDS,      /* Class flags */
+     0,                                /* # of reserved IDs for class */
+     (H5I_free_t)H5E_close_msg   /* Callback routine for closing objects of 
this class */
+ }};
+@@ -138,7 +138,7 @@ static const H5I_class_t H5I_ERRMSG_CLS[
+ /* Error stack ID class */
+ static const H5I_class_t H5I_ERRSTK_CLS[1] = {{
+     H5I_ERROR_STACK,          /* ID class value */
+-    0,                                /* Class flags */
++    H5I_CLASS_REUSE_IDS,      /* Class flags */
+     0,                                /* # of reserved IDs for class */
+     (H5I_free_t)H5E_close_stack /* Callback routine for closing objects of 
this class */
+ }};
+Index: hdf5/src/H5I.c
+===================================================================
+--- hdf5.orig/src/H5I.c
++++ hdf5/src/H5I.c
+@@ -814,7 +814,7 @@ H5I__wrapped_cb(void *_item, void UNUSED
+     HDassert(udata);
+ 
+     /* Break out if we see a free ID */
+-    if(udata->nextid != item->id) {
++    if(udata->nextid != (ID_MASK & item->id)) {
+         /* Sanity check */
+         HDassert(item->id > udata->nextid);
+ 
+@@ -874,6 +874,40 @@ H5I_register(H5I_type_t type, const void
+     /* If no available ID structure, then create a new id for use, and
+      * allocate a new struct to house it. */
+     else {
++        /*
++         * This next section of code checks for the 'nextid' getting too 
large and
++         * wrapping around, thus necessitating checking for duplicate IDs 
being
++         * handed out.
++         */
++        if(type_ptr->nextid > (hid_t)ID_MASK)
++            type_ptr->wrapped = TRUE;
++
++        /*
++         * If we've wrapped around then we need to check for duplicate id's 
being
++         * handed out.
++         */
++        if(type_ptr->wrapped) {
++            H5I_wrap_ud_t udata;    /* User data for iteration */
++            herr_t iter_status;     /* Iteration status */
++
++            /* Set up user data for iteration */
++            udata.nextid = (hid_t)type_ptr->cls->reserved;
++
++            /* Iterate over all the ID nodes, looking for a gap in the ID 
sequence */
++            if((iter_status = H5SL_iterate(type_ptr->ids, H5I__wrapped_cb, 
&udata)) < 0)
++                HGOTO_ERROR(H5E_ATOM, H5E_BADITER, FAIL, "ID iteration 
failed")
++
++            /* If we didn't break out of the iteration and we're at the max. 
ID, we've used all the IDs */
++            if(0 == iter_status && udata.nextid >= ID_MASK)
++                HGOTO_ERROR(H5E_ATOM, H5E_NOIDS, FAIL, "no IDs available in 
type")
++
++            /* Sanity check */
++            HDassert(udata.nextid < ID_MASK);
++
++            /* Retain the next ID for the class */
++            type_ptr->nextid = udata.nextid;
++        } /* end if */
++
+         /* Allocate new ID struct */
+         if(NULL == (id_ptr = H5FL_MALLOC(H5I_id_info_t)))
+             HGOTO_ERROR(H5E_ATOM, H5E_NOSPACE, FAIL, "memory allocation 
failed")
+@@ -895,40 +929,6 @@ H5I_register(H5I_type_t type, const void
+         HGOTO_ERROR(H5E_ATOM, H5E_CANTINSERT, FAIL, "can't insert ID node 
into skip list")
+     type_ptr->id_count++;
+ 
+-    /*
+-     * This next section of code checks for the 'nextid' getting too large and
+-     * wrapping around, thus necessitating checking for duplicate IDs being
+-     * handed out.
+-     */
+-    if(type_ptr->nextid > (hid_t)ID_MASK)
+-      type_ptr->wrapped = TRUE;
+-
+-    /*
+-     * If we've wrapped around then we need to check for duplicate id's being
+-     * handed out.
+-     */
+-    if(type_ptr->wrapped) {
+-        H5I_wrap_ud_t udata;    /* User data for iteration */
+-        herr_t iter_status;     /* Iteration status */
+-
+-        /* Set up user data for iteration */
+-        udata.nextid = (hid_t)type_ptr->cls->reserved;
+-
+-        /* Iterate over all the ID nodes, looking for a gap in the ID 
sequence */
+-        if((iter_status = H5SL_iterate(type_ptr->ids, H5I__wrapped_cb, 
&udata)) < 0)
+-            HGOTO_ERROR(H5E_ATOM, H5E_BADITER, FAIL, "ID iteration failed")
+-
+-        /* If we didn't break out of the iteration and we're at the max. ID, 
we've used all the IDs */
+-        if(0 == iter_status && udata.nextid >= ID_MASK)
+-            HGOTO_ERROR(H5E_ATOM, H5E_NOIDS, FAIL, "no IDs available in type")
+-
+-        /* Sanity check */
+-        HDassert(udata.nextid < ID_MASK);
+-
+-        /* Retain the next ID for the class */
+-        type_ptr->nextid = udata.nextid;
+-    } /* end if */
+-
+     /* Set return value */
+     ret_value = id_ptr->id;
+ 
+@@ -1249,13 +1249,24 @@ H5I__remove_common(H5I_id_type_t *type_p
+     /* (Casting away const OK -QAK) */
+     ret_value = (void *)curr_id->obj_ptr;
+ 
+-    /* If there's room, and we can save IDs of this type, then 
+-       save the struct (and its ID) for future re-use */
+-    if((type_ptr->cls->flags & H5I_CLASS_REUSE_IDS)
+-            && (type_ptr->avail_count < MAX_FREE_ID_STRUCTS)) {
+-        if(H5SL_insert(type_ptr->avail_ids, curr_id, &curr_id->id) < 0)
+-            HGOTO_ERROR(H5E_ATOM, H5E_CANTINSERT, NULL, "can't insert 
available ID node into skip list")
+-        type_ptr->avail_count++;
++    /* See if we can reuse IDs of this type */
++    if(type_ptr->cls->flags & H5I_CLASS_REUSE_IDS) {
++        /* See if we can decrement the next ID for the ID class */
++        if(type_ptr->nextid == (ID_MASK & (curr_id->id + 1))) {
++            type_ptr->nextid--;
++            curr_id = H5FL_FREE(H5I_id_info_t, curr_id);
++        } /* end if */
++        else {
++            /* Store the ID on the available ID list, for later */
++            if((type_ptr->avail_count < MAX_FREE_ID_STRUCTS)
++                    && (type_ptr->id_count > 1)) {
++                if(H5SL_insert(type_ptr->avail_ids, curr_id, &curr_id->id) < 
0)
++                    HGOTO_ERROR(H5E_ATOM, H5E_CANTINSERT, NULL, "can't insert 
available ID node into skip list")
++                type_ptr->avail_count++;
++            }
++            else
++                curr_id = H5FL_FREE(H5I_id_info_t, curr_id);
++        } /* end else */
+     } /* end if */
+     /* Otherwise, just toss it. */
+     else
+Index: hdf5/src/H5Pint.c
+===================================================================
+--- hdf5.orig/src/H5Pint.c
++++ hdf5/src/H5Pint.c
+@@ -276,7 +276,7 @@ static const H5I_class_t H5I_GENPROPCLS_
+ /* Generic Property List ID class */
+ static const H5I_class_t H5I_GENPROPLST_CLS[1] = {{
+     H5I_GENPROP_LST,          /* ID class value */
+-    0,                                /* Class flags */
++    H5I_CLASS_REUSE_IDS,      /* Class flags */
+     0,                                /* # of reserved IDs for class */
+     (H5I_free_t)H5P_close     /* Callback routine for closing objects of this 
class */
+ }};
+Index: hdf5/test/tid.c
+===================================================================
+--- hdf5.orig/test/tid.c
++++ hdf5/test/tid.c
+@@ -533,6 +533,103 @@ out:
+       return -1;
+ }
+ 
++/* 'Fake' free routine for ID wrapping test */
++static herr_t fake_free(void *obj)
++{
++    /* Shut compilers up */
++    obj = obj;
++
++    return(0);
++}
++
++      /* Test boundary cases with lots of IDs */
++
++/* Type IDs range from 0 to ID_MASK before wrapping around.  The code will 
assign */
++/* IDs in sequential order until ID_MASK IDs have been given out, at which */
++/* point it will search for type IDs that were allocated but have since been 
*/
++/* closed. */
++/* This test will allocate IDs up to ID_MASK, ensure that IDs wrap around */
++/* to low values successfully, ensure that an error is thrown when all 
possible */
++/* type IDs are taken, then ensure that deleting types frees up their IDs. */
++/* NOTE: this test depends on the implementation of IDs, so may break */
++/*            if the implementation changes. */
++static int test_id_wrap(void)
++{
++    H5I_type_t testType;        /* ID class for testing */
++    hid_t *id_array;    /* Array of IDs allocated */
++    hid_t test_id;      /* Test ID */
++    void *obj;          /* Object pointer returned for ID */
++    unsigned u;         /* Local index variable */
++    herr_t status;      /* Status from routine */
++
++    /* Allocate array for storing IDs */
++    id_array = (hid_t *)HDmalloc((ID_MASK + 1) * sizeof(hid_t));
++    CHECK(id_array, NULL, "HDmalloc");
++
++    /* Register type for testing */
++    testType = H5Iregister_type((size_t)8, 0, (H5I_free_t)fake_free);
++    CHECK(testType, H5I_BADID, "H5Iregister_type");
++    if(testType == H5I_BADID)
++        goto out;
++
++    /* Get IDs, up to the maximum possible */
++    for(u = 0; u <= ID_MASK; u++) {
++        id_array[u] = H5Iregister(testType, &id_array[u]);
++        CHECK(id_array[u], FAIL, "H5Iregister");
++        if(id_array[u] < 0)
++            goto out;
++    } /* end for */
++
++    /* There should be no room at the inn for a new ID */
++    H5E_BEGIN_TRY
++        test_id = H5Iregister(testType, id_array);
++    H5E_END_TRY
++    VERIFY(test_id, H5I_BADID, "H5Iregister_type");
++    if(test_id != H5I_BADID)
++        goto out;
++
++    /* Release the first ID in the array */
++    obj = H5Iremove_verify(id_array[0], testType);
++    CHECK(obj, NULL, "H5Iremove_verify");
++    if(NULL == obj)
++        goto out;
++    VERIFY(obj, &id_array[0], "H5Iremove_verify");
++    if(&id_array[0] != obj)
++        goto out;
++
++    /* Register another object, should be room now, but will wraparound */
++    test_id = H5Iregister(testType, &id_array[0]);
++    CHECK(test_id, FAIL, "H5Iregister");
++    if(test_id < 0)
++        goto out;
++    VERIFY(test_id, id_array[0], "H5Iregister");
++    if(id_array[0] != test_id)
++        goto out;
++
++    /* Release all IDs, unregister the ID class and free the array */
++    for(u = 0; u <= ID_MASK; u++) {
++        obj = H5Iremove_verify(id_array[u], testType);
++        CHECK(obj, NULL, "H5Iremove_verify");
++        if(NULL == obj)
++            goto out;
++        VERIFY(obj, &id_array[u], "H5Iremove_verify");
++        if(&id_array[u] != obj)
++            goto out;
++    } /* end for */
++
++    status = H5Idestroy_type(testType);
++    CHECK(status, FAIL, "H5Idestroy_type");
++    if(status < 0)
++        goto out;
++
++    HDfree(id_array);
++
++    return(0);
++
++out:
++    return(-1);
++}
++
+ void test_ids(void)
+ {
+       if (basic_id_test() < 0) TestErrPrintf("Basic ID test failed\n");
+@@ -540,5 +637,5 @@ void test_ids(void)
+       if (test_is_valid() < 0) TestErrPrintf("H5Iis_valid test failed\n");
+       if (test_get_type() < 0) TestErrPrintf("H5Iget_type test failed\n");
+       if (test_id_type_list() < 0) TestErrPrintf("ID type list test 
failed\n");
+-
++      if (test_id_wrap() < 0) TestErrPrintf("ID wraparound test failed\n");
+ }
diff --git a/debian/patches/series b/debian/patches/series
index aa93df5..8f6a91f 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -5,3 +5,4 @@ ullong_force.diff
 relax-version-check.patch
 #skip_cxx_inclusion.diff
 soname.diff
+HDFFV-8917.patch

-- 
Alioth's /usr/local/bin/git-commit-notice on 
/srv/git.debian.org/git/pkg-grass/hdf5.git

_______________________________________________
Pkg-grass-devel mailing list
Pkg-grass-devel@lists.alioth.debian.org
http://lists.alioth.debian.org/cgi-bin/mailman/listinfo/pkg-grass-devel

Reply via email to