Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 1 | /* A Media Gateway Control Protocol Media Gateway: RFC 3435 */ |
| 2 | /* rate-counter implementation */ |
| 3 | |
| 4 | /* |
| 5 | * (C) 2009-2012 by Holger Hans Peter Freyther <zecke@selfish.org> |
| 6 | * (C) 2009-2012 by On-Waves |
| 7 | * (C) 2017-2020 by sysmocom s.f.m.c. GmbH <info@sysmocom.de> |
| 8 | * All Rights Reserved |
| 9 | * |
| 10 | * This program is free software; you can redistribute it and/or modify |
| 11 | * it under the terms of the GNU Affero General Public License as published by |
| 12 | * the Free Software Foundation; either version 3 of the License, or |
| 13 | * (at your option) any later version. |
| 14 | * |
| 15 | * This program is distributed in the hope that it will be useful, |
| 16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 18 | * GNU Affero General Public License for more details. |
| 19 | * |
| 20 | * You should have received a copy of the GNU Affero General Public License |
| 21 | * along with this program. If not, see <http://www.gnu.org/licenses/>. |
| 22 | * |
| 23 | */ |
| 24 | |
| 25 | #include <errno.h> |
| 26 | #include <osmocom/core/stats.h> |
Philipp Maier | 124a3e0 | 2021-07-26 11:17:15 +0200 | [diff] [blame] | 27 | #include <osmocom/core/stat_item.h> |
Philipp Maier | 993ea6b | 2020-08-04 18:26:50 +0200 | [diff] [blame] | 28 | #include <osmocom/mgcp/mgcp_conn.h> |
Philipp Maier | a065e63 | 2021-07-09 13:22:42 +0200 | [diff] [blame] | 29 | #include <osmocom/mgcp/mgcp_trunk.h> |
Philipp Maier | 124a3e0 | 2021-07-26 11:17:15 +0200 | [diff] [blame] | 30 | #include <osmocom/mgcp/mgcp_protocol.h> |
| 31 | #include <osmocom/mgcp/mgcp_endp.h> |
Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 32 | #include <osmocom/mgcp/mgcp_ratectr.h> |
| 33 | |
| 34 | static const struct rate_ctr_desc mgcp_general_ctr_desc[] = { |
| 35 | /* rx_msgs = rx_msgs_retransmitted + rx_msgs_handled + rx_msgs_unhandled + err_rx_msg_parse + err_rx_no_endpoint */ |
| 36 | [MGCP_GENERAL_RX_MSGS_TOTAL] = { "mgcp:rx_msgs", "total number of MGCP messages received." }, |
| 37 | [MGCP_GENERAL_RX_MSGS_RETRANSMITTED] = { "mgcp:rx_msgs_retransmitted", "number of received retransmissions." }, |
| 38 | [MGCP_GENERAL_RX_MSGS_HANDLED] = { "mgcp:rx_msgs_handled", "number of handled MGCP messages." }, |
| 39 | [MGCP_GENERAL_RX_MSGS_UNHANDLED] = { "mgcp:rx_msgs_unhandled", "number of unhandled MGCP messages." }, |
| 40 | [MGCP_GENERAL_RX_FAIL_MSG_PARSE] = { "mgcp:err_rx_msg_parse", "error parsing MGCP message." }, |
| 41 | [MGCP_GENERAL_RX_FAIL_NO_ENDPOINT] = |
| 42 | { "mgcp:err_rx_no_endpoint", "can't find MGCP endpoint, probably we've used all allocated endpoints." }, |
| 43 | }; |
| 44 | |
| 45 | const static struct rate_ctr_group_desc mgcp_general_ctr_group_desc = { |
| 46 | .group_name_prefix = "mgcp", |
| 47 | .group_description = "mgcp general statistics", |
| 48 | .class_id = OSMO_STATS_CLASS_GLOBAL, |
| 49 | .num_ctr = ARRAY_SIZE(mgcp_general_ctr_desc), |
| 50 | .ctr_desc = mgcp_general_ctr_desc |
| 51 | }; |
| 52 | |
| 53 | static const struct rate_ctr_desc mgcp_crcx_ctr_desc[] = { |
| 54 | [MGCP_CRCX_SUCCESS] = { "crcx:success", "CRCX command processed successfully." }, |
| 55 | [MGCP_CRCX_FAIL_BAD_ACTION] = { "crcx:bad_action", "bad action in CRCX command." }, |
| 56 | [MGCP_CRCX_FAIL_UNHANDLED_PARAM] = { "crcx:unhandled_param", "unhandled parameter in CRCX command." }, |
| 57 | [MGCP_CRCX_FAIL_MISSING_CALLID] = { "crcx:missing_callid", "missing CallId in CRCX command." }, |
| 58 | [MGCP_CRCX_FAIL_INVALID_MODE] = { "crcx:invalid_mode", "invalid connection mode in CRCX command." }, |
| 59 | [MGCP_CRCX_FAIL_LIMIT_EXCEEDED] = { "crcx:limit_exceeded", "limit of concurrent connections was reached." }, |
| 60 | [MGCP_CRCX_FAIL_UNKNOWN_CALLID] = { "crcx:unkown_callid", "unknown CallId in CRCX command." }, |
| 61 | [MGCP_CRCX_FAIL_ALLOC_CONN] = { "crcx:alloc_conn_fail", "connection allocation failure." }, |
| 62 | [MGCP_CRCX_FAIL_NO_REMOTE_CONN_DESC] = |
| 63 | { "crcx:no_remote_conn_desc", "no opposite end specified for connection." }, |
| 64 | [MGCP_CRCX_FAIL_START_RTP] = { "crcx:start_rtp_failure", "failure to start RTP processing." }, |
Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 65 | [MGCP_CRCX_FAIL_NO_OSMUX] = { "crcx:no_osmux", "no osmux offered by peer." }, |
| 66 | [MGCP_CRCX_FAIL_INVALID_CONN_OPTIONS] = { "crcx:conn_opt", "connection options invalid." }, |
| 67 | [MGCP_CRCX_FAIL_CODEC_NEGOTIATION] = { "crcx:codec_nego", "codec negotiation failure." }, |
| 68 | [MGCP_CRCX_FAIL_BIND_PORT] = { "crcx:bind_port", "port bind failure." }, |
Philipp Maier | 8d6a193 | 2020-06-18 12:19:31 +0200 | [diff] [blame] | 69 | [MGCP_CRCX_FAIL_AVAIL] = { "crcx:unavailable", "endpoint unavailable." }, |
Philipp Maier | 889fe7f | 2020-07-06 17:44:12 +0200 | [diff] [blame] | 70 | [MGCP_CRCX_FAIL_CLAIM] = { "crcx:claim", "endpoint can not be claimed." }, |
Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 71 | }; |
| 72 | |
| 73 | const static struct rate_ctr_group_desc mgcp_crcx_ctr_group_desc = { |
| 74 | .group_name_prefix = "crcx", |
| 75 | .group_description = "crxc statistics", |
| 76 | .class_id = OSMO_STATS_CLASS_GLOBAL, |
| 77 | .num_ctr = ARRAY_SIZE(mgcp_crcx_ctr_desc), |
| 78 | .ctr_desc = mgcp_crcx_ctr_desc |
| 79 | }; |
| 80 | |
| 81 | static const struct rate_ctr_desc mgcp_mdcx_ctr_desc[] = { |
| 82 | [MGCP_MDCX_SUCCESS] = { "mdcx:success", "MDCX command processed successfully." }, |
| 83 | [MGCP_MDCX_FAIL_WILDCARD] = { "mdcx:wildcard", "wildcard endpoint names in MDCX commands are unsupported." }, |
| 84 | [MGCP_MDCX_FAIL_NO_CONN] = { "mdcx:no_conn", "endpoint specified in MDCX command has no active connections." }, |
| 85 | [MGCP_MDCX_FAIL_INVALID_CALLID] = { "mdcx:callid", "invalid CallId specified in MDCX command." }, |
| 86 | [MGCP_MDCX_FAIL_INVALID_CONNID] = { "mdcx:connid", "invalid connection ID specified in MDCX command." }, |
| 87 | [MGCP_MDCX_FAIL_UNHANDLED_PARAM] = { "crcx:unhandled_param", "unhandled parameter in MDCX command." }, |
| 88 | [MGCP_MDCX_FAIL_NO_CONNID] = { "mdcx:no_connid", "no connection ID specified in MDCX command." }, |
| 89 | [MGCP_MDCX_FAIL_CONN_NOT_FOUND] = |
| 90 | { "mdcx:conn_not_found", "connection specified in MDCX command does not exist." }, |
| 91 | [MGCP_MDCX_FAIL_INVALID_MODE] = { "mdcx:invalid_mode", "invalid connection mode in MDCX command." }, |
| 92 | [MGCP_MDCX_FAIL_INVALID_CONN_OPTIONS] = { "mdcx:conn_opt", "connection options invalid." }, |
| 93 | [MGCP_MDCX_FAIL_NO_REMOTE_CONN_DESC] = |
| 94 | { "mdcx:no_remote_conn_desc", "no opposite end specified for connection." }, |
| 95 | [MGCP_MDCX_FAIL_START_RTP] = { "mdcx:start_rtp_failure", "failure to start RTP processing." }, |
Philipp Maier | 8d6a193 | 2020-06-18 12:19:31 +0200 | [diff] [blame] | 96 | [MGCP_MDCX_FAIL_AVAIL] = { "mdcx:unavailable", "endpoint unavailable." }, |
Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 97 | }; |
| 98 | |
| 99 | const static struct rate_ctr_group_desc mgcp_mdcx_ctr_group_desc = { |
| 100 | .group_name_prefix = "mdcx", |
| 101 | .group_description = "mdcx statistics", |
| 102 | .class_id = OSMO_STATS_CLASS_GLOBAL, |
| 103 | .num_ctr = ARRAY_SIZE(mgcp_mdcx_ctr_desc), |
| 104 | .ctr_desc = mgcp_mdcx_ctr_desc |
| 105 | }; |
| 106 | |
| 107 | static const struct rate_ctr_desc mgcp_dlcx_ctr_desc[] = { |
| 108 | [MGCP_DLCX_SUCCESS] = { "dlcx:success", "DLCX command processed successfully." }, |
Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 109 | [MGCP_DLCX_FAIL_NO_CONN] = { "dlcx:no_conn", "endpoint specified in DLCX command has no active connections." }, |
| 110 | [MGCP_DLCX_FAIL_INVALID_CALLID] = |
| 111 | { "dlcx:callid", "CallId specified in DLCX command mismatches endpoint's CallId ." }, |
| 112 | [MGCP_DLCX_FAIL_INVALID_CONNID] = |
| 113 | { "dlcx:connid", "connection ID specified in DLCX command does not exist on endpoint." }, |
| 114 | [MGCP_DLCX_FAIL_UNHANDLED_PARAM] = { "dlcx:unhandled_param", "unhandled parameter in DLCX command." }, |
Philipp Maier | 8d6a193 | 2020-06-18 12:19:31 +0200 | [diff] [blame] | 115 | [MGCP_DLCX_FAIL_AVAIL] = { "dlcx:unavailable", "endpoint unavailable." }, |
Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 116 | }; |
| 117 | |
| 118 | const static struct rate_ctr_group_desc mgcp_dlcx_ctr_group_desc = { |
| 119 | .group_name_prefix = "dlcx", |
| 120 | .group_description = "dlcx statistics", |
| 121 | .class_id = OSMO_STATS_CLASS_GLOBAL, |
| 122 | .num_ctr = ARRAY_SIZE(mgcp_dlcx_ctr_desc), |
| 123 | .ctr_desc = mgcp_dlcx_ctr_desc |
| 124 | }; |
| 125 | |
Philipp Maier | 889fe7f | 2020-07-06 17:44:12 +0200 | [diff] [blame] | 126 | static const struct rate_ctr_desc e1_rate_ctr_desc[] = { |
Philipp Maier | 97cae47 | 2021-07-09 13:26:47 +0200 | [diff] [blame] | 127 | [E1_I460_TRAU_RX_FAIL_CTR] = { "e1:rx_fail", "Inbound I.460 TRAU failures." }, |
| 128 | [E1_I460_TRAU_TX_FAIL_CTR] = { "e1:tx_fail", "Outbound I.460 TRAU failures." }, |
| 129 | [E1_I460_TRAU_MUX_EMPTY_CTR] = { "e1:i460", "Outbound I.460 MUX queue empty." } |
Philipp Maier | 889fe7f | 2020-07-06 17:44:12 +0200 | [diff] [blame] | 130 | }; |
| 131 | |
| 132 | const static struct rate_ctr_group_desc e1_rate_ctr_group_desc = { |
| 133 | .group_name_prefix = "e1", |
| 134 | .group_description = "e1 statistics", |
| 135 | .class_id = OSMO_STATS_CLASS_GLOBAL, |
| 136 | .num_ctr = ARRAY_SIZE(e1_rate_ctr_desc), |
| 137 | .ctr_desc = e1_rate_ctr_desc |
| 138 | }; |
| 139 | |
Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 140 | const static struct rate_ctr_group_desc all_rtp_conn_rate_ctr_group_desc = { |
| 141 | .group_name_prefix = "all_rtp_conn", |
| 142 | .group_description = "aggregated statistics for all rtp connections", |
| 143 | .class_id = 1, |
| 144 | .num_ctr = ARRAY_SIZE(all_rtp_conn_rate_ctr_desc), |
| 145 | .ctr_desc = all_rtp_conn_rate_ctr_desc |
| 146 | }; |
| 147 | |
Philipp Maier | a065e63 | 2021-07-09 13:22:42 +0200 | [diff] [blame] | 148 | /*! allocate global rate counters |
| 149 | * (called once at startup). |
| 150 | * \param[in] cfg mgw configuration for which the rate counters are allocated. |
| 151 | * \returns 0 on success, -EINVAL on failure. */ |
| 152 | int mgcp_ratectr_global_alloc(struct mgcp_config *cfg) |
Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 153 | { |
Philipp Maier | a065e63 | 2021-07-09 13:22:42 +0200 | [diff] [blame] | 154 | struct mgcp_ratectr_global *ratectr = &cfg->ratectr; |
Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 155 | static unsigned int general_rate_ctr_index = 0; |
Philipp Maier | a065e63 | 2021-07-09 13:22:42 +0200 | [diff] [blame] | 156 | char ctr_name[512]; |
Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 157 | |
| 158 | if (ratectr->mgcp_general_ctr_group == NULL) { |
| 159 | ratectr->mgcp_general_ctr_group = |
Philipp Maier | a065e63 | 2021-07-09 13:22:42 +0200 | [diff] [blame] | 160 | rate_ctr_group_alloc(cfg, &mgcp_general_ctr_group_desc, general_rate_ctr_index); |
Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 161 | if (!ratectr->mgcp_general_ctr_group) |
| 162 | return -EINVAL; |
Philipp Maier | a065e63 | 2021-07-09 13:22:42 +0200 | [diff] [blame] | 163 | snprintf(ctr_name, sizeof(ctr_name), "%s:general", cfg->domain); |
| 164 | rate_ctr_group_set_name(ratectr->mgcp_general_ctr_group, ctr_name); |
Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 165 | general_rate_ctr_index++; |
| 166 | } |
| 167 | return 0; |
| 168 | } |
| 169 | |
Philipp Maier | 38533ba | 2021-07-29 17:38:34 +0200 | [diff] [blame] | 170 | /*! free global rate counters |
| 171 | * (called once at process shutdown). |
| 172 | * \param[in] cfg mgw configuration for which the rate counters are allocated. */ |
| 173 | void mgcp_ratectr_global_free(struct mgcp_config *cfg) |
| 174 | { |
| 175 | struct mgcp_ratectr_global *ratectr = &cfg->ratectr; |
| 176 | |
| 177 | if (ratectr->mgcp_general_ctr_group) { |
| 178 | rate_ctr_group_free(ratectr->mgcp_general_ctr_group); |
| 179 | ratectr->mgcp_general_ctr_group = NULL; |
| 180 | } |
| 181 | } |
| 182 | |
Philipp Maier | a065e63 | 2021-07-09 13:22:42 +0200 | [diff] [blame] | 183 | /*! allocate trunk specific rate counters |
| 184 | * (called once on trunk initialization). |
| 185 | * \param[in] trunk mgw trunk for which the rate counters are allocated. |
Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 186 | * \returns 0 on success, -EINVAL on failure */ |
Philipp Maier | a065e63 | 2021-07-09 13:22:42 +0200 | [diff] [blame] | 187 | int mgcp_ratectr_trunk_alloc(struct mgcp_trunk *trunk) |
Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 188 | { |
Philipp Maier | a065e63 | 2021-07-09 13:22:42 +0200 | [diff] [blame] | 189 | struct mgcp_ratectr_trunk *ratectr = &trunk->ratectr; |
Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 190 | static unsigned int crcx_rate_ctr_index = 0; |
| 191 | static unsigned int mdcx_rate_ctr_index = 0; |
| 192 | static unsigned int dlcx_rate_ctr_index = 0; |
| 193 | static unsigned int all_rtp_conn_rate_ctr_index = 0; |
Philipp Maier | a065e63 | 2021-07-09 13:22:42 +0200 | [diff] [blame] | 194 | char ctr_name[256]; |
Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 195 | |
| 196 | if (ratectr->mgcp_crcx_ctr_group == NULL) { |
Philipp Maier | a065e63 | 2021-07-09 13:22:42 +0200 | [diff] [blame] | 197 | ratectr->mgcp_crcx_ctr_group = |
| 198 | rate_ctr_group_alloc(trunk, &mgcp_crcx_ctr_group_desc, crcx_rate_ctr_index); |
Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 199 | if (!ratectr->mgcp_crcx_ctr_group) |
| 200 | return -EINVAL; |
Philipp Maier | d70eef6 | 2021-07-19 13:53:28 +0200 | [diff] [blame] | 201 | snprintf(ctr_name, sizeof(ctr_name), "%s-%u:crcx", mgcp_trunk_type_strs_str(trunk->trunk_type), |
Philipp Maier | a065e63 | 2021-07-09 13:22:42 +0200 | [diff] [blame] | 202 | trunk->trunk_nr); |
| 203 | rate_ctr_group_set_name(ratectr->mgcp_crcx_ctr_group, ctr_name); |
Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 204 | crcx_rate_ctr_index++; |
| 205 | } |
| 206 | if (ratectr->mgcp_mdcx_ctr_group == NULL) { |
Philipp Maier | a065e63 | 2021-07-09 13:22:42 +0200 | [diff] [blame] | 207 | ratectr->mgcp_mdcx_ctr_group = |
| 208 | rate_ctr_group_alloc(trunk, &mgcp_mdcx_ctr_group_desc, mdcx_rate_ctr_index); |
Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 209 | if (!ratectr->mgcp_mdcx_ctr_group) |
| 210 | return -EINVAL; |
Philipp Maier | d70eef6 | 2021-07-19 13:53:28 +0200 | [diff] [blame] | 211 | snprintf(ctr_name, sizeof(ctr_name), "%s-%u:mdcx", mgcp_trunk_type_strs_str(trunk->trunk_type), |
Philipp Maier | a065e63 | 2021-07-09 13:22:42 +0200 | [diff] [blame] | 212 | trunk->trunk_nr); |
| 213 | rate_ctr_group_set_name(ratectr->mgcp_mdcx_ctr_group, ctr_name); |
Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 214 | mdcx_rate_ctr_index++; |
| 215 | } |
| 216 | if (ratectr->mgcp_dlcx_ctr_group == NULL) { |
Philipp Maier | a065e63 | 2021-07-09 13:22:42 +0200 | [diff] [blame] | 217 | ratectr->mgcp_dlcx_ctr_group = |
| 218 | rate_ctr_group_alloc(trunk, &mgcp_dlcx_ctr_group_desc, dlcx_rate_ctr_index); |
Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 219 | if (!ratectr->mgcp_dlcx_ctr_group) |
| 220 | return -EINVAL; |
Philipp Maier | d70eef6 | 2021-07-19 13:53:28 +0200 | [diff] [blame] | 221 | snprintf(ctr_name, sizeof(ctr_name), "%s-%u:dlcx", mgcp_trunk_type_strs_str(trunk->trunk_type), |
Philipp Maier | a065e63 | 2021-07-09 13:22:42 +0200 | [diff] [blame] | 222 | trunk->trunk_nr); |
| 223 | rate_ctr_group_set_name(ratectr->mgcp_dlcx_ctr_group, ctr_name); |
Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 224 | dlcx_rate_ctr_index++; |
| 225 | } |
| 226 | if (ratectr->all_rtp_conn_stats == NULL) { |
Philipp Maier | a065e63 | 2021-07-09 13:22:42 +0200 | [diff] [blame] | 227 | ratectr->all_rtp_conn_stats = rate_ctr_group_alloc(trunk, &all_rtp_conn_rate_ctr_group_desc, |
| 228 | all_rtp_conn_rate_ctr_index); |
Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 229 | if (!ratectr->all_rtp_conn_stats) |
| 230 | return -EINVAL; |
Philipp Maier | d70eef6 | 2021-07-19 13:53:28 +0200 | [diff] [blame] | 231 | snprintf(ctr_name, sizeof(ctr_name), "%s-%u:rtp_conn", mgcp_trunk_type_strs_str(trunk->trunk_type), |
Philipp Maier | a065e63 | 2021-07-09 13:22:42 +0200 | [diff] [blame] | 232 | trunk->trunk_nr); |
| 233 | rate_ctr_group_set_name(ratectr->all_rtp_conn_stats, ctr_name); |
Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 234 | all_rtp_conn_rate_ctr_index++; |
| 235 | } |
Philipp Maier | a065e63 | 2021-07-09 13:22:42 +0200 | [diff] [blame] | 236 | |
| 237 | /* E1 specific */ |
| 238 | if (trunk->trunk_type == MGCP_TRUNK_E1 && ratectr->e1_stats == NULL) { |
| 239 | ratectr->e1_stats = rate_ctr_group_alloc(trunk, &e1_rate_ctr_group_desc, mdcx_rate_ctr_index); |
Philipp Maier | 889fe7f | 2020-07-06 17:44:12 +0200 | [diff] [blame] | 240 | if (!ratectr->e1_stats) |
| 241 | return -EINVAL; |
Philipp Maier | d70eef6 | 2021-07-19 13:53:28 +0200 | [diff] [blame] | 242 | snprintf(ctr_name, sizeof(ctr_name), "%s-%u:e1", mgcp_trunk_type_strs_str(trunk->trunk_type), |
Philipp Maier | a065e63 | 2021-07-09 13:22:42 +0200 | [diff] [blame] | 243 | trunk->trunk_nr); |
| 244 | rate_ctr_group_set_name(ratectr->e1_stats, ctr_name); |
Philipp Maier | 889fe7f | 2020-07-06 17:44:12 +0200 | [diff] [blame] | 245 | mdcx_rate_ctr_index++; |
| 246 | } |
Philipp Maier | c66ab2c | 2020-06-02 20:55:34 +0200 | [diff] [blame] | 247 | return 0; |
| 248 | } |
Philipp Maier | 124a3e0 | 2021-07-26 11:17:15 +0200 | [diff] [blame] | 249 | |
Philipp Maier | 38533ba | 2021-07-29 17:38:34 +0200 | [diff] [blame] | 250 | /*! free trunk specific rate counters |
| 251 | * (called once when trunk is freed). |
| 252 | * \param[in] trunk mgw trunk on which the rate counters are allocated. */ |
| 253 | void mgcp_ratectr_trunk_free(struct mgcp_trunk *trunk) |
| 254 | { |
| 255 | struct mgcp_ratectr_trunk *ratectr = &trunk->ratectr; |
| 256 | |
| 257 | if (ratectr->mgcp_crcx_ctr_group) { |
| 258 | rate_ctr_group_free(ratectr->mgcp_crcx_ctr_group); |
| 259 | ratectr->mgcp_crcx_ctr_group = NULL; |
| 260 | } |
| 261 | if (ratectr->mgcp_mdcx_ctr_group) { |
| 262 | rate_ctr_group_free(ratectr->mgcp_mdcx_ctr_group); |
| 263 | ratectr->mgcp_mdcx_ctr_group = NULL; |
| 264 | } |
| 265 | if (ratectr->mgcp_dlcx_ctr_group) { |
| 266 | rate_ctr_group_free(ratectr->mgcp_dlcx_ctr_group); |
| 267 | ratectr->mgcp_dlcx_ctr_group = NULL; |
| 268 | } |
| 269 | if (ratectr->all_rtp_conn_stats) { |
| 270 | rate_ctr_group_free(ratectr->all_rtp_conn_stats); |
| 271 | ratectr->all_rtp_conn_stats = NULL; |
| 272 | } |
| 273 | |
| 274 | /* E1 specific */ |
| 275 | if (ratectr->e1_stats) { |
| 276 | rate_ctr_group_free(ratectr->e1_stats); |
| 277 | ratectr->e1_stats = NULL; |
| 278 | } |
| 279 | } |
| 280 | |
Philipp Maier | 124a3e0 | 2021-07-26 11:17:15 +0200 | [diff] [blame] | 281 | const struct osmo_stat_item_desc trunk_stat_desc[] = { |
| 282 | [TRUNK_STAT_ENDPOINTS_TOTAL] = { "endpoints:total", |
| 283 | "Number of endpoints that exist on the trunk", |
| 284 | "", 60, 0 }, |
| 285 | [TRUNK_STAT_ENDPOINTS_USED] = { "endpoints:used", |
| 286 | "Number of endpoints in use", |
| 287 | "", 60, 0 }, |
| 288 | }; |
| 289 | |
| 290 | const struct osmo_stat_item_group_desc trunk_statg_desc = { |
| 291 | .group_name_prefix = "trunk", |
| 292 | .group_description = "mgw trunk", |
| 293 | .class_id = OSMO_STATS_CLASS_GLOBAL, |
| 294 | .num_items = ARRAY_SIZE(trunk_stat_desc), |
| 295 | .item_desc = trunk_stat_desc, |
| 296 | }; |
| 297 | |
Philipp Maier | 124a3e0 | 2021-07-26 11:17:15 +0200 | [diff] [blame] | 298 | /*! allocate trunk specific stat items |
| 299 | * (called once on trunk initialization). |
| 300 | * \param[in] trunk for which the stat items are allocated. |
| 301 | * \returns 0 on success, -EINVAL on failure. */ |
| 302 | int mgcp_stat_trunk_alloc(struct mgcp_trunk *trunk) |
| 303 | { |
| 304 | struct mgcp_stat_trunk *stats = &trunk->stats; |
| 305 | static unsigned int common_stat_index = 0; |
| 306 | char stat_name[256]; |
| 307 | |
| 308 | stats->common = osmo_stat_item_group_alloc(trunk, &trunk_statg_desc, common_stat_index); |
| 309 | if (!stats->common) |
| 310 | return -EINVAL; |
| 311 | snprintf(stat_name, sizeof(stat_name), "%s-%u:common", mgcp_trunk_type_strs_str(trunk->trunk_type), |
| 312 | trunk->trunk_nr); |
| 313 | osmo_stat_item_group_set_name(stats->common, stat_name); |
Philipp Maier | 124a3e0 | 2021-07-26 11:17:15 +0200 | [diff] [blame] | 314 | common_stat_index++; |
| 315 | |
| 316 | return 0; |
| 317 | } |
Philipp Maier | 38533ba | 2021-07-29 17:38:34 +0200 | [diff] [blame] | 318 | |
| 319 | /*! free trunk specific stat items |
| 320 | * (called once when trunk is freed). |
| 321 | * \param[in] trunk on which the stat items are allocated. */ |
| 322 | void mgcp_stat_trunk_free(struct mgcp_trunk *trunk) |
| 323 | { |
| 324 | struct mgcp_stat_trunk *stats = &trunk->stats; |
| 325 | |
| 326 | if (stats->common) { |
| 327 | osmo_stat_item_group_free(stats->common); |
| 328 | stats->common = NULL; |
| 329 | } |
| 330 | } |