From 300bb8d62d412eccb1537cbdaf27b8264fa6fc19 Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Sun, 21 Apr 2019 11:37:56 +0200 Subject: fix quota out calculation, even if it may go away --- src/include/gnunet_bandwidth_lib.h | 70 +++++++++------- src/transport/gnunet-service-tng.c | 52 ++++++++---- src/util/bandwidth.c | 161 +++++++++++++++++++++---------------- 3 files changed, 167 insertions(+), 116 deletions(-) (limited to 'src') diff --git a/src/include/gnunet_bandwidth_lib.h b/src/include/gnunet_bandwidth_lib.h index e52ab54be..f941624af 100644 --- a/src/include/gnunet_bandwidth_lib.h +++ b/src/include/gnunet_bandwidth_lib.h @@ -33,9 +33,8 @@ #define GNUNET_BANDWIDTH_LIB_H #ifdef __cplusplus -extern "C" -{ -#if 0 /* keep Emacsens' auto-indent happy */ +extern "C" { +#if 0 /* keep Emacsens' auto-indent happy */ } #endif #endif @@ -55,6 +54,7 @@ struct GNUNET_BANDWIDTH_Value32NBO */ uint32_t value__ GNUNET_PACKED; }; + GNUNET_NETWORK_STRUCT_END @@ -64,8 +64,7 @@ GNUNET_NETWORK_STRUCT_END * * @param cls a closure to pass */ -typedef void -(*GNUNET_BANDWIDTH_TrackerUpdateCallback) (void *cls); +typedef void (*GNUNET_BANDWIDTH_TrackerUpdateCallback) (void *cls); /** @@ -74,8 +73,7 @@ typedef void * * @param cls a closure to pass */ -typedef void -(*GNUNET_BANDWIDTH_ExcessNotificationCallback) (void *cls); +typedef void (*GNUNET_BANDWIDTH_ExcessNotificationCallback) (void *cls); /** @@ -158,7 +156,7 @@ GNUNET_BANDWIDTH_value_init (uint32_t bytes_per_second); /** * Maximum possible bandwidth value. */ -#define GNUNET_BANDWIDTH_VALUE_MAX GNUNET_BANDWIDTH_value_init(UINT32_MAX) +#define GNUNET_BANDWIDTH_VALUE_MAX GNUNET_BANDWIDTH_value_init (UINT32_MAX) /** @@ -170,8 +168,9 @@ GNUNET_BANDWIDTH_value_init (uint32_t bytes_per_second); * @return number of bytes available at bps until deadline */ uint64_t -GNUNET_BANDWIDTH_value_get_available_until (struct GNUNET_BANDWIDTH_Value32NBO bps, - struct GNUNET_TIME_Relative deadline); +GNUNET_BANDWIDTH_value_get_available_until ( + struct GNUNET_BANDWIDTH_Value32NBO bps, + struct GNUNET_TIME_Relative deadline); /** @@ -211,6 +210,18 @@ GNUNET_BANDWIDTH_value_max (struct GNUNET_BANDWIDTH_Value32NBO b1, struct GNUNET_BANDWIDTH_Value32NBO b2); +/** + * Compute the SUM of two bandwidth values. + * + * @param b1 first value + * @param b2 second value + * @return the sum of b1 and b2 + */ +struct GNUNET_BANDWIDTH_Value32NBO +GNUNET_BANDWIDTH_value_sum (struct GNUNET_BANDWIDTH_Value32NBO b1, + struct GNUNET_BANDWIDTH_Value32NBO b2); + + /** * Initialize bandwidth tracker. Note that in addition to the * 'max_carry_s' limit, we also always allow at least @@ -228,11 +239,12 @@ GNUNET_BANDWIDTH_value_max (struct GNUNET_BANDWIDTH_Value32NBO b1, * may accumulate before it expires */ void -GNUNET_BANDWIDTH_tracker_init (struct GNUNET_BANDWIDTH_Tracker *av, - GNUNET_BANDWIDTH_TrackerUpdateCallback update_cb, - void *update_cb_cls, - struct GNUNET_BANDWIDTH_Value32NBO bytes_per_second_limit, - uint32_t max_carry_s); +GNUNET_BANDWIDTH_tracker_init ( + struct GNUNET_BANDWIDTH_Tracker *av, + GNUNET_BANDWIDTH_TrackerUpdateCallback update_cb, + void *update_cb_cls, + struct GNUNET_BANDWIDTH_Value32NBO bytes_per_second_limit, + uint32_t max_carry_s); /** @@ -254,13 +266,14 @@ GNUNET_BANDWIDTH_tracker_init (struct GNUNET_BANDWIDTH_Tracker *av, * @param excess_cb_cls closure for @a excess_cb */ void -GNUNET_BANDWIDTH_tracker_init2 (struct GNUNET_BANDWIDTH_Tracker *av, - GNUNET_BANDWIDTH_TrackerUpdateCallback update_cb, - void *update_cb_cls, - struct GNUNET_BANDWIDTH_Value32NBO bytes_per_second_limit, - uint32_t max_carry_s, - GNUNET_BANDWIDTH_ExcessNotificationCallback excess_cb, - void *excess_cb_cls); +GNUNET_BANDWIDTH_tracker_init2 ( + struct GNUNET_BANDWIDTH_Tracker *av, + GNUNET_BANDWIDTH_TrackerUpdateCallback update_cb, + void *update_cb_cls, + struct GNUNET_BANDWIDTH_Value32NBO bytes_per_second_limit, + uint32_t max_carry_s, + GNUNET_BANDWIDTH_ExcessNotificationCallback excess_cb, + void *excess_cb_cls); /** @@ -269,7 +282,8 @@ GNUNET_BANDWIDTH_tracker_init2 (struct GNUNET_BANDWIDTH_Tracker *av, * @param av the respective trackers */ void -GNUNET_BANDWIDTH_tracker_notification_stop (struct GNUNET_BANDWIDTH_Tracker *av); +GNUNET_BANDWIDTH_tracker_notification_stop ( + struct GNUNET_BANDWIDTH_Tracker *av); /** @@ -320,12 +334,12 @@ GNUNET_BANDWIDTH_tracker_get_available (struct GNUNET_BANDWIDTH_Tracker *av); * @param bytes_per_second_limit new limit to assume */ void -GNUNET_BANDWIDTH_tracker_update_quota (struct GNUNET_BANDWIDTH_Tracker *av, - struct GNUNET_BANDWIDTH_Value32NBO - bytes_per_second_limit); +GNUNET_BANDWIDTH_tracker_update_quota ( + struct GNUNET_BANDWIDTH_Tracker *av, + struct GNUNET_BANDWIDTH_Value32NBO bytes_per_second_limit); -#if 0 /* keep Emacsens' auto-indent happy */ +#if 0 /* keep Emacsens' auto-indent happy */ { #endif #ifdef __cplusplus @@ -335,6 +349,6 @@ GNUNET_BANDWIDTH_tracker_update_quota (struct GNUNET_BANDWIDTH_Tracker *av, /* ifndef GNUNET_BANDWIDTH_LIB_H */ #endif -/** @} */ /* end of group */ +/** @} */ /* end of group */ /* end of gnunet_bandwidth_lib.h */ diff --git a/src/transport/gnunet-service-tng.c b/src/transport/gnunet-service-tng.c index 3bef2b4e7..b2f0838bf 100644 --- a/src/transport/gnunet-service-tng.c +++ b/src/transport/gnunet-service-tng.c @@ -23,15 +23,6 @@ * @author Christian Grothoff * * TODO: - * - figure out how to transmit (selective) ACKs in case of uni-directional - * communicators (with/without core? DV-only?) When do we use ACKs? - * => communicators use selective ACKs for flow control - * => transport uses message-level ACKs for RTT, fragment confirmation - * => integrate DV into transport, use neither core nor communicators - * but rather give communicators transport-encapsulated messages - * (which could be core-data, background-channel traffic, or - * transport-to-transport traffic) - * * Implement next: * - retransmission logic * - track RTT, distance, loss, etc. => requires extra data structures! @@ -1077,6 +1068,20 @@ struct DistanceVector */ struct GNUNET_SCHEDULER_Task *visibility_task; + /** + * Quota at which CORE is allowed to transmit to this peer + * (note that the value CORE should actually be told is this + * value plus the respective value in `struct Neighbour`). + * Should match the sum of the quotas of all of the paths. + * + * FIXME: not yet set, tricky to get right given multiple paths, + * many of which may be inactive! (=> Idea: measure???) + * FIXME: how do we set this value initially when we tell CORE? + * Options: start at a minimum value or at literally zero? + * (=> Current thought: clean would be zero!) + */ + struct GNUNET_BANDWIDTH_Value32NBO quota_out; + /** * Is one of the DV paths in this struct 'confirmed' and thus * the cause for CORE to see this peer as connected? (Note that @@ -1421,9 +1426,12 @@ struct Neighbour struct GNUNET_SCHEDULER_Task *timeout_task; /** - * Quota at which CORE is allowed to transmit to this peer. + * Quota at which CORE is allowed to transmit to this peer + * (note that the value CORE should actually be told is this + * value plus the respective value in `struct DistanceVector`). + * Should match the sum of the quotas of all of the queues. * - * FIXME: not yet used, tricky to get right given multiple queues! + * FIXME: not yet set, tricky to get right given multiple queues! * (=> Idea: measure???) * FIXME: how do we set this value initially when we tell CORE? * Options: start at a minimum value or at literally zero? @@ -4685,7 +4693,11 @@ activate_core_visible_dv_path (struct DistanceVectorHop *hop) n = GNUNET_CONTAINER_multipeermap_get (neighbours, &dv->target); if ((NULL != n) && (GNUNET_YES == n->core_visible)) return; /* no need to tell core, connection already up! */ - cores_send_connect_info (&dv->target, GNUNET_BANDWIDTH_ZERO); + cores_send_connect_info (&dv->target, + (NULL != n) + ? GNUNET_BANDWDITH_value_sum (n->quota_out, + dv->quota_out) + : dv->quota_out); } @@ -5626,6 +5638,7 @@ handle_validation_response (void *cls, struct GNUNET_TIME_Absolute origin_time; struct Queue *q; struct DistanceVector *dv; + struct Neighbour *n; /* check this is one of our challenges */ (void) GNUNET_CONTAINER_multipeermap_get_multiple (validation_map, @@ -5722,20 +5735,25 @@ handle_validation_response (void *cls, } q->validated_until = vs->validated_until; q->rtt = vs->validation_rtt; - if (GNUNET_NO != q->neighbour->core_visible) + n = q->neighbour; + if (GNUNET_NO != n->core_visible) return; /* nothing changed, we are done here */ - q->neighbour->core_visible = GNUNET_YES; + n->core_visible = GNUNET_YES; q->visibility_task = GNUNET_SCHEDULER_add_at (q->validated_until, &core_queue_visibility_check, q); /* Check if _any_ DV route to this neighbour is currently valid, if so, do NOT tell core anything! */ - dv = GNUNET_CONTAINER_multipeermap_get (dv_routes, &q->neighbour->pid); - if (GNUNET_YES == dv->core_visible) + dv = GNUNET_CONTAINER_multipeermap_get (dv_routes, &n->pid); + if ((NULL != dv) && (GNUNET_YES == dv->core_visible)) return; /* nothing changed, done */ /* We lacked a confirmed connection to the neighbour before, so tell CORE about it (finally!) */ - cores_send_connect_info (&q->neighbour->pid, GNUNET_BANDWIDTH_ZERO); + cores_send_connect_info (&n->pid, + (NULL != dv) + ? GNUNET_BANDWIDTH_value_sum (dv->quota_out, + n->quota_out) + : n->quota_out); } diff --git a/src/util/bandwidth.c b/src/util/bandwidth.c index 5cf1297c7..bdac43b77 100644 --- a/src/util/bandwidth.c +++ b/src/util/bandwidth.c @@ -11,7 +11,7 @@ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. - + You should have received a copy of the GNU Affero General Public License along with this program. If not, see . @@ -27,7 +27,7 @@ #include "gnunet_util_lib.h" -#define LOG(kind,...) GNUNET_log_from (kind, "util-bandwidth", __VA_ARGS__) +#define LOG(kind, ...) GNUNET_log_from (kind, "util-bandwidth", __VA_ARGS__) /** * Create a new bandwidth value. @@ -56,10 +56,8 @@ struct GNUNET_BANDWIDTH_Value32NBO GNUNET_BANDWIDTH_value_min (struct GNUNET_BANDWIDTH_Value32NBO b1, struct GNUNET_BANDWIDTH_Value32NBO b2) { - return - GNUNET_BANDWIDTH_value_init (GNUNET_MIN - (ntohl (b1.value__), - ntohl (b2.value__))); + return GNUNET_BANDWIDTH_value_init ( + GNUNET_MIN (ntohl (b1.value__), ntohl (b2.value__))); } @@ -74,10 +72,23 @@ struct GNUNET_BANDWIDTH_Value32NBO GNUNET_BANDWIDTH_value_max (struct GNUNET_BANDWIDTH_Value32NBO b1, struct GNUNET_BANDWIDTH_Value32NBO b2) { - return - GNUNET_BANDWIDTH_value_init (GNUNET_MAX - (ntohl (b1.value__), - ntohl (b2.value__))); + return GNUNET_BANDWIDTH_value_init ( + GNUNET_MAX (ntohl (b1.value__), ntohl (b2.value__))); +} + + +/** + * Compute the SUM of two bandwidth values. + * + * @param b1 first value + * @param b2 second value + * @return the sum of b1 and b2 + */ +struct GNUNET_BANDWIDTH_Value32NBO +GNUNET_BANDWIDTH_value_sum (struct GNUNET_BANDWIDTH_Value32NBO b1, + struct GNUNET_BANDWIDTH_Value32NBO b2) +{ + return GNUNET_BANDWIDTH_value_init (ntohl (b1.value__) + ntohl (b2.value__)); } @@ -90,15 +101,17 @@ GNUNET_BANDWIDTH_value_max (struct GNUNET_BANDWIDTH_Value32NBO b1, * @return number of bytes available at bps until deadline */ uint64_t -GNUNET_BANDWIDTH_value_get_available_until (struct GNUNET_BANDWIDTH_Value32NBO bps, - struct GNUNET_TIME_Relative deadline) +GNUNET_BANDWIDTH_value_get_available_until ( + struct GNUNET_BANDWIDTH_Value32NBO bps, + struct GNUNET_TIME_Relative deadline) { uint64_t b; b = ntohl (bps.value__); LOG (GNUNET_ERROR_TYPE_DEBUG, "Bandwidth has %llu bytes available until deadline in %s\n", - (unsigned long long) ((b * deadline.rel_value_us + 500000LL) / 1000000LL), + (unsigned long long) ((b * deadline.rel_value_us + 500000LL) / + 1000000LL), GNUNET_STRINGS_relative_time_to_string (deadline, GNUNET_YES)); return (b * deadline.rel_value_us + 500000LL) / 1000000LL; } @@ -149,7 +162,7 @@ excess_trigger (void *cls) if (NULL != av->excess_cb) { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Notifying application about excess bandwidth\n"); + "Notifying application about excess bandwidth\n"); av->excess_cb (av->excess_cb_cls); } } @@ -174,8 +187,9 @@ update_excess (struct GNUNET_BANDWIDTH_Tracker *av) now = GNUNET_TIME_absolute_get (); delta_time = now.abs_value_us - av->last_update__.abs_value_us; delta_avail = - (delta_time * ((unsigned long long) av->available_bytes_per_s__) + - 500000LL) / 1000000LL; + (delta_time * ((unsigned long long) av->available_bytes_per_s__) + + 500000LL) / + 1000000LL; current_consumption = av->consumption_since_last_update__ - delta_avail; if (current_consumption > av->consumption_since_last_update__) { @@ -203,21 +217,20 @@ update_excess (struct GNUNET_BANDWIDTH_Tracker *av) } else { - double factor = 1.0 * left_bytes / (double) av->available_bytes_per_s__; - delay = GNUNET_TIME_relative_saturating_multiply (GNUNET_TIME_UNIT_SECONDS, - (unsigned long long) factor); + double factor = 1.0 * left_bytes / (double) av->available_bytes_per_s__; + delay = + GNUNET_TIME_relative_saturating_multiply (GNUNET_TIME_UNIT_SECONDS, + (unsigned long long) factor); } - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "At %llu bps it will take us %s for %lld bytes to reach excess threshold\n", - (unsigned long long) av->available_bytes_per_s__, - GNUNET_STRINGS_relative_time_to_string (delay, - GNUNET_NO), - (long long) left_bytes); + GNUNET_log ( + GNUNET_ERROR_TYPE_DEBUG, + "At %llu bps it will take us %s for %lld bytes to reach excess threshold\n", + (unsigned long long) av->available_bytes_per_s__, + GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_NO), + (long long) left_bytes); if (NULL != av->excess_task) GNUNET_SCHEDULER_cancel (av->excess_task); - av->excess_task = GNUNET_SCHEDULER_add_delayed (delay, - &excess_trigger, - av); + av->excess_task = GNUNET_SCHEDULER_add_delayed (delay, &excess_trigger, av); } @@ -243,13 +256,14 @@ update_excess (struct GNUNET_BANDWIDTH_Tracker *av) * @param excess_cb_cls closure for @a excess_cb */ void -GNUNET_BANDWIDTH_tracker_init2 (struct GNUNET_BANDWIDTH_Tracker *av, - GNUNET_BANDWIDTH_TrackerUpdateCallback update_cb, - void *update_cb_cls, - struct GNUNET_BANDWIDTH_Value32NBO bytes_per_second_limit, - uint32_t max_carry_s, - GNUNET_BANDWIDTH_ExcessNotificationCallback excess_cb, - void *excess_cb_cls) +GNUNET_BANDWIDTH_tracker_init2 ( + struct GNUNET_BANDWIDTH_Tracker *av, + GNUNET_BANDWIDTH_TrackerUpdateCallback update_cb, + void *update_cb_cls, + struct GNUNET_BANDWIDTH_Value32NBO bytes_per_second_limit, + uint32_t max_carry_s, + GNUNET_BANDWIDTH_ExcessNotificationCallback excess_cb, + void *excess_cb_cls) { av->update_cb = update_cb; av->update_cb_cls = update_cb_cls; @@ -285,17 +299,20 @@ GNUNET_BANDWIDTH_tracker_init2 (struct GNUNET_BANDWIDTH_Tracker *av, * may accumulate before it expires */ void -GNUNET_BANDWIDTH_tracker_init (struct GNUNET_BANDWIDTH_Tracker *av, - GNUNET_BANDWIDTH_TrackerUpdateCallback update_cb, - void *update_cb_cls, - struct GNUNET_BANDWIDTH_Value32NBO bytes_per_second_limit, - uint32_t max_carry_s) +GNUNET_BANDWIDTH_tracker_init ( + struct GNUNET_BANDWIDTH_Tracker *av, + GNUNET_BANDWIDTH_TrackerUpdateCallback update_cb, + void *update_cb_cls, + struct GNUNET_BANDWIDTH_Value32NBO bytes_per_second_limit, + uint32_t max_carry_s) { - GNUNET_BANDWIDTH_tracker_init2 (av, update_cb, + GNUNET_BANDWIDTH_tracker_init2 (av, + update_cb, update_cb_cls, bytes_per_second_limit, max_carry_s, - NULL, NULL); + NULL, + NULL); } @@ -335,36 +352,36 @@ update_tracker (struct GNUNET_BANDWIDTH_Tracker *av) now = GNUNET_TIME_absolute_get (); delta_time = now.abs_value_us - av->last_update__.abs_value_us; delta_avail = - (delta_time * ((unsigned long long) av->available_bytes_per_s__) + - 500000LL) / 1000000LL; + (delta_time * ((unsigned long long) av->available_bytes_per_s__) + + 500000LL) / + 1000000LL; av->consumption_since_last_update__ -= delta_avail; av->last_update__ = now; if (av->consumption_since_last_update__ < 0) { - left_bytes = - av->consumption_since_last_update__; - max_carry = ((unsigned long long) av->available_bytes_per_s__) * - av->max_carry_s__; + left_bytes = -av->consumption_since_last_update__; + max_carry = + ((unsigned long long) av->available_bytes_per_s__) * av->max_carry_s__; if (max_carry < GNUNET_MAX_MESSAGE_SIZE) max_carry = GNUNET_MAX_MESSAGE_SIZE; if (max_carry > INT64_MAX) max_carry = INT64_MAX; if (max_carry > left_bytes) - av->consumption_since_last_update__ = - left_bytes; + av->consumption_since_last_update__ = -left_bytes; else - av->consumption_since_last_update__ = - max_carry; + av->consumption_since_last_update__ = -max_carry; } -#if !defined(GNUNET_CULL_LOGGING) +#if ! defined(GNUNET_CULL_LOGGING) { struct GNUNET_TIME_Relative delta; delta.rel_value_us = delta_time; LOG (GNUNET_ERROR_TYPE_DEBUG, - "Tracker %p updated, consumption at %lld at %u Bps, last update was %s ago\n", - av, - (long long) av->consumption_since_last_update__, - (unsigned int) av->available_bytes_per_s__, - GNUNET_STRINGS_relative_time_to_string (delta, - GNUNET_YES)); + "Tracker %p updated, consumption at %lld at %u Bps, last update was %s ago\n", + av, + (long long) av->consumption_since_last_update__, + (unsigned int) av->available_bytes_per_s__, + GNUNET_STRINGS_relative_time_to_string (delta, GNUNET_YES)); } #endif } @@ -407,7 +424,7 @@ GNUNET_BANDWIDTH_tracker_consume (struct GNUNET_BANDWIDTH_Tracker *av, { LOG (GNUNET_ERROR_TYPE_DEBUG, "Tracker %p consumption %llu bytes above limit\n", - av, + av, (unsigned long long) av->consumption_since_last_update__); return GNUNET_YES; } @@ -446,8 +463,7 @@ GNUNET_BANDWIDTH_tracker_get_delay (struct GNUNET_BANDWIDTH_Tracker *av, if (0 == av->available_bytes_per_s__) { - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Tracker %p delay is infinity\n", av); + LOG (GNUNET_ERROR_TYPE_DEBUG, "Tracker %p delay is infinity\n", av); return GNUNET_TIME_UNIT_FOREVER_REL; } update_tracker (av); @@ -455,13 +471,13 @@ GNUNET_BANDWIDTH_tracker_get_delay (struct GNUNET_BANDWIDTH_Tracker *av, if (bytes_needed <= 0) { LOG (GNUNET_ERROR_TYPE_DEBUG, - "Tracker %p delay for %u bytes is zero\n", av, + "Tracker %p delay for %u bytes is zero\n", + av, (unsigned int) size); return GNUNET_TIME_UNIT_ZERO; } - ret.rel_value_us = - (1000LL * 1000LL * bytes_needed) / - (unsigned long long) av->available_bytes_per_s__; + ret.rel_value_us = (1000LL * 1000LL * bytes_needed) / + (unsigned long long) av->available_bytes_per_s__; LOG (GNUNET_ERROR_TYPE_DEBUG, "Tracker %p delay for %u bytes is %s\n", av, @@ -488,12 +504,13 @@ GNUNET_BANDWIDTH_tracker_get_available (struct GNUNET_BANDWIDTH_Tracker *av) update_tracker (av); bps = GNUNET_BANDWIDTH_value_init (av->available_bytes_per_s__); avail = - GNUNET_BANDWIDTH_value_get_available_until (bps, - GNUNET_TIME_absolute_get_duration - (av->last_update__)); + GNUNET_BANDWIDTH_value_get_available_until (bps, + GNUNET_TIME_absolute_get_duration ( + av->last_update__)); used = av->consumption_since_last_update__; LOG (GNUNET_ERROR_TYPE_DEBUG, - "Tracker %p available bandwidth is %lld bytes\n", av, + "Tracker %p available bandwidth is %lld bytes\n", + av, (long long) (int64_t) (avail - used)); return (int64_t) (avail - used); } @@ -506,15 +523,17 @@ GNUNET_BANDWIDTH_tracker_get_available (struct GNUNET_BANDWIDTH_Tracker *av) * @param bytes_per_second_limit new limit to assume */ void -GNUNET_BANDWIDTH_tracker_update_quota (struct GNUNET_BANDWIDTH_Tracker *av, - struct GNUNET_BANDWIDTH_Value32NBO bytes_per_second_limit) +GNUNET_BANDWIDTH_tracker_update_quota ( + struct GNUNET_BANDWIDTH_Tracker *av, + struct GNUNET_BANDWIDTH_Value32NBO bytes_per_second_limit) { uint32_t old_limit; uint32_t new_limit; new_limit = ntohl (bytes_per_second_limit.value__); LOG (GNUNET_ERROR_TYPE_DEBUG, - "Tracker %p bandwidth changed to %u Bps\n", av, + "Tracker %p bandwidth changed to %u Bps\n", + av, (unsigned int) new_limit); update_tracker (av); old_limit = av->available_bytes_per_s__; @@ -522,7 +541,7 @@ GNUNET_BANDWIDTH_tracker_update_quota (struct GNUNET_BANDWIDTH_Tracker *av, if (NULL != av->update_cb) av->update_cb (av->update_cb_cls); if (old_limit > new_limit) - update_tracker (av); /* maximum excess might be less now */ + update_tracker (av); /* maximum excess might be less now */ update_excess (av); } -- cgit v1.2.3