Script 'mail_helper' called by obssrc
Hello community,
here is the log from the commit of package aws-c-s3 for openSUSE:Factory
checked in at 2025-07-21 20:02:10
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/aws-c-s3 (Old)
and /work/SRC/openSUSE:Factory/.aws-c-s3.new.8875 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "aws-c-s3"
Mon Jul 21 20:02:10 2025 rev:26 rq:1294811 version:0.8.4
Changes:
--------
--- /work/SRC/openSUSE:Factory/aws-c-s3/aws-c-s3.changes 2025-07-02
18:17:57.280524425 +0200
+++ /work/SRC/openSUSE:Factory/.aws-c-s3.new.8875/aws-c-s3.changes
2025-07-21 20:03:29.551056320 +0200
@@ -1,0 +2,8 @@
+Tue Jul 15 11:55:48 UTC 2025 - John Paul Adrian Glaubitz
<adrian.glaub...@suse.com>
+
+- Update to version 0.8.4
+ * More request metrics by @DmitriyMusatkin in (#530)
+ * Avoid releasing pending mem ticket future while holding
+ the lock by @DmitriyMusatkin in (#533)
+
+-------------------------------------------------------------------
Old:
----
v0.8.3.tar.gz
New:
----
v0.8.4.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ aws-c-s3.spec ++++++
--- /var/tmp/diff_new_pack.TDUat2/_old 2025-07-21 20:03:30.171082122 +0200
+++ /var/tmp/diff_new_pack.TDUat2/_new 2025-07-21 20:03:30.171082122 +0200
@@ -19,7 +19,7 @@
%define library_version 1.0.0
%define library_soversion 0unstable
Name: aws-c-s3
-Version: 0.8.3
+Version: 0.8.4
Release: 0
Summary: AWS Cross-Platform, C99 wrapper for cryptography primitives
License: Apache-2.0
++++++ v0.8.3.tar.gz -> v0.8.4.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/aws-c-s3-0.8.3/include/aws/s3/private/s3_request.h
new/aws-c-s3-0.8.4/include/aws/s3/private/s3_request.h
--- old/aws-c-s3-0.8.3/include/aws/s3/private/s3_request.h 2025-06-24
20:52:52.000000000 +0200
+++ new/aws-c-s3-0.8.4/include/aws/s3/private/s3_request.h 2025-07-14
20:40:27.000000000 +0200
@@ -70,6 +70,26 @@
/* The time duration for the request from start signing to finish
signing (sign_end_timestamp_ns -
* sign_start_timestamp_ns). When sign_end_timestamp_ns is 0, means
data not available. */
int64_t signing_duration_ns;
+
+ /* The time stamp when the request started to acquire memory. -1 means
data not
+ * available. Timestamp are from `aws_high_res_clock_get_ticks` */
+ int64_t mem_acquire_start_timestamp_ns;
+ /* The time stamp when the response to acquire memory. -1 means data
not
+ * available. Timestamp are from `aws_high_res_clock_get_ticks` */
+ int64_t mem_acquire_end_timestamp_ns;
+ /* The time duration for the request from start mem acquire to finish
mem acquire (mem_acquire_end_timestamp_ns
+ * - mem_acquire_start_timestamp_ns). When sign_end_timestamp_ns is 0,
means data not available. */
+ int64_t mem_acquire_duration_ns;
+
+ /* The time stamp when the request started to be delivered (i.e. on
body callback is invoked or write to file
+ * initiated). -1 means data not available. Timestamp are from
`aws_high_res_clock_get_ticks` */
+ int64_t deliver_start_timestamp_ns;
+ /* The time stamp when the response finished to be delivered. -1 means
data not
+ * available. Timestamp are from `aws_high_res_clock_get_ticks` */
+ int64_t deliver_end_timestamp_ns;
+ /* The time duration for the request from start of delivery to finish
of delivery (deliver_end_timestamp_ns -
+ * deliver_start_timestamp_ns). When deliver_duration_ns is 0, means
data not available. */
+ int64_t deliver_duration_ns;
} time_metrics;
struct {
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/aws-c-s3-0.8.3/source/s3_client.c
new/aws-c-s3-0.8.4/source/s3_client.c
--- old/aws-c-s3-0.8.3/source/s3_client.c 2025-06-24 20:52:52.000000000
+0200
+++ new/aws-c-s3-0.8.4/source/s3_client.c 2025-07-14 20:40:27.000000000
+0200
@@ -1850,6 +1850,14 @@
struct aws_s3_meta_request *meta_request = request->meta_request;
AWS_PRECONDITION(meta_request);
+ if (request->send_data.metrics) {
+ struct aws_s3_request_metrics *metric = request->send_data.metrics;
+ aws_high_res_clock_get_ticks((uint64_t
*)&metric->time_metrics.mem_acquire_end_timestamp_ns);
+ AWS_ASSERT(metric->time_metrics.mem_acquire_start_timestamp_ns != 0);
+ metric->time_metrics.mem_acquire_duration_ns =
+ metric->time_metrics.mem_acquire_end_timestamp_ns -
metric->time_metrics.mem_acquire_start_timestamp_ns;
+ }
+
struct aws_future_s3_buffer_ticket *future_ticket = payload->buffer_future;
int error_code = aws_future_s3_buffer_ticket_get_error(future_ticket);
@@ -1889,10 +1897,19 @@
void *user_data) {
if (request->ticket == NULL && request->should_allocate_buffer_from_pool) {
+
+ if (request->send_data.metrics) {
+ struct aws_s3_request_metrics *metric = request->send_data.metrics;
+ aws_high_res_clock_get_ticks((uint64_t
*)&metric->time_metrics.mem_acquire_start_timestamp_ns);
+ }
+
struct aws_allocator *allocator = request->allocator;
struct aws_s3_meta_request *meta_request = request->meta_request;
struct aws_s3_buffer_pool_reserve_meta meta = {
- .client = client, .meta_request = meta_request, .size =
meta_request->part_size};
+ .client = client,
+ .meta_request = meta_request,
+ .size = meta_request->part_size,
+ };
struct aws_s3_reserve_memory_payload *payload =
aws_mem_calloc(allocator, 1, sizeof(struct
aws_s3_reserve_memory_payload));
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/aws-c-s3-0.8.3/source/s3_default_buffer_pool.c
new/aws-c-s3-0.8.4/source/s3_default_buffer_pool.c
--- old/aws-c-s3-0.8.3/source/s3_default_buffer_pool.c 2025-06-24
20:52:52.000000000 +0200
+++ new/aws-c-s3-0.8.4/source/s3_default_buffer_pool.c 2025-07-14
20:40:27.000000000 +0200
@@ -389,6 +389,8 @@
aws_mem_release(buffer_pool->base_allocator, ticket);
aws_mem_release(buffer_pool->base_allocator, ticket_wrapper);
+ struct aws_future_s3_buffer_ticket *pending_ticket_future = NULL;
+
if (!aws_linked_list_empty(&buffer_pool->pending_reserves)) {
struct aws_linked_list_node *node =
aws_linked_list_front(&buffer_pool->pending_reserves);
struct s3_pending_reserve *pending_reserve = AWS_CONTAINER_OF(node,
struct s3_pending_reserve, node);
@@ -397,14 +399,15 @@
if (new_ticket != NULL) {
struct aws_s3_buffer_ticket *new_ticket_wrapper =
s_wrap_default_ticket(new_ticket);
-
aws_future_s3_buffer_ticket_set_result_by_move(pending_reserve->ticket_future,
&new_ticket_wrapper);
-
aws_future_s3_buffer_ticket_release(pending_reserve->ticket_future);
+ pending_ticket_future = pending_reserve->ticket_future;
+
aws_future_s3_buffer_ticket_set_result_by_move(pending_ticket_future,
&new_ticket_wrapper);
aws_linked_list_pop_front(&buffer_pool->pending_reserves);
aws_mem_release(buffer_pool->base_allocator, pending_reserve);
}
}
aws_mutex_unlock(&buffer_pool->mutex);
+ aws_future_s3_buffer_ticket_release(pending_ticket_future);
}
struct aws_s3_default_buffer_ticket *s_try_reserve(
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/aws-c-s3-0.8.3/source/s3_meta_request.c
new/aws-c-s3-0.8.4/source/s3_meta_request.c
--- old/aws-c-s3-0.8.3/source/s3_meta_request.c 2025-06-24 20:52:52.000000000
+0200
+++ new/aws-c-s3-0.8.4/source/s3_meta_request.c 2025-07-14 20:40:27.000000000
+0200
@@ -1933,6 +1933,11 @@
}
}
if (error_code == AWS_ERROR_SUCCESS) {
+ if (request->send_data.metrics) {
+ struct aws_s3_request_metrics *metric =
request->send_data.metrics;
+ aws_high_res_clock_get_ticks((uint64_t
*)&metric->time_metrics.deliver_start_timestamp_ns);
+ }
+
if (meta_request->recv_file) {
/* Write the data directly to the file. No need to
seek, since the event will always be
* delivered with the right order. */
@@ -1978,6 +1983,14 @@
error_code,
aws_error_str(error_code));
}
+
+ if (request->send_data.metrics) {
+ struct aws_s3_request_metrics *metric =
request->send_data.metrics;
+ aws_high_res_clock_get_ticks((uint64_t
*)&metric->time_metrics.deliver_end_timestamp_ns);
+
AWS_ASSERT(metric->time_metrics.deliver_start_timestamp_ns != 0);
+ metric->time_metrics.deliver_duration_ns =
metric->time_metrics.deliver_end_timestamp_ns -
+
metric->time_metrics.deliver_start_timestamp_ns;
+ }
}
}
aws_atomic_fetch_sub(&client->stats.num_requests_streaming_response, 1);
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/aws-c-s3-0.8.3/source/s3_request.c
new/aws-c-s3-0.8.4/source/s3_request.c
--- old/aws-c-s3-0.8.3/source/s3_request.c 2025-06-24 20:52:52.000000000
+0200
+++ new/aws-c-s3-0.8.4/source/s3_request.c 2025-07-14 20:40:27.000000000
+0200
@@ -192,6 +192,12 @@
metrics->time_metrics.sign_start_timestamp_ns = -1;
metrics->time_metrics.sign_end_timestamp_ns = -1;
metrics->time_metrics.signing_duration_ns = -1;
+ metrics->time_metrics.mem_acquire_start_timestamp_ns = -1;
+ metrics->time_metrics.mem_acquire_end_timestamp_ns = -1;
+ metrics->time_metrics.mem_acquire_duration_ns = -1;
+ metrics->time_metrics.deliver_start_timestamp_ns = -1;
+ metrics->time_metrics.deliver_end_timestamp_ns = -1;
+ metrics->time_metrics.deliver_duration_ns = -1;
metrics->req_resp_info_metrics.response_status = -1;
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/aws-c-s3-0.8.3/tests/CMakeLists.txt
new/aws-c-s3-0.8.4/tests/CMakeLists.txt
--- old/aws-c-s3-0.8.3/tests/CMakeLists.txt 2025-06-24 20:52:52.000000000
+0200
+++ new/aws-c-s3-0.8.4/tests/CMakeLists.txt 2025-07-14 20:40:27.000000000
+0200
@@ -398,6 +398,7 @@
add_test_case(test_s3_buffer_pool_forced_buffer)
add_test_case(test_s3_buffer_pool_forced_buffer_after_limit_hit)
add_test_case(test_s3_buffer_pool_forced_buffer_wont_stop_reservations)
+add_test_case(test_s3_buffer_pool_reserve_over_limit_instant_release)
add_net_test_case(client_update_upload_part_timeout)
add_net_test_case(client_meta_request_override_part_size)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/aws-c-s3-0.8.3/tests/s3_default_buffer_pool_tests.c
new/aws-c-s3-0.8.4/tests/s3_default_buffer_pool_tests.c
--- old/aws-c-s3-0.8.3/tests/s3_default_buffer_pool_tests.c 2025-06-24
20:52:52.000000000 +0200
+++ new/aws-c-s3-0.8.4/tests/s3_default_buffer_pool_tests.c 2025-07-14
20:40:27.000000000 +0200
@@ -268,6 +268,62 @@
};
AWS_TEST_CASE(test_s3_buffer_pool_reserve_over_limit,
s_test_s3_buffer_pool_reserve_over_limit)
+static void s_on_pool_buffer_reserved_instant_release(void *user_data) {
+ struct s_reserve_state *state = user_data;
+
+ if (aws_future_s3_buffer_ticket_get_error(state->future) ==
AWS_OP_SUCCESS) {
+ state->ticket =
aws_future_s3_buffer_ticket_get_result_by_move(state->future);
+ }
+
+ state->future = aws_future_s3_buffer_ticket_release(state->future);
+}
+
+/* release future in the callback right away to check for potential race
conditions */
+static int s_test_s3_buffer_pool_reserve_over_limit_instant_release(struct
aws_allocator *allocator, void *ctx) {
+ (void)allocator;
+ (void)ctx;
+
+ struct aws_s3_buffer_pool *buffer_pool = aws_s3_default_buffer_pool_new(
+ allocator, (struct aws_s3_buffer_pool_config){.part_size =
MB_TO_BYTES(8), .memory_limit = GB_TO_BYTES(1)});
+
+ struct aws_s3_buffer_ticket *tickets[112];
+ struct aws_future_s3_buffer_ticket *ticket_futures[112];
+ for (size_t i = 0; i < 112; ++i) {
+ ticket_futures[i] = aws_s3_default_buffer_pool_reserve(
+ buffer_pool, (struct aws_s3_buffer_pool_reserve_meta){.size =
MB_TO_BYTES(8)});
+ ASSERT_TRUE(aws_future_s3_buffer_ticket_is_done(ticket_futures[i]));
+
ASSERT_INT_EQUALS(aws_future_s3_buffer_ticket_get_error(ticket_futures[i]),
AWS_OP_SUCCESS);
+ tickets[i] =
aws_future_s3_buffer_ticket_get_result_by_move(ticket_futures[i]);
+ struct aws_byte_buf buf = aws_s3_buffer_ticket_claim(tickets[i]);
+ ASSERT_NOT_NULL(buf.buffer);
+ }
+
+ struct aws_future_s3_buffer_ticket *over_future =
aws_s3_default_buffer_pool_reserve(
+ buffer_pool, (struct aws_s3_buffer_pool_reserve_meta){.size =
MB_TO_BYTES(8)});
+
+ ASSERT_FALSE(aws_future_s3_buffer_ticket_is_done(over_future));
+
+ struct s_reserve_state state = {.future = over_future};
+
+ aws_future_s3_buffer_ticket_register_callback(over_future,
s_on_pool_buffer_reserved_instant_release, &state);
+
+ for (size_t i = 0; i < 112; ++i) {
+ aws_s3_buffer_ticket_release(tickets[i]);
+ aws_future_s3_buffer_ticket_release(ticket_futures[i]);
+ }
+
+ ASSERT_NOT_NULL(state.ticket);
+
+ aws_s3_buffer_ticket_release(state.ticket);
+
+ aws_s3_default_buffer_pool_destroy(buffer_pool);
+
+ return 0;
+};
+AWS_TEST_CASE(
+ test_s3_buffer_pool_reserve_over_limit_instant_release,
+ s_test_s3_buffer_pool_reserve_over_limit_instant_release)
+
static int s_test_s3_buffer_pool_too_small(struct aws_allocator *allocator,
void *ctx) {
(void)allocator;
(void)ctx;
