diff --git a/openair2/LAYER2/nr_pdcp/nr_pdcp_entity.c b/openair2/LAYER2/nr_pdcp/nr_pdcp_entity.c index 480b651593..d1107bb82f 100644 --- a/openair2/LAYER2/nr_pdcp/nr_pdcp_entity.c +++ b/openair2/LAYER2/nr_pdcp/nr_pdcp_entity.c @@ -59,6 +59,9 @@ static void nr_pdcp_entity_recv_pdu(nr_pdcp_entity_t *entity, We need to investigate why this hack is neccessary. */ buffer[0] |= 128; } + entity->stats.rxpdu_pkts++; + entity->stats.rxpdu_bytes += size; + if (entity->sn_size == 12) { rcvd_sn = ((buffer[0] & 0xf) << 8) | @@ -70,6 +73,7 @@ static void nr_pdcp_entity_recv_pdu(nr_pdcp_entity_t *entity, buffer[2]; header_size = 3; } + entity->stats.rxpdu_sn = rcvd_sn; /* SRBs always have MAC-I, even if integrity is not active */ if (entity->has_integrity || entity->type == NR_PDCP_SRB) { @@ -80,6 +84,11 @@ static void nr_pdcp_entity_recv_pdu(nr_pdcp_entity_t *entity, if (size < header_size + integrity_size + 1) { LOG_E(PDCP, "bad PDU received (size = %d)\n", size); + + entity->stats.rxpdu_dd_pkts++; + entity->stats.rxpdu_dd_bytes += size; + + return; } @@ -109,12 +118,20 @@ static void nr_pdcp_entity_recv_pdu(nr_pdcp_entity_t *entity, if (memcmp(integrity, buffer + size - integrity_size, 4) != 0) { LOG_E(PDCP, "discard NR PDU, integrity failed\n"); // return; + entity->stats.rxpdu_dd_pkts++; + entity->stats.rxpdu_dd_bytes += size; + + } } if (rcvd_count < entity->rx_deliv || nr_pdcp_sdu_in_list(entity->rx_list, rcvd_count)) { LOG_W(PDCP, "discard NR PDU rcvd_count=%d, entity->rx_deliv %d,sdu_in_list %d\n", rcvd_count,entity->rx_deliv,nr_pdcp_sdu_in_list(entity->rx_list,rcvd_count)); + entity->stats.rxpdu_dd_pkts++; + entity->stats.rxpdu_dd_bytes += size; + + return; } @@ -139,6 +156,10 @@ static void nr_pdcp_entity_recv_pdu(nr_pdcp_entity_t *entity, cur->buffer, cur->size); entity->rx_list = cur->next; entity->rx_size -= cur->size; + entity->stats.txsdu_pkts++; + entity->stats.txsdu_bytes += cur->size; + + nr_pdcp_free_sdu(cur); count++; } @@ -165,6 +186,9 @@ static void nr_pdcp_entity_recv_sdu(nr_pdcp_entity_t *entity, int integrity_size; char buf[size + 3 + 4]; int dc_bit; + entity->stats.rxsdu_pkts++; + entity->stats.rxsdu_bytes += size; + count = entity->tx_next; sn = entity->tx_next & entity->sn_max; @@ -215,6 +239,11 @@ static void nr_pdcp_entity_recv_sdu(nr_pdcp_entity_t *entity, entity->deliver_pdu(entity->deliver_pdu_data, entity, buf, header_size + size + integrity_size, sdu_id); + entity->stats.txpdu_pkts++; + entity->stats.txpdu_bytes += header_size + size + integrity_size; + entity->stats.txpdu_sn = sn; + + } /* may be called several times, take care to clean previous settings */ @@ -346,6 +375,13 @@ void nr_pdcp_entity_delete(nr_pdcp_entity_t *entity) free(entity); } +static void nr_pdcp_entity_get_stats(nr_pdcp_entity_t *entity, + nr_pdcp_statistics_t *out) +{ + *out = entity->stats; +} + + nr_pdcp_entity_t *new_nr_pdcp_entity( nr_pdcp_entity_type_t type, int is_gnb, int rb_id, int pdusession_id,int has_sdap, @@ -381,6 +417,7 @@ nr_pdcp_entity_t *new_nr_pdcp_entity( ret->delete_entity = nr_pdcp_entity_delete; + ret->get_stats = nr_pdcp_entity_get_stats; ret->deliver_sdu = deliver_sdu; ret->deliver_sdu_data = deliver_sdu_data; diff --git a/openair2/LAYER2/nr_pdcp/nr_pdcp_entity.h b/openair2/LAYER2/nr_pdcp/nr_pdcp_entity.h index 49e9c4142b..19445887f4 100644 --- a/openair2/LAYER2/nr_pdcp/nr_pdcp_entity.h +++ b/openair2/LAYER2/nr_pdcp/nr_pdcp_entity.h @@ -32,6 +32,39 @@ typedef enum { NR_PDCP_SRB } nr_pdcp_entity_type_t; +typedef struct { + //nr_pdcp_entity_type_t mode; + /* PDU stats */ + /* TX */ + uint32_t txpdu_pkts; /* aggregated number of tx packets */ + uint32_t txpdu_bytes; /* aggregated bytes of tx packets */ + uint32_t txpdu_sn; /* current sequence number of last tx packet (or TX_NEXT) */ + /* RX */ + uint32_t rxpdu_pkts; /* aggregated number of rx packets */ + uint32_t rxpdu_bytes; /* aggregated bytes of rx packets */ + uint32_t rxpdu_sn; /* current sequence number of last rx packet (or RX_NEXT) */ + /* TODO? */ + uint32_t rxpdu_oo_pkts; /* aggregated number of out-of-order rx pkts (or RX_REORD) */ + /* TODO? */ + uint32_t rxpdu_oo_bytes; /* aggregated amount of out-of-order rx bytes */ + uint32_t rxpdu_dd_pkts; /* aggregated number of duplicated discarded packets (or dropped packets because of other reasons such as integrity failure) (or RX_DELIV) */ + uint32_t rxpdu_dd_bytes; /* aggregated amount of discarded packets' bytes */ + /* TODO? */ + uint32_t rxpdu_ro_count; /* this state variable indicates the COUNT value following the COUNT value associated with the PDCP Data PDU which triggered t-Reordering. (RX_REORD) */ + + /* SDU stats */ + /* TX */ + uint32_t txsdu_pkts; /* number of SDUs delivered */ + uint32_t txsdu_bytes; /* number of bytes of SDUs delivered */ + + /* RX */ + uint32_t rxsdu_pkts; /* number of SDUs received */ + uint32_t rxsdu_bytes; /* number of bytes of SDUs received */ + + uint8_t mode; /* 0: PDCP AM, 1: PDCP UM, 2: PDCP TM */ +} nr_pdcp_statistics_t; + + typedef struct nr_pdcp_entity_t { nr_pdcp_entity_type_t type; @@ -40,6 +73,7 @@ typedef struct nr_pdcp_entity_t { void (*recv_sdu)(struct nr_pdcp_entity_t *entity, char *buffer, int size, int sdu_id); void (*delete_entity)(struct nr_pdcp_entity_t *entity); + void (*get_stats)(struct nr_pdcp_entity_t *entity, nr_pdcp_statistics_t *out); /* set_security: pass -1 to integrity_algorithm / ciphering_algorithm * to keep the current algorithm @@ -114,6 +148,7 @@ typedef struct nr_pdcp_entity_t { nr_pdcp_sdu_t *rx_list; int rx_size; int rx_maxsize; + nr_pdcp_statistics_t stats; } nr_pdcp_entity_t; nr_pdcp_entity_t *new_nr_pdcp_entity( diff --git a/openair2/LAYER2/nr_pdcp/nr_pdcp_oai_api.c b/openair2/LAYER2/nr_pdcp/nr_pdcp_oai_api.c index 47c630e0c9..3f9c980710 100644 --- a/openair2/LAYER2/nr_pdcp/nr_pdcp_oai_api.c +++ b/openair2/LAYER2/nr_pdcp/nr_pdcp_oai_api.c @@ -1441,6 +1441,44 @@ void nr_pdcp_tick(int frame, int subframe) /* * For the SDAP API */ -nr_pdcp_ue_manager_t *nr_pdcp_sdap_get_ue_manager(){ - return nr_pdcp_ue_manager; +nr_pdcp_ue_manager_t *nr_pdcp_sdap_get_ue_manager() { + return nr_pdcp_ue_manager; +} + +/* returns 0 in case of error, 1 if everything ok */ +int const nr_pdcp_get_statistics( + int rnti, + int srb_flag, + int rb_id, + nr_pdcp_statistics_t *out) +{ + nr_pdcp_ue_t *ue; + nr_pdcp_entity_t *rb; + int ret; + + nr_pdcp_manager_lock(nr_pdcp_ue_manager); + ue = nr_pdcp_manager_get_ue(nr_pdcp_ue_manager, rnti); + + if (srb_flag == 1) { + if (rb_id < 1 || rb_id > 2) + rb = NULL; + else + rb = ue->srb[rb_id - 1]; + } else { + if (rb_id < 1 || rb_id > 5) + rb = NULL; + else + rb = ue->drb[rb_id - 1]; + } + + if (rb != NULL) { + rb->get_stats(rb, out); + ret = 1; + } else { + ret = 0; + } + + nr_pdcp_manager_unlock(nr_pdcp_ue_manager); + + return ret; }