Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 1 | |
| 2 | #include <stdlib.h> |
Harald Welte | f5d6fee | 2016-01-13 22:29:10 +0100 | [diff] [blame] | 3 | #include <inttypes.h> |
Holger Hans Peter Freyther | 93b625b | 2013-05-31 09:52:26 +0200 | [diff] [blame] | 4 | #include <stddef.h> |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 5 | #include <stdio.h> |
| 6 | #include <string.h> |
Holger Hans Peter Freyther | 93b625b | 2013-05-31 09:52:26 +0200 | [diff] [blame] | 7 | #include <time.h> |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 8 | |
| 9 | #include <sys/stat.h> |
| 10 | #include <fcntl.h> |
| 11 | #include <unistd.h> |
| 12 | #include <errno.h> |
| 13 | |
Harald Welte | 211dd6c | 2016-01-13 00:18:49 +0100 | [diff] [blame] | 14 | #include <osmocom/core/msgb.h> |
| 15 | |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 16 | #include "diagchar_hdlc.h" |
Harald Welte | 211dd6c | 2016-01-13 00:18:49 +0100 | [diff] [blame] | 17 | #include "protocol.h" |
Harald Welte | 211dd6c | 2016-01-13 00:18:49 +0100 | [diff] [blame] | 18 | #include "config.h" |
Harald Welte | f5d6fee | 2016-01-13 22:29:10 +0100 | [diff] [blame] | 19 | #include "diagcmd.h" |
| 20 | #include "diag_gsm.h" |
| 21 | #include "log_codes_gsm.h" |
| 22 | #include "log_codes_wcdma.h" |
Harald Welte | e1d8ef9 | 2016-12-22 11:16:33 +0100 | [diff] [blame] | 23 | #include "log_codes_qmi.h" |
Harald Welte | f5d6fee | 2016-01-13 22:29:10 +0100 | [diff] [blame] | 24 | #include "diag_wcdma.h" |
| 25 | #include "gprs_rlc.h" |
| 26 | #include "gprs_mac.h" |
Harald Welte | e1d8ef9 | 2016-12-22 11:16:33 +0100 | [diff] [blame] | 27 | #include "qmi_decode.h" |
Harald Welte | 211dd6c | 2016-01-13 00:18:49 +0100 | [diff] [blame] | 28 | |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 29 | struct diag_instance { |
| 30 | int fd; |
| 31 | /* Receiver */ |
| 32 | struct { |
| 33 | struct msgb *msg; |
| 34 | } rx; |
| 35 | struct { |
| 36 | } tx; |
| 37 | }; |
| 38 | |
Harald Welte | 2d371ed | 2016-12-23 21:52:22 +0100 | [diff] [blame] | 39 | /* transmit a msgb containing a DIAG message over the given fd */ |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 40 | static int diag_transmit_msgb(struct diag_instance *di, struct msgb *msg) |
Harald Welte | 211dd6c | 2016-01-13 00:18:49 +0100 | [diff] [blame] | 41 | { |
| 42 | int out_len, rc; |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 43 | uint8_t packet[DIAG_MAX_HDLC_BUF_SIZE]; |
| 44 | struct diag_send_desc_type send; |
| 45 | struct diag_hdlc_dest_type enc = { NULL, NULL, 0 }; |
Harald Welte | 211dd6c | 2016-01-13 00:18:49 +0100 | [diff] [blame] | 46 | |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 47 | send.state = DIAG_STATE_START; |
| 48 | send.pkt = msgb_data(msg); |
| 49 | send.last = msgb_data(msg) + msgb_length(msg) - 1; |
| 50 | send.terminate = 1; |
Harald Welte | 211dd6c | 2016-01-13 00:18:49 +0100 | [diff] [blame] | 51 | |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 52 | enc.dest = packet; |
| 53 | enc.dest_last = packet + sizeof(packet) - 1; |
| 54 | |
| 55 | diag_hdlc_encode(&send, &enc); |
| 56 | |
| 57 | out_len = (enc.dest - (void *)packet); |
| 58 | |
| 59 | rc = write(di->fd, packet, out_len); |
Harald Welte | 211dd6c | 2016-01-13 00:18:49 +0100 | [diff] [blame] | 60 | if (rc != out_len) { |
| 61 | printf("Short write on packet.\n"); |
| 62 | return -1; |
| 63 | } |
| 64 | |
| 65 | msgb_free(msg); |
| 66 | |
| 67 | return 0; |
| 68 | } |
| 69 | |
Harald Welte | 2d371ed | 2016-12-23 21:52:22 +0100 | [diff] [blame] | 70 | /* transmit a message from a buffer (nto msgb) as DIAG over the given fd */ |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 71 | static int diag_transmit_buf(struct diag_instance *di, const uint8_t *data, size_t data_len) |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 72 | { |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 73 | struct msgb *msg = msgb_alloc(DIAG_MAX_REQ_SIZE, "DIAG Tx"); |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 74 | |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 75 | memcpy(msg->tail, data, data_len); |
| 76 | msgb_put(msg, data_len); |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 77 | |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 78 | return diag_transmit_msgb(di, msg); |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 79 | } |
| 80 | |
Holger Hans Peter Freyther | 93b625b | 2013-05-31 09:52:26 +0200 | [diff] [blame] | 81 | static int dump_log(const uint8_t *data, const size_t len) |
| 82 | { |
Holger Hans Peter Freyther | 93b625b | 2013-05-31 09:52:26 +0200 | [diff] [blame] | 83 | const struct ext_log_msg *msg; |
Harald Welte | cd877f1 | 2016-12-23 20:04:27 +0100 | [diff] [blame] | 84 | const char *file = NULL, *fmt; |
| 85 | unsigned int num_args; |
Holger Hans Peter Freyther | 93b625b | 2013-05-31 09:52:26 +0200 | [diff] [blame] | 86 | |
| 87 | if (len < sizeof(struct ext_log_msg)) { |
| 88 | printf("too short log message.\n"); |
| 89 | return -1; |
| 90 | } |
| 91 | |
| 92 | msg = (struct ext_log_msg *) data; |
Harald Welte | cd877f1 | 2016-12-23 20:04:27 +0100 | [diff] [blame] | 93 | num_args = msg->num_args; |
| 94 | fmt = (const char *) msg->params + num_args*sizeof(msg->params[0]); |
| 95 | file = fmt + strlen(fmt) + 1; |
Holger Hans Peter Freyther | 93b625b | 2013-05-31 09:52:26 +0200 | [diff] [blame] | 96 | |
Harald Welte | cd877f1 | 2016-12-23 20:04:27 +0100 | [diff] [blame] | 97 | printf("%"PRIu64" %-20s(%u): ", msg->timestamp, file, msg->line_nr); |
| 98 | switch (num_args) { |
| 99 | case 0: |
| 100 | fputs(fmt, stdout); |
| 101 | break; |
| 102 | case 1: |
| 103 | printf(fmt, msg->params[0]); |
| 104 | break; |
| 105 | case 2: |
| 106 | printf(fmt, msg->params[0], msg->params[1]); |
| 107 | break; |
| 108 | case 3: |
| 109 | printf(fmt, msg->params[0], msg->params[1], msg->params[2]); |
| 110 | break; |
| 111 | case 4: |
| 112 | printf(fmt, msg->params[0], msg->params[1], msg->params[2], msg->params[3]); |
| 113 | break; |
Holger Hans Peter Freyther | 93b625b | 2013-05-31 09:52:26 +0200 | [diff] [blame] | 114 | } |
Harald Welte | cd877f1 | 2016-12-23 20:04:27 +0100 | [diff] [blame] | 115 | fputc('\n', stdout); |
Holger Hans Peter Freyther | 93b625b | 2013-05-31 09:52:26 +0200 | [diff] [blame] | 116 | return 0; |
| 117 | } |
| 118 | |
Harald Welte | f5d6fee | 2016-01-13 22:29:10 +0100 | [diff] [blame] | 119 | static void handle_rr_sig_msg(struct log_hdr *lh, struct msgb *msg) |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 120 | { |
Harald Welte | f5d6fee | 2016-01-13 22:29:10 +0100 | [diff] [blame] | 121 | struct diag_gsm_rr_msg *rm = (struct diag_gsm_rr_msg *) msgb_data(msg); |
| 122 | |
| 123 | printf("RR: %02x %02x %u: %s\n", rm->chan_type, rm->msg_type, |
| 124 | rm->length, osmo_hexdump(msgb_data(msg), rm->length)); |
| 125 | } |
| 126 | |
| 127 | static void handle_rr_state_msg(struct log_hdr *lh, struct msgb *msg) |
| 128 | { |
| 129 | struct diag_gsm_rr_state *rrs = (struct diag_gsm_rr_state *) msgb_data(msg); |
| 130 | printf("RR-STATE { state=%s, substate=%u, status=%u, mode=%u }\n", |
| 131 | get_value_string(diag_gsm_rr_st_vals, rrs->state) |
| 132 | , rrs->substate, rrs->status, rrs->mode); |
| 133 | |
| 134 | } |
| 135 | |
| 136 | static void handle_grr_state_msg(struct log_hdr *lh, struct msgb *msg) |
| 137 | { |
| 138 | struct diag_gprs_grr_state *rrs = (struct diag_gprs_grr_state *) msgb_data(msg); |
| 139 | |
| 140 | printf("GRR-STATE { active=%u, state=%s }\n", rrs->active_state, |
| 141 | get_value_string(diag_gprs_grr_st_vals, rrs->grr_state)); |
| 142 | } |
| 143 | |
| 144 | static void handle_rrc_sig_msg(struct log_hdr *lh, struct msgb *msg) |
| 145 | { |
| 146 | struct diag_umts_rrc_msg *rrm = (struct diag_umts_rrc_msg *) msgb_data(msg); |
| 147 | |
| 148 | printf("RRC: %u %u %u: %s\n", rrm->chan_type, rrm->rb_id, rrm->length, |
| 149 | osmo_hexdump(msgb_data(msg), rrm->length)); |
| 150 | } |
| 151 | |
| 152 | static void handle_rlc_ul_abnrml_rls(struct log_hdr *lh, struct msgb *msg) |
| 153 | { |
| 154 | struct gprs_rlc_ul_abnrml_rls_counts *arc; |
| 155 | arc = (struct gprs_rlc_ul_abnrml_rls_counts *) msgb_data(msg); |
| 156 | |
| 157 | printf("RLC-UL-ABNRML-RLS-COUNTS { access_reject_cnt=%u, arc_retry_cnt=%u, arc_wo_retry_cnt=%u, arc_sys_info_cnt=%u }", |
| 158 | arc->access_reject_cnt, arc->arc_retry_cnt, arc->arc_wo_retry_cnt, arc->arc_sys_info_cnt); |
| 159 | } |
| 160 | |
| 161 | static void handle_mac_sign_msg(struct log_hdr *lh, struct msgb *msg) |
| 162 | { |
| 163 | struct gprs_mac_signalling_msg *msm; |
| 164 | msm = (struct gprs_mac_signalling_msg *) msgb_data(msg); |
| 165 | printf("MAC-SIGN-MSG { chan_type=%s, msg_type=%s, msg=%s }\n", |
| 166 | get_value_string(gprs_mac_chan_type_vals, msm->chan_type), |
| 167 | get_value_string(gprs_mac_msg_type_vals, msm->msg_type), |
| 168 | osmo_hexdump(msm->msg, msm->msg_len)); |
| 169 | } |
| 170 | |
| 171 | static void handle_llc_me_info(struct log_hdr *lh, struct msgb *msg) |
| 172 | { |
| 173 | struct diag_gprs_llme_info *gli; |
| 174 | gli = (struct diag_gprs_llme_info *) msgb_data(msg); |
| 175 | printf("LLC-ME-INFO { state=%s, xid_version=%u, tlli_new=0x%08x, tlli_old=0x%08x, gea=%u, key=%s }\n", |
| 176 | get_value_string(diag_gprs_llme_st_vals, gli->state), gli->xid_version, |
| 177 | gli->tlli_new, gli->tlli_old, gli->enc_alg, |
| 178 | osmo_hexdump_nospc(gli->enc_key, sizeof(gli->enc_key))); |
| 179 | } |
| 180 | |
| 181 | static void handle_llc_pdu_stats(struct log_hdr *lh, struct msgb *msg) |
| 182 | { |
| 183 | struct diag_gprs_llc_stats *gls; |
| 184 | gls = (struct diag_gprs_llc_stats *) msgb_data(msg); |
| 185 | printf("LLC-PDU-STATS-ACK { sap=%u, l3pdu_tx=%u, octet_tx=%u, octet_retrans=%u, l3pdu_rx=%u, octet_rx=%u }\n", |
| 186 | gls->sapi, gls->ack_l3pdu_tx, gls->ack_octet_tx, gls->ack_l3pdu_retrans, gls->ack_l3pdu_rx, gls->ack_octet_rx); |
| 187 | printf("LLC-PDU-STATS-UNACK { sapi=%u, l3pdu_tx=%u, octet_tx=%u, l3pdu_rx=%u, octet_rx=%u }\n", |
| 188 | gls->sapi, gls->unack_l3pdu_tx, gls->unack_octet_tx, gls->unack_l3pdu_rx, gls->unack_octet_rx); |
| 189 | printf("LLC-PDU-STATS-LLPDU { tx=%u, rx=%u, fcs_err=%u, frm_rej=%u, tlli_err=%u, addr_err=%u, short_err=%u }\n", |
| 190 | gls->llpdu_tx, gls->llpdu_rx, gls->llpdu_fcs_err, gls->llpdu_frm_rej, gls->llpdu_tlli_err, gls->llpdu_addr_err, gls->llpdu_short_err); |
| 191 | } |
| 192 | |
| 193 | static void handle_mac_state(struct log_hdr *lh, struct msgb *msg) |
| 194 | { |
| 195 | struct gprs_mac_state_change *msc; |
| 196 | msc = (struct gprs_mac_state_change *) msgb_data(msg); |
| 197 | const char *name = ""; |
| 198 | |
| 199 | switch (msc->mac_mode) { |
| 200 | case NULL_MODE: |
| 201 | name = get_value_string(gprs_mac_null_substate_vals, msc->mac_null_fsm_state); |
| 202 | break; |
| 203 | case IDLE_MODE: |
| 204 | name = get_value_string(gprs_mac_idle_substate_vals, msc->mac_idle_fsm_state); |
| 205 | break; |
| 206 | case TRANSFER_MODE: |
| 207 | name = get_value_string(gprs_mac_transfer_substate_vals, msc->mac_transfer_fsm_state); |
| 208 | break; |
| 209 | } |
| 210 | |
| 211 | printf("MAC-STATE { mode=%s, state=%s }\n", |
| 212 | get_value_string(gprs_mac_mode_vals, msc->mac_mode), name); |
| 213 | } |
| 214 | |
| 215 | static void handle_mac_dl_tbf_est(struct log_hdr *lh, struct msgb *msg) |
| 216 | { |
| 217 | struct gprs_mac_dl_tbf_est *dte; |
| 218 | dte = (struct gprs_mac_dl_tbf_est *) msgb_data(msg); |
| 219 | |
| 220 | printf("MAC-DL-TBF-EST { tfi=%u, rlc_mode=%u, dl_ts_bmap=0x%x, is_egprs=%u, egprs_win_size=%u, egprs_link_qual_mode=%u, bep_period2=%u }\n", |
| 221 | dte->dl_tfi, dte->rlc_mode, dte->dl_ts_bmap, dte->is_egprs_tbf, dte->egprs_win_size, dte->egprs_link_qual_mode, dte->bep_period2); |
| 222 | } |
| 223 | |
| 224 | static void handle_mac_ul_tbf_est(struct log_hdr *lh, struct msgb *msg) |
| 225 | { |
| 226 | struct gprs_mac_ul_tbf_est *ute; |
| 227 | ute = (struct gprs_mac_ul_tbf_est *) msgb_data(msg); |
| 228 | |
| 229 | printf("MAC-UL-TBF-EST { tbf_req_cause=%u, acc_granted=%u, radio_prio=%u, peak_tput=%u, ul_tfi=%u, rlc_mode=%u, ul_ts_bmap=0x%x, is_egprs=%u, egprs_win_size=%u, resegment=%u, bep_period2=%u }\n", |
| 230 | ute->tbf_req_cause, ute->acc_granted, ute->radio_prio, ute->peak_tput, ute->ul_tfi, ute->rlc_mode, ute->ul_ts_bmap, ute->is_egprs_tbf, ute->egprs_win_size, ute->resegment, ute->bep_period2); |
| 231 | } |
| 232 | |
Harald Welte | 97d3042 | 2016-12-19 21:18:06 +0100 | [diff] [blame] | 233 | static void handle_mac_dl_tbf_rel(struct log_hdr *lh, struct msgb *msg) |
| 234 | { |
| 235 | struct gprs_mac_tbf_release *tr; |
| 236 | tr = (struct gprs_mac_tbf_release *) msgb_data(msg); |
| 237 | |
| 238 | printf("MAC-DL-TBF-REL { tfi=%u, fail_cause=%u }\n", tr->tfi, tr->fail_cause); |
| 239 | } |
| 240 | |
| 241 | static void handle_mac_ul_tbf_rel(struct log_hdr *lh, struct msgb *msg) |
| 242 | { |
| 243 | struct gprs_mac_tbf_release *tr; |
| 244 | tr = (struct gprs_mac_tbf_release *) msgb_data(msg); |
| 245 | |
| 246 | printf("MAC-DL-TBF-REL { tfi=%u, fail_cause=%u }\n", tr->tfi, tr->fail_cause); |
| 247 | } |
| 248 | |
Harald Welte | f5d6fee | 2016-01-13 22:29:10 +0100 | [diff] [blame] | 249 | static void handle_rlc_ul_evt_cnt(struct log_hdr *lh, struct msgb *msg) |
| 250 | { |
| 251 | struct gprs_rlc_ul_event_counts *uec; |
| 252 | uec = (struct gprs_rlc_ul_event_counts *) msgb_data(msg); |
| 253 | |
| 254 | printf("RLC-UL-EVT-CNT { llc_event_cnt=%u, mac_event_cnt=%u, pl1_event_cnt=%u, tmr_event_cnt=%u }\n", |
| 255 | uec->llc_event_cnt, uec->mac_event_cnt, uec->pl1_event_cnt, uec->tmr_event_cnt); |
| 256 | } |
| 257 | |
| 258 | static void handle_rlc_ul_stats(struct log_hdr *lh, struct msgb *msg) |
| 259 | { |
| 260 | struct gprs_rlc_ul_stats *uls; |
| 261 | uls = (struct gprs_rlc_ul_stats *) msgb_data(msg); |
| 262 | |
| 263 | printf("RLC-UL-STATS { state=%s(%s), FIXME... }\n", |
| 264 | get_value_string(gprs_rlc_ul_state_vals, uls->rlc_ul_state), |
| 265 | get_value_string(gprs_rlc_ul_substate_vals, uls->rlc_ul_substate)); |
| 266 | } |
| 267 | |
| 268 | static void handle_rlc_dl_stats(struct log_hdr *lh, struct msgb *msg) |
| 269 | { |
| 270 | struct gprs_rlc_dl_stats *dls; |
| 271 | dls = (struct gprs_rlc_dl_stats *) msgb_data(msg); |
| 272 | |
| 273 | printf("RLC-DL-STATS { state=%s, FIXME... }\n", |
| 274 | get_value_string(gprs_rlc_dl_state_vals, dls->rlc_dl_state)); |
| 275 | } |
| 276 | |
| 277 | static void handle_rlc_rel(struct log_hdr *lh, struct msgb *msg) |
| 278 | { |
| 279 | struct gprs_rlc_release_ind *rli; |
| 280 | rli = (struct gprs_rlc_release_ind *) msgb_data(msg); |
| 281 | char ud = 'D'; |
| 282 | |
| 283 | if (lh->code == LOG_GPRS_RLC_UL_RELEASE_IND_C) |
| 284 | ud ='U'; |
| 285 | |
| 286 | printf("RLC-%cL-RELEASE { tfi=%u, cause=%u }\n", ud, rli->tfi, rli->cause); |
| 287 | } |
| 288 | |
| 289 | |
| 290 | |
| 291 | struct log_dispatch_tbl { |
| 292 | uint16_t code; |
| 293 | void (*handler)(struct log_hdr *lh, struct msgb *msg); |
| 294 | }; |
| 295 | |
| 296 | #define GSM(x) (0x5000 + x) |
| 297 | #define UMTS(x) (0x4000 + x) |
| 298 | |
| 299 | static const struct log_dispatch_tbl log_tbl[] = { |
| 300 | { GSM(LOG_GSM_RR_SIGNALING_MESSAGE_C), handle_rr_sig_msg }, |
| 301 | { GSM(LOG_GSM_RR_STATE_C), handle_rr_state_msg }, |
| 302 | { GSM(LOG_GPRS_LLC_ME_INFO_C), handle_llc_me_info }, |
| 303 | { GSM(LOG_GPRS_LLC_PDU_STATS_C), handle_llc_pdu_stats }, |
| 304 | { GSM(LOG_GPRS_GRR_STATE_C), handle_grr_state_msg }, |
| 305 | { GSM(LOG_GPRS_RLC_UL_ABNRML_RLS_COUNTS_C), handle_rlc_ul_abnrml_rls }, |
| 306 | { GSM(LOG_GPRS_RLC_UL_EVENT_COUNTS_C), handle_rlc_ul_evt_cnt }, |
| 307 | { GSM(LOG_GPRS_RLC_UL_RELEASE_IND_C), handle_rlc_rel }, |
| 308 | { GSM(LOG_GPRS_RLC_DL_RELEASE_IND_C), handle_rlc_rel }, |
| 309 | { GSM(LOG_GPRS_MAC_SIGNALLING_MESSAGE_C), handle_mac_sign_msg }, |
| 310 | { GSM(LOG_GPRS_MAC_STATE_C), handle_mac_state }, |
| 311 | { GSM(LOG_GPRS_MAC_DL_TBF_ESTABLISH_C), handle_mac_dl_tbf_est }, |
| 312 | { GSM(LOG_GPRS_MAC_UL_TBF_ESTABLISH_C), handle_mac_ul_tbf_est }, |
Harald Welte | 97d3042 | 2016-12-19 21:18:06 +0100 | [diff] [blame] | 313 | { GSM(LOG_GPRS_MAC_DL_TBF_RELEASE_C), handle_mac_dl_tbf_rel }, |
| 314 | { GSM(LOG_GPRS_MAC_UL_TBF_RELEASE_C), handle_mac_ul_tbf_rel }, |
Harald Welte | f5d6fee | 2016-01-13 22:29:10 +0100 | [diff] [blame] | 315 | { GSM(LOG_GPRS_RLC_UL_STATS_C), handle_rlc_ul_stats }, |
| 316 | { GSM(LOG_GPRS_RLC_DL_STATS_C), handle_rlc_dl_stats }, |
| 317 | { UMTS(LOG_WCDMA_SIGNALING_MSG_C), handle_rrc_sig_msg }, |
| 318 | }; |
| 319 | |
| 320 | static void diag_log_handle(struct msgb *msg) |
| 321 | { |
| 322 | struct diag_log_hdr *dlh; |
| 323 | struct log_hdr *lh; |
| 324 | int i; |
| 325 | |
| 326 | dlh = (struct diag_log_hdr *) msg->data; |
| 327 | /* FIXME: verify length */ |
| 328 | msg->l3h = msgb_pull(msg, sizeof(*dlh)); |
| 329 | |
| 330 | lh = (struct log_hdr *) msg->l3h; |
| 331 | /* FIXME: verify length */ |
| 332 | msgb_pull(msg, sizeof(*lh)); |
| 333 | |
| 334 | for (i = 0; i < ARRAY_SIZE(log_tbl); i++) { |
| 335 | if (log_tbl[i].code == lh->code) { |
| 336 | log_tbl[i].handler(lh, msg); |
| 337 | return; |
| 338 | } |
| 339 | } |
| 340 | |
| 341 | printf("LOG(0x%04x, %"PRIu64"u, %u): %s\n", lh->code, lh->ts, lh->len, |
| 342 | osmo_hexdump(lh->data, lh->len)); |
Harald Welte | e1d8ef9 | 2016-12-22 11:16:33 +0100 | [diff] [blame] | 343 | |
| 344 | uint8_t subsys = lh->code >> 12; |
| 345 | |
| 346 | if (subsys == 0x01 && |
| 347 | ((lh->code & 0xfff) >= LOG_QMI_RESERVED_CODES_BASE_C) && |
| 348 | ((lh->code & 0xfff) <= LOG_QMI_LAST_C)) |
| 349 | dump_qmi_msg(lh->data, lh->len); |
Harald Welte | f5d6fee | 2016-01-13 22:29:10 +0100 | [diff] [blame] | 350 | } |
| 351 | |
| 352 | /*********/ |
| 353 | |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 354 | static int do_read(struct diag_instance *di) |
Harald Welte | f5d6fee | 2016-01-13 22:29:10 +0100 | [diff] [blame] | 355 | { |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 356 | uint8_t buf[DIAG_MAX_HDLC_BUF_SIZE]; |
| 357 | struct diag_hdlc_decode_type hdlc_decode; |
| 358 | struct msgb *msg; |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 359 | int rc; |
| 360 | |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 361 | /* read raw data into buffer */ |
| 362 | rc = read(di->fd, buf, sizeof(buf)); |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 363 | if (rc <= 0 ) { |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 364 | fprintf(stderr, "Short read!\n"); |
| 365 | return -EIO; |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 366 | } |
| 367 | |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 368 | if (!di->rx.msg) { |
| 369 | di->rx.msg = msgb_alloc(DIAG_MAX_REQ_SIZE, "DIAG Rx"); |
| 370 | di->rx.msg->l2h = di->rx.msg->tail; |
| 371 | } |
| 372 | msg = di->rx.msg; |
| 373 | |
| 374 | hdlc_decode.dest_ptr = msg->tail; |
| 375 | hdlc_decode.dest_size = msgb_tailroom(msg); |
| 376 | hdlc_decode.src_ptr = buf; |
| 377 | hdlc_decode.src_size = rc; |
| 378 | hdlc_decode.src_idx = 0; |
| 379 | hdlc_decode.dest_idx = 0; |
| 380 | |
| 381 | rc = diag_hdlc_decode(&hdlc_decode); |
| 382 | |
| 383 | if (msgb_length(msg) + hdlc_decode.dest_idx > DIAG_MAX_REQ_SIZE) { |
| 384 | fprintf(stderr, "Dropping packet. pkt_size: %d, max: %d\n", |
| 385 | msgb_length(msg) + hdlc_decode.dest_idx, |
| 386 | DIAG_MAX_REQ_SIZE); |
| 387 | return -EIO; |
| 388 | } |
| 389 | |
| 390 | msgb_put(msg, hdlc_decode.dest_idx); |
| 391 | |
| 392 | if (rc == HDLC_COMPLETE) { |
| 393 | di->rx.msg = NULL; |
| 394 | rc = crc_check(msgb_data(msg), msgb_length(msg)); |
| 395 | if (rc) { |
| 396 | fprintf(stderr, "Bad CRC, dropping packet\n"); |
| 397 | msgb_free(msg); |
| 398 | return -EINVAL; |
| 399 | } |
| 400 | msgb_get(msg, HDLC_FOOTER_LEN); |
| 401 | |
| 402 | if (msgb_length(msg) < 1) { |
| 403 | fprintf(stderr, "Message too short, len: %u\n", msgb_length(msg)); |
| 404 | msgb_free(msg); |
| 405 | return -EINVAL; |
| 406 | } |
| 407 | |
| 408 | switch (msg->l2h[0]) { |
| 409 | case DIAG_LOG_F: |
| 410 | diag_log_handle(msg); |
| 411 | break; |
| 412 | case DIAG_EXT_MSG_F: |
| 413 | dump_log(msgb_data(msg), msgb_length(msg)); |
| 414 | break; |
| 415 | default: |
| 416 | printf("Got %d bytes data of unknown payload type 0x%02x\n", |
| 417 | msgb_length(msg), msg->l2h[0]); |
| 418 | printf("%s\n", osmo_hexdump(msgb_data(msg), msgb_length(msg))); |
| 419 | break; |
| 420 | } |
Harald Welte | f5d6fee | 2016-01-13 22:29:10 +0100 | [diff] [blame] | 421 | msgb_free(msg); |
Harald Welte | f5d6fee | 2016-01-13 22:29:10 +0100 | [diff] [blame] | 422 | } |
Holger Hans Peter Freyther | 93b625b | 2013-05-31 09:52:26 +0200 | [diff] [blame] | 423 | |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 424 | return 0; |
| 425 | }; |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 426 | |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 427 | static void do_configure(struct diag_instance *di) |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 428 | { |
Harald Welte | f5d6fee | 2016-01-13 22:29:10 +0100 | [diff] [blame] | 429 | static uint8_t timestamp[] = { DIAG_TS_F }; |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 430 | static const uint8_t enable_evt_report[] = { |
Harald Welte | f5d6fee | 2016-01-13 22:29:10 +0100 | [diff] [blame] | 431 | DIAG_EVENT_REPORT_F, 0x01 |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 432 | }; |
| 433 | static const uint8_t disable_evt_report[] = { |
Harald Welte | f5d6fee | 2016-01-13 22:29:10 +0100 | [diff] [blame] | 434 | DIAG_EVENT_REPORT_F, 0x00 |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 435 | }; |
| 436 | static const uint8_t extended_report_cfg[] = { |
Harald Welte | f5d6fee | 2016-01-13 22:29:10 +0100 | [diff] [blame] | 437 | /* command code */ |
| 438 | DIAG_EXT_MSG_CONFIG_F, |
| 439 | /* sub command */ |
| 440 | 0x04, |
| 441 | /* subsystem ID range start */ |
| 442 | 0x00, 0x00, |
| 443 | /* subsystem ID range end */ |
| 444 | 0x00, 0x00, |
| 445 | /* pad */ |
| 446 | 0x00, 0x00, |
| 447 | /* array of runtime masks */ |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 448 | 0x02, 0x00, 0x00, 0x00, |
| 449 | }; |
| 450 | |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 451 | /* TODO: introduce a wait for response kind of method */ |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 452 | diag_transmit_buf(di, timestamp, sizeof(timestamp)); |
| 453 | do_read(di); |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 454 | |
Holger Hans Peter Freyther | 93b625b | 2013-05-31 09:52:26 +0200 | [diff] [blame] | 455 | /* enable|disable the event report */ |
| 456 | #if 0 |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 457 | diag_transmit_buf(di, enable_evt_report, sizeof(enable_evt_report)); |
| 458 | do_read(di); |
Harald Welte | f5d6fee | 2016-01-13 22:29:10 +0100 | [diff] [blame] | 459 | #else |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 460 | diag_transmit_buf(di, disable_evt_report, sizeof(disable_evt_report)); |
| 461 | do_read(di); |
Harald Welte | f5d6fee | 2016-01-13 22:29:10 +0100 | [diff] [blame] | 462 | #endif |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 463 | |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 464 | diag_transmit_buf(di, extended_report_cfg, sizeof(extended_report_cfg)); |
| 465 | do_read(di); |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 466 | |
Harald Welte | f5d6fee | 2016-01-13 22:29:10 +0100 | [diff] [blame] | 467 | printf("GSM\n"); |
| 468 | struct msgb *msg = gen_log_config_set_mask(5, 1064); |
| 469 | #if 0 |
| 470 | for (int i = 0; i < 1064; i++) |
| 471 | log_config_set_mask_bit(msg, i); |
| 472 | #endif |
| 473 | |
| 474 | log_config_set_mask_bit(msg, LOG_GSM_RR_CONTROL_CHANNEL_PARAMS_C); |
| 475 | log_config_set_mask_bit(msg, LOG_GSM_RR_SIGNALING_MESSAGE_C); |
| 476 | log_config_set_mask_bit(msg, LOG_GSM_RR_STATE_C); |
| 477 | |
| 478 | log_config_set_mask_bit(msg, LOG_GPRS_GRR_STATE_C); |
| 479 | |
| 480 | log_config_set_mask_bit(msg, LOG_GPRS_RLC_UL_ABNRML_RLS_COUNTS_C); |
| 481 | log_config_set_mask_bit(msg, LOG_GPRS_RLC_UL_EVENT_COUNTS_C); |
| 482 | log_config_set_mask_bit(msg, LOG_GPRS_RLC_UL_STATS_C); |
| 483 | log_config_set_mask_bit(msg, LOG_GPRS_RLC_DL_STATS_C); |
| 484 | log_config_set_mask_bit(msg, LOG_GPRS_RLC_UL_ACKNACK_PARAMS_VER2_C); |
| 485 | log_config_set_mask_bit(msg, LOG_GPRS_RLC_DL_ACKNACK_PARAMS_VER2_C); |
| 486 | log_config_set_mask_bit(msg, LOG_GPRS_RLC_UL_RELEASE_IND_C); |
| 487 | log_config_set_mask_bit(msg, LOG_GPRS_RLC_DL_RELEASE_IND_C); |
| 488 | log_config_set_mask_bit(msg, LOG_EGPRS_RLC_DL_HEADER_C); |
| 489 | log_config_set_mask_bit(msg, LOG_EGPRS_RLC_UL_HEADER_C); |
| 490 | |
| 491 | log_config_set_mask_bit(msg, LOG_GPRS_LLC_ME_INFO_C); |
| 492 | log_config_set_mask_bit(msg, LOG_GPRS_LLC_PDU_STATS_C); |
| 493 | log_config_set_mask_bit(msg, LOG_GPRS_LLC_PERIODIC_STATS_C); |
| 494 | |
| 495 | log_config_set_mask_bit(msg, LOG_GPRS_SNDCP_UL_TCP_HDR_C); |
| 496 | log_config_set_mask_bit(msg, LOG_GPRS_SNDCP_DL_TCP_HDR_C); |
Harald Welte | 211dd6c | 2016-01-13 00:18:49 +0100 | [diff] [blame] | 497 | log_config_set_mask_bit(msg, 546); |
| 498 | log_config_set_mask_bit(msg, 547); |
Harald Welte | f5d6fee | 2016-01-13 22:29:10 +0100 | [diff] [blame] | 499 | log_config_set_mask_bit(msg, LOG_GPRS_MAC_STATE_C); |
| 500 | log_config_set_mask_bit(msg, LOG_GPRS_MAC_SIGNALLING_MESSAGE_C); |
| 501 | log_config_set_mask_bit(msg, LOG_GPRS_MAC_UL_TBF_ESTABLISH_C); |
| 502 | log_config_set_mask_bit(msg, LOG_GPRS_MAC_DL_TBF_ESTABLISH_C); |
| 503 | log_config_set_mask_bit(msg, LOG_EGPRS_MAC_UL_ACKNACK_C); |
| 504 | log_config_set_mask_bit(msg, LOG_EGPRS_MAC_DL_ACKNACK_C); |
| 505 | log_config_set_mask_bit(msg, LOG_GPRS_MAC_UL_TBF_RELEASE_C); |
| 506 | log_config_set_mask_bit(msg, LOG_GPRS_MAC_DL_TBF_RELEASE_C); |
| 507 | |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 508 | diag_transmit_msgb(di, msg); |
| 509 | do_read(di); |
Harald Welte | f5d6fee | 2016-01-13 22:29:10 +0100 | [diff] [blame] | 510 | |
| 511 | printf("WCDMA\n"); |
| 512 | msg = gen_log_config_set_mask(4, 1064); |
| 513 | #if 0 |
| 514 | for (int i = 0; i < 1064; i++) |
| 515 | log_config_set_mask_bit(msg, i); |
| 516 | #endif |
| 517 | log_config_set_mask_bit(msg, 0x125); |
| 518 | log_config_set_mask_bit(msg, 0x126); |
| 519 | log_config_set_mask_bit(msg, 0x127); |
| 520 | log_config_set_mask_bit(msg, 0x128); |
| 521 | log_config_set_mask_bit(msg, 0x129); |
| 522 | log_config_set_mask_bit(msg, LOG_WCDMA_SIGNALING_MSG_C); |
| 523 | |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 524 | diag_transmit_msgb(di, msg); |
| 525 | do_read(di); |
Harald Welte | f5d6fee | 2016-01-13 22:29:10 +0100 | [diff] [blame] | 526 | |
Harald Welte | e1d8ef9 | 2016-12-22 11:16:33 +0100 | [diff] [blame] | 527 | |
| 528 | printf("Core\n"); |
| 529 | msg = gen_log_config_set_mask(1, 1064); |
| 530 | log_config_set_mask_bit(msg, LOG_QMI_CALL_FLOW_C); |
| 531 | log_config_set_mask_bit(msg, LOG_QMI_SUPPORTED_INTERFACES_C); |
| 532 | for (int i = 0; i < 16*2; i++) |
| 533 | log_config_set_mask_bit(msg, LOG_QMI_RESERVED_CODES_BASE_C+i); |
| 534 | for (int i = LOG_QMI_RESERVED_CODES_BASE_C; i < LOG_QMI_LAST_C; i++) |
| 535 | log_config_set_mask_bit(msg, i); |
| 536 | |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 537 | diag_transmit_msgb(di, msg); |
| 538 | do_read(di); |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 539 | } |
| 540 | |
| 541 | int main(int argc, char **argv) |
| 542 | { |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 543 | struct diag_instance di; |
Harald Welte | 4e06b5c | 2016-12-23 22:56:06 +0100 | [diff] [blame] | 544 | int i; |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 545 | int rc; |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 546 | |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 547 | if (argc < 2) { |
| 548 | printf("Invoke with %s PATH_TO_SERIAL\n", |
| 549 | argv[0]); |
| 550 | return EXIT_FAILURE; |
| 551 | } |
| 552 | |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 553 | memset(&di, 0, sizeof(di)); |
| 554 | di.fd = osmo_serial_init(argv[1], 115200); |
| 555 | if (di.fd < 0) |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 556 | return EXIT_FAILURE; |
| 557 | |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 558 | do_configure(&di); |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 559 | |
Harald Welte | f5d6fee | 2016-01-13 22:29:10 +0100 | [diff] [blame] | 560 | while (1) { |
| 561 | i++; |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 562 | rc = do_read(&di); |
| 563 | if (rc == -EIO) |
| 564 | break; |
Harald Welte | f5d6fee | 2016-01-13 22:29:10 +0100 | [diff] [blame] | 565 | #if 0 |
| 566 | /* some packets need to be explicitly requested and |
| 567 | * don't appear automatically */ |
| 568 | if (i % 10 == 0) { |
| 569 | struct msgb *msg = diag_gsm_make_log_pack_req(LOG_GPRS_LLC_PDU_STATS_C , 0, 0); |
| 570 | printf("Requesting LLC stats...(%s)\n", osmo_hexdump(msgb_data(msg), msgb_length(msg))); |
Harald Welte | 272b4ae | 2016-12-23 23:28:28 +0100 | [diff] [blame^] | 571 | diag_transmit_msgb(&di, msg); |
Harald Welte | f5d6fee | 2016-01-13 22:29:10 +0100 | [diff] [blame] | 572 | } |
| 573 | #endif |
| 574 | |
| 575 | } |
Holger Hans Peter Freyther | ae73a05 | 2013-05-31 09:51:53 +0200 | [diff] [blame] | 576 | } |