
// autogenerated by show asciidoc counters
These counters and their description based on OsmoMSC 1.4.0 (OsmoMSC).

=== Rate Counters

// generating tables for rate_ctr_group
// rate_ctr_group table mobile switching center
.msc - mobile switching center 
[options="header"]
|===
| Name | Reference | Description
| loc_update_type:attach | <<msc_loc_update_type:attach>> | Received Location Update (IMSI Attach) requests.
| loc_update_type:normal | <<msc_loc_update_type:normal>> | Received Location Update (LAC change) requests.
| loc_update_type:periodic | <<msc_loc_update_type:periodic>> | Received (periodic) Location Update requests.
| loc_update_type:detach | <<msc_loc_update_type:detach>> | Received IMSI Detach indications.
| loc_update_resp:failed | <<msc_loc_update_resp:failed>> | Rejected Location Updates requests.
| loc_update_resp:completed | <<msc_loc_update_resp:completed>> | Successful Location Update procedures.
| cm_service_request:rejected | <<msc_cm_service_request:rejected>> | Rejected CM Service Requests.
| cm_service_request:accepted | <<msc_cm_service_request:accepted>> | Accepted CM Service Requests.
| paging_resp:rejected | <<msc_paging_resp:rejected>> | Rejected Paging Responses.
| paging_resp:accepted | <<msc_paging_resp:accepted>> | Accepted Paging Responses.
| sms:submitted | <<msc_sms:submitted>> | Total MO SMS received from the MS.
| sms:no_receiver | <<msc_sms:no_receiver>> | Failed MO SMS delivery attempts (no receiver found).
| sms:deliver_unknown_error | <<msc_sms:deliver_unknown_error>> | Failed MO SMS delivery attempts (other reason).
| sms:delivered | <<msc_sms:delivered>> | Total MT SMS delivery attempts.
| sms:rp_err_mem | <<msc_sms:rp_err_mem>> | Failed MT SMS delivery attempts (no memory).
| sms:rp_err_other | <<msc_sms:rp_err_other>> | Failed MT SMS delivery attempts (other reason).
| call:mo_setup | <<msc_call:mo_setup>> | Received MO SETUP messages (MO call establishment).
| call:mo_connect_ack | <<msc_call:mo_connect_ack>> | Received MO CONNECT messages (MO call establishment).
| call:mt_setup | <<msc_call:mt_setup>> | Sent MT SETUP messages (MT call establishment).
| call:mt_connect | <<msc_call:mt_connect>> | Sent MT CONNECT messages (MT call establishment).
| call:active | <<msc_call:active>> | Calls that ever reached the active state.
| call:complete | <<msc_call:complete>> | Calls terminated by DISCONNECT message after reaching the active state.
| call:incomplete | <<msc_call:incomplete>> | Calls terminated by any other reason after reaching the active state.
| nc_ss:mo_requests | <<msc_nc_ss:mo_requests>> | Received MS-initiated call independent SS/USSD requests.
| nc_ss:mo_established | <<msc_nc_ss:mo_established>> | Established MS-initiated call independent SS/USSD sessions.
| nc_ss:mt_requests | <<msc_nc_ss:mt_requests>> | Received network-initiated call independent SS/USSD requests.
| nc_ss:mt_established | <<msc_nc_ss:mt_established>> | Established network-initiated call independent SS/USSD sessions.
| bssmap:cipher_mode_reject | <<msc_bssmap:cipher_mode_reject>> | Number of CIPHER MODE REJECT messages processed by BSSMAP layer
| bssmap:cipher_mode_complete | <<msc_bssmap:cipher_mode_complete>> | Number of CIPHER MODE COMPLETE messages processed by BSSMAP layer
|===
== Osmo Stat Items

// generating tables for osmo_stat_items
== Osmo Counters

// generating tables for osmo_counters
// ungrouped osmo_counters
.ungrouped osmo counters
[options="header"]
|===
| Name | Reference | Description
| msc.active_calls | <<ungroup_counter_msc.active_calls>> | 
| msc.active_nc_ss | <<ungroup_counter_msc.active_nc_ss>> |
|===
