
// 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 normal requests.
| loc_update_type:periodic | <<msc_loc_update_type:periodic>> | Received location update periodic requests.
| loc_update_type:detach | <<msc_loc_update_type:detach>> | Received location update detach indication.
| loc_update_resp:failed | <<msc_loc_update_resp:failed>> | Rejected location updates.
| loc_update_resp:completed | <<msc_loc_update_resp:completed>> | Successful location updates.
| cm_service_request:rejected | <<msc_cm_service_request:rejected>> | Rejected CM Service Request.
| cm_service_request:accepted | <<msc_cm_service_request:accepted>> | Accepted CM Service Request.
| paging_resp:rejected | <<msc_paging_resp:rejected>> | Rejected Paging Response.
| paging_resp:accepted | <<msc_paging_resp:accepted>> | Accepted Paging Response.
| sms:submitted | <<msc_sms:submitted>> | Received a RPDU from a MS (MO).
| sms:no_receiver | <<msc_sms:no_receiver>> | Counts SMS which couldn't routed because no receiver found.
| sms:delivered | <<msc_sms:delivered>> | Global SMS Deliver attempts.
| sms:rp_err_mem | <<msc_sms:rp_err_mem>> | CAUSE_MT_MEM_EXCEEDED errors of MS responses on a sms deliver attempt.
| sms:rp_err_other | <<msc_sms:rp_err_other>> | Other error of MS responses on a sms delive attempt.
| sms:deliver_unknown_error | <<msc_sms:deliver_unknown_error>> | Unknown error occurred during sms delivery.
| call:mo_setup | <<msc_call:mo_setup>> | Received setup requests from a MS to init a MO call.
| call:mo_connect_ack | <<msc_call:mo_connect_ack>> | Received a connect ack from MS of a MO call. Call is now succesful connected up.
| call:mt_setup | <<msc_call:mt_setup>> | Sent setup requests to the MS (MT).
| call:mt_connect | <<msc_call:mt_connect>> | Sent a connect to the MS (MT).
| call:active | <<msc_call:active>> | Count total amount of calls that ever reached active state.
| call:complete | <<msc_call:complete>> | Count total amount of calls which got terminated by disconnect req or ind after reaching active state.
| call:incomplete | <<msc_call:incomplete>> | Count total amount of call which got terminated by any other reason after reaching 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>> |
|===
