159 lines
5.3 KiB
C
159 lines
5.3 KiB
C
/* (C) 2018 by sysmocom - s.f.m.c. GmbH <info@sysmocom.de>
|
|
*
|
|
* All Rights Reserved
|
|
*
|
|
* Author: Neels Hofmeyr <nhofmeyr@sysmocom.de>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as published by
|
|
* the Free Software Foundation; either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but 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 <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
#include <talloc.h>
|
|
#include <time.h>
|
|
#include <stdint.h>
|
|
|
|
#include <osmocom/core/linuxlist.h>
|
|
|
|
#include <osmocom/bsc/penalty_timers.h>
|
|
#include <osmocom/bsc/gsm_data.h>
|
|
|
|
static unsigned int time_now(void)
|
|
{
|
|
struct timespec tp;
|
|
if (osmo_clock_gettime(CLOCK_MONOTONIC, &tp))
|
|
return 0;
|
|
return (unsigned int)tp.tv_sec;
|
|
}
|
|
|
|
/* Add a penalty timer for a target cell ID.
|
|
* \param ctx talloc context to allocate new struct penalty_timer from.
|
|
* \param penalty_timers llist head to add penalty timer to.
|
|
* \param for_target_cell Which handover target to penalize.
|
|
* \param timeout Penalty time in seconds.
|
|
*/
|
|
void penalty_timers_add(void *ctx, struct llist_head *penalty_timers,
|
|
const struct gsm0808_cell_id *for_target_cell, int timeout)
|
|
{
|
|
struct penalty_timer *timer;
|
|
unsigned int now;
|
|
unsigned int then;
|
|
now = time_now();
|
|
|
|
if (timeout <= 0)
|
|
return;
|
|
|
|
then = now + timeout;
|
|
|
|
/* timer already running for that target cell? */
|
|
llist_for_each_entry(timer, penalty_timers, entry) {
|
|
if (!gsm0808_cell_ids_match(&timer->for_target_cell, for_target_cell, true))
|
|
continue;
|
|
/* raise, if running timer will timeout earlier or has timed
|
|
* out already, otherwise keep later timeout */
|
|
if (timer->timeout < then)
|
|
timer->timeout = then;
|
|
return;
|
|
}
|
|
|
|
/* add new timer */
|
|
timer = talloc_zero(ctx, struct penalty_timer);
|
|
if (!timer)
|
|
return;
|
|
|
|
timer->for_target_cell = *for_target_cell;
|
|
timer->timeout = then;
|
|
|
|
llist_add_tail(&timer->entry, penalty_timers);
|
|
}
|
|
|
|
/* Add a penalty timer for each target cell ID in the given list.
|
|
* \param ctx talloc context to allocate new struct penalty_timer from.
|
|
* \param penalty_timers llist head to add penalty timer to.
|
|
* \param for_target_cells Which handover targets to penalize.
|
|
* \param timeout Penalty time in seconds.
|
|
*/
|
|
void penalty_timers_add_list(void *ctx, struct llist_head *penalty_timers,
|
|
const struct gsm0808_cell_id_list2 *for_target_cells, int timeout)
|
|
{
|
|
int i;
|
|
for (i = 0; i < for_target_cells->id_list_len; i++) {
|
|
struct gsm0808_cell_id add = {
|
|
.id_discr = for_target_cells->id_discr,
|
|
.id = for_target_cells->id_list[i],
|
|
};
|
|
penalty_timers_add(ctx, penalty_timers, &add, timeout);
|
|
}
|
|
}
|
|
|
|
/* Return the amount of penalty time in seconds remaining for a target cell.
|
|
* \param penalty_timers llist head to look up penalty time in.
|
|
* \param for_target_cell Which handover target to query.
|
|
* \returns seconds remaining until all penalty time has expired.
|
|
*/
|
|
unsigned int penalty_timers_remaining(struct llist_head *penalty_timers,
|
|
const struct gsm0808_cell_id *for_target_cell)
|
|
{
|
|
struct penalty_timer *timer;
|
|
unsigned int now = time_now();
|
|
unsigned int max_remaining = 0;
|
|
llist_for_each_entry(timer, penalty_timers, entry) {
|
|
unsigned int remaining;
|
|
if (!gsm0808_cell_ids_match(&timer->for_target_cell, for_target_cell, true))
|
|
continue;
|
|
if (now >= timer->timeout)
|
|
continue;
|
|
remaining = timer->timeout - now;
|
|
if (remaining > max_remaining)
|
|
max_remaining = remaining;
|
|
}
|
|
return max_remaining;
|
|
}
|
|
|
|
/* Return the largest amount of penalty time in seconds remaining for any one of the given target cells.
|
|
* Call penalty_timers_remaining() for each entry of for_target_cells and return the largest value encountered.
|
|
* \param penalty_timers llist head to look up penalty time in.
|
|
* \param for_target_cells Which handover targets to query.
|
|
* \returns seconds remaining until all penalty time has expired.
|
|
*/
|
|
unsigned int penalty_timers_remaining_list(struct llist_head *penalty_timers,
|
|
const struct gsm0808_cell_id_list2 *for_target_cells)
|
|
{
|
|
int i;
|
|
unsigned int max_remaining = 0;
|
|
for (i = 0; i < for_target_cells->id_list_len; i++) {
|
|
unsigned int remaining;
|
|
struct gsm0808_cell_id query = {
|
|
.id_discr = for_target_cells->id_discr,
|
|
.id = for_target_cells->id_list[i],
|
|
};
|
|
remaining = penalty_timers_remaining(penalty_timers, &query);
|
|
max_remaining = OSMO_MAX(max_remaining, remaining);
|
|
}
|
|
return max_remaining;
|
|
}
|
|
|
|
/* Clear penalty timers for one target cell, or completely clear the entire list.
|
|
* \param penalty_timers llist head to add penalty timer to.
|
|
* \param for_target_cell Which handover target to clear timers for, or NULL to clear all timers. */
|
|
void penalty_timers_clear(struct llist_head *penalty_timers, const struct gsm0808_cell_id *for_target_cell)
|
|
{
|
|
struct penalty_timer *timer, *timer2;
|
|
llist_for_each_entry_safe(timer, timer2, penalty_timers, entry) {
|
|
if (for_target_cell && !gsm0808_cell_ids_match(&timer->for_target_cell, for_target_cell, true))
|
|
continue;
|
|
llist_del(&timer->entry);
|
|
talloc_free(timer);
|
|
}
|
|
}
|