Exemple #1
0
int
vr_route_get(vr_route_req *req)
{
    struct vr_route_req vr_req;
    struct vrouter *router;
    struct vr_rtable *rtable;
    int ret = 0;
   
    vr_req.rtr_req = *req;
    router = vrouter_get(req->rtr_rid);
    if (!router) {
        ret = -ENOENT;
        goto generate_response;
    } else {

        rtable = vr_get_inet_table(router, req->rtr_rt_type);
        if (!rtable) {
            ret = -ENOENT;
            goto generate_response;
        }

        ret = rtable->algo_get(vr_req.rtr_req.rtr_vrf_id, &vr_req);
    }

generate_response:
    vr_message_response(VR_ROUTE_OBJECT_ID, ret ? NULL : &vr_req, ret);
    return ret;
}
int
vr_mpls_get(vr_mpls_req *req)
{
    int ret = 0;
    struct vr_nexthop *nh = NULL;
    struct vrouter *router;

    router = vrouter_get(req->mr_rid);
    if (!router || req->mr_label > (int)router->vr_max_labels) {
        ret = -ENODEV;
    } else {
        nh = vrouter_get_label(req->mr_rid, req->mr_label);
        if (!nh)
            ret = -ENOENT;
    }

    if (!ret)
        vr_mpls_make_req(req, nh, req->mr_label);
    else
        req = NULL;

    vr_message_response(VR_MPLS_OBJECT_ID, req, ret);

    return 0;
}
static void
vr_drop_stats_get(unsigned int core)
{
    int ret = 0;
    unsigned int cpu;
    struct vrouter *router = vrouter_get(0);
    vr_drop_stats_req *response = NULL;

    if (!router && (ret = -ENOENT))
        goto exit_get;

    response = vr_zalloc(sizeof(*response), VR_DROP_STATS_REQ_OBJECT);
    if (!response && (ret = -ENOMEM))
        goto exit_get;

    if (core == (unsigned)-1) {
        /* summed up stats */
        for (cpu = 0; cpu < vr_num_cpus; cpu++) {
            vr_drop_stats_add_response(response, router->vr_pdrop_stats[cpu]);
        }
    } else if (core < vr_num_cpus) {
        /* stats for a specific core */
        vr_drop_stats_add_response(response, router->vr_pdrop_stats[core]);
    }
    /* otherwise the counters will be zeros */

exit_get:
    vr_message_response(VR_DROP_STATS_OBJECT_ID, ret ? NULL : response, ret);

    if (response != NULL)
        vr_free(response, VR_DROP_STATS_REQ_OBJECT);

    return;
}
Exemple #4
0
/*
 * sandesh handler for vr_flow_req
 */
void
vr_flow_req_process(void *s_req)
{
    int ret = 0;
    struct vrouter *router;
    vr_flow_req *req = (vr_flow_req *)s_req;

    router = vrouter_get(req->fr_rid);
    switch (req->fr_op) {
    case FLOW_OP_FLOW_TABLE_GET:
        req->fr_ftable_size = vr_flow_table_size(router) +
            vr_oflow_table_size(router);
#ifdef __KERNEL__
        req->fr_ftable_dev = vr_flow_major;
#endif
        break;

    case FLOW_OP_FLOW_SET:
        ret = vr_flow_set(router, req);
        break;

    default:
        ret = -EINVAL;
    }

    vr_message_response(VR_FLOW_OBJECT_ID, req, ret);
    return;
}
Exemple #5
0
int
vr_mpls_get(vr_mpls_req *req)
{
    int ret = 0;
    struct vr_nexthop *nh = NULL;
    struct vrouter *router;

    router = vrouter_get(req->mr_rid);
    if (!router) {
        ret = -ENODEV;
        goto generate_response;
    }

    if (((unsigned int)req->mr_label >= router->vr_max_labels)) {
        ret = -EINVAL;
        goto generate_response;
    }

    nh = vrouter_get_label(req->mr_rid, req->mr_label);
    if (!nh) {
        ret = -ENOENT;
        goto generate_response;
    }

    vr_mpls_make_req(req, nh, req->mr_label);

generate_response:
    if (ret)
        req = NULL;

    vr_message_response(VR_MPLS_OBJECT_ID, req, ret);

    return 0;
}
int
vr_send_broadcast(unsigned int object_type, void *object, unsigned int sandesh_op, int code)
{
    if (!vr_nl_broadcast_supported)
      return 0;
    // We only broadcast requests that have succeeded
    if (code >= 0)
        return vr_message_response(object_type, object, code, true);
    return code;
}
Exemple #7
0
static void
vr_fc_map_get(vr_fc_map_req *req)
{
    int ret = 0;

    vr_fc_map_req *resp = NULL;
    struct vrouter *router = vrouter_get(req->fmr_rid);
    struct vr_forwarding_class *fc_p;

    if (!req->fmr_id) {
        ret = -EINVAL;
        goto generate_response;
    }

    if (req->fmr_id[0] >= vr_fc_map_entries) {
        ret = -EINVAL;
        goto generate_response;
    }

    fc_p = vr_fc_map_get_fc(router, req->fmr_id[0]);
    if (!fc_p || !fc_p->vfc_valid) {
        ret = -ENOENT;
        goto generate_response;
    }

    resp = vr_fc_map_req_get(1);
    if (!resp) {
        ret = -ENOMEM;
        goto generate_response;
    }

    resp->fmr_id[0] = req->fmr_id[0];
    resp->fmr_dscp[0] = fc_p->vfc_dscp;
    resp->fmr_mpls_qos[0] = fc_p->vfc_mpls_qos;
    resp->fmr_dotonep[0] = fc_p->vfc_dotonep_qos;
    resp->fmr_queue_id[0] = fc_p->vfc_queue_id;

    /* Debug comparison to check if matching entry is programmed on NIC */
    (void)vr_offload_fc_map_get(resp);

generate_response:
    vr_message_response(VR_FC_MAP_OBJECT_ID, ret < 0 ? NULL : resp, ret, false);
    if (resp)
        vr_fc_map_req_destroy(resp);

    return;
}
Exemple #8
0
void
vr_bridge_table_data_process(void *s_req)
{
    int ret = 0;
    struct vrouter *router;
    vr_bridge_table_data *resp = NULL, *req = (vr_bridge_table_data *)s_req;

    router = vrouter_get(req->btable_rid);
    if (!router) {
        ret = -EINVAL;
        goto generate_response;
    }

    resp = vr_bridge_table_data_get();
    if (!resp) {
        ret = -ENOMEM;
        goto generate_response;
    }

    resp->btable_op = req->btable_op;
    switch (req->btable_op) {
    case SANDESH_OP_GET:
        resp->btable_size = vr_bridge_table_size(router);
#if defined(__linux__) && defined(__KERNEL__)
        resp->btable_dev = vr_bridge_table_major;
#endif
        if (vr_bridge_table_path) {
            strncpy(resp->btable_file_path, vr_bridge_table_path,
                    VR_UNIX_PATH_MAX - 1);
        }
        break;

    default:
        ret = -EINVAL;
        break;
    }

generate_response:
    vr_message_response(VR_BRIDGE_TABLE_DATA_OBJECT_ID, resp, ret);
    if (resp) {
        vr_bridge_table_data_destroy(resp);
        resp = NULL;
    }

    return;
}
Exemple #9
0
static void
vr_qos_map_get(vr_qos_map_req *req)
{
    int ret = 0;

    vr_qos_map_req *resp;
    struct vrouter *router = vrouter_get(req->qmr_rid);
    struct vr_forwarding_class *fc_p = NULL;

    if (req->qmr_id >= vr_qos_map_entries) {
        ret = -EINVAL;
        goto get_error;
    }

    fc_p = vr_qos_map_get_fc(router, req->qmr_id);
    if (!fc_p) {
        ret = -ENOENT;
        goto get_error;
    }

    resp = vr_qos_map_req_get();
    if (!resp) {
        ret = -ENOMEM;
        goto get_error;
    }

    vr_qos_map_make_req(req->qmr_id, resp, fc_p);

    /* Debug comparison to check if matching entry is programmed on NIC */
    (void)vr_offload_qos_map_get(resp);

    vr_message_response(VR_QOS_MAP_OBJECT_ID, resp, ret, false);
    if (resp) {
        vr_qos_map_req_destroy(resp);
    }

    return;

get_error:
    vr_send_response(ret);
    return;
}
Exemple #10
0
int
vr_route_get(vr_route_req *req)
{
    struct vr_route_req vr_req;
    struct vrouter *router;
    int ret = 0;
    uint32_t rt_prefix[4];
	struct vr_rtable *rtable;

    vr_req.rtr_req = *req;

    vr_req.rtr_req.rtr_marker_size = 0;
    vr_req.rtr_req.rtr_prefix_size = req->rtr_prefix_size;
    if (req->rtr_prefix_size) {
        vr_req.rtr_req.rtr_prefix = (uint8_t*)&rt_prefix;
        memcpy(vr_req.rtr_req.rtr_prefix, req->rtr_prefix, RT_IP_ADDR_SIZE(req->rtr_family));
    } else
        vr_req.rtr_req.rtr_prefix = NULL;

    router = vrouter_get(req->rtr_rid);
    if (!router) {
        ret = -ENOENT;
        goto generate_response;
    } else {

        rtable = router->vr_inet_rtable;
        if (!rtable) {
            ret = -ENOENT;
            goto generate_response;
        }

        ret = rtable->algo_get(vr_req.rtr_req.rtr_vrf_id, &vr_req);
    }

generate_response:
    vr_message_response(VR_ROUTE_OBJECT_ID, ret ? NULL : &vr_req, ret);
    return ret;
}
Exemple #11
0
static void
vr_inet_vrf_stats_get(struct vrouter *router, vr_vrf_stats_req *req)
{
    int ret = 0;
    struct vr_rtable *rtable;
    vr_vrf_stats_req response;

    rtable = router->vr_inet_rtable;
    if (!rtable) {
        ret = -ENOENT;
        goto generate_error;
    }

    if (req->vsr_vrf >= 0 &&
            (unsigned int)req->vsr_vrf >= rtable->algo_max_vrfs) {
        ret = -EINVAL;
        goto generate_error;
    }

    ret = rtable->algo_stats_get(req, &response);
generate_error:
    vr_message_response(VR_VRF_STATS_OBJECT_ID, ret ? NULL : &response, ret);
    return;
}
Exemple #12
0
static int
vr_mirror_get(vr_mirror_req *req)
{
    int ret = 0;
    struct vrouter *router;
    struct vr_mirror_entry *mirror = NULL;

    router = vrouter_get(req->mirr_rid);
    if (!router ||
            (unsigned int)req->mirr_index >= router->vr_max_mirror_indices) {
        ret = -ENODEV;
    } else {
        mirror = router->vr_mirrors[req->mirr_index];
        if (!mirror)
            ret = -ENOENT;
    }

    if (mirror) {
        vr_mirror_make_req(req, mirror, req->mirr_index);
    } else
        req = NULL;

    return vr_message_response(VR_MIRROR_OBJECT_ID, req, ret, false);
}
Exemple #13
0
int
vr_send_response(int code)
{
    return vr_message_response(VR_NULL_OBJECT_ID, NULL, code);
}
Exemple #14
0
static void
vr_drop_stats_get(unsigned int core)
{
    int ret = 0;
    unsigned int cpu;
    struct vrouter *router = vrouter_get(0);
    vr_drop_stats_req *response = NULL;
    struct vr_drop_stats *stats_block, *stats = NULL;

    if (!router && (ret = -ENOENT))
        goto exit_get;

    stats = vr_zalloc(sizeof(*stats));
    if (!stats && (ret = -ENOMEM))
        goto exit_get;

    response = vr_zalloc(sizeof(*response));
    if (!response && (ret = -ENOMEM))
        goto exit_get;

    if (core == 0) { /* user or agent wants summed up stats */
        for (cpu = 0; cpu < vr_num_cpus; cpu++) {
            stats_block = (struct vr_drop_stats *)router->vr_pdrop_stats[cpu];
            stats->vds_discard += stats_block->vds_discard;
            stats->vds_pull += stats_block->vds_pull;
            stats->vds_invalid_if += stats_block->vds_invalid_if;
            stats->vds_arp_no_where_to_go +=
                stats_block->vds_arp_no_where_to_go;
            stats->vds_garp_from_vm += stats_block->vds_garp_from_vm;
            stats->vds_invalid_arp += stats_block->vds_invalid_arp;
            stats->vds_trap_no_if += stats_block->vds_trap_no_if;
            stats->vds_nowhere_to_go += stats_block->vds_nowhere_to_go;
            stats->vds_flow_queue_limit_exceeded +=
                stats_block->vds_flow_queue_limit_exceeded;
            stats->vds_flow_no_memory += stats_block->vds_flow_no_memory;
            stats->vds_flow_invalid_protocol +=
                stats_block->vds_flow_invalid_protocol;
            stats->vds_flow_nat_no_rflow += stats_block->vds_flow_nat_no_rflow;
            stats->vds_flow_action_drop += stats_block->vds_flow_action_drop;
            stats->vds_flow_action_invalid += stats_block->vds_flow_action_invalid;
            stats->vds_flow_unusable += stats_block->vds_flow_unusable;
            stats->vds_flow_table_full += stats_block->vds_flow_table_full;
            stats->vds_interface_tx_discard += stats_block->vds_interface_tx_discard;
            stats->vds_interface_drop += stats_block->vds_interface_drop;
            stats->vds_duplicated += stats_block->vds_duplicated;
            stats->vds_push += stats_block->vds_push;
            stats->vds_ttl_exceeded += stats_block->vds_ttl_exceeded;
            stats->vds_invalid_nh += stats_block->vds_invalid_nh;
            stats->vds_invalid_label += stats_block->vds_invalid_label;
            stats->vds_invalid_protocol += stats_block->vds_invalid_protocol;
            stats->vds_interface_rx_discard += stats_block->vds_interface_rx_discard;
            stats->vds_invalid_mcast_source += stats_block->vds_invalid_mcast_source;
            stats->vds_head_alloc_fail += stats_block->vds_head_alloc_fail;
            stats->vds_head_space_reserve_fail += stats_block->vds_head_space_reserve_fail;
            stats->vds_pcow_fail += stats_block->vds_pcow_fail;
            stats->vds_mcast_df_bit += stats_block->vds_mcast_df_bit;
            stats->vds_mcast_clone_fail += stats_block->vds_mcast_clone_fail;
            stats->vds_composite_invalid_interface +=
                stats_block->vds_composite_invalid_interface;
            stats->vds_rewrite_fail += stats_block->vds_rewrite_fail;
            stats->vds_misc += stats_block->vds_misc;
            stats->vds_invalid_packet += stats_block->vds_invalid_packet;
            stats->vds_cksum_err += stats_block->vds_cksum_err;
            stats->vds_clone_fail += stats_block->vds_clone_fail;
            stats->vds_no_fmd += stats_block->vds_no_fmd;
            stats->vds_cloned_original += stats_block->vds_cloned_original;
            stats->vds_invalid_vnid += stats_block->vds_invalid_vnid;
            stats->vds_frag_err += stats_block->vds_frag_err;
            stats->vds_invalid_source += stats_block->vds_invalid_source;
            stats->vds_arp_no_route += stats_block->vds_arp_no_route;
            stats->vds_l2_no_route += stats_block->vds_l2_no_route;
            stats->vds_arp_reply_no_route +=
                stats_block->vds_arp_reply_no_route;
        }
    } else if (core > 0) {
        /**
         * What user really asks for is real_core = core - 1.
         * If a request came for stats for 1st core, it means user
         * asked for 0th core. If request was made for 2nd, user wanted
         * the 1st, and so on.
         *
         * TODO: This would be much simplier if agent could explicitly ask
         * for stats for 'minus 1st' core, meaning 'all the cores'.
         */
        stats_block = (struct vr_drop_stats *)router->vr_pdrop_stats[core - 1];
        stats->vds_discard = stats_block->vds_discard;
        stats->vds_pull = stats_block->vds_pull;
        stats->vds_invalid_if = stats_block->vds_invalid_if;
        stats->vds_arp_no_where_to_go =
            stats_block->vds_arp_no_where_to_go;
        stats->vds_garp_from_vm = stats_block->vds_garp_from_vm;
        stats->vds_invalid_arp = stats_block->vds_invalid_arp;
        stats->vds_trap_no_if = stats_block->vds_trap_no_if;
        stats->vds_nowhere_to_go = stats_block->vds_nowhere_to_go;
        stats->vds_flow_queue_limit_exceeded =
            stats_block->vds_flow_queue_limit_exceeded;
        stats->vds_flow_no_memory = stats_block->vds_flow_no_memory;
        stats->vds_flow_invalid_protocol =
            stats_block->vds_flow_invalid_protocol;
        stats->vds_flow_nat_no_rflow = stats_block->vds_flow_nat_no_rflow;
        stats->vds_flow_action_drop = stats_block->vds_flow_action_drop;
        stats->vds_flow_action_invalid = stats_block->vds_flow_action_invalid;
        stats->vds_flow_unusable = stats_block->vds_flow_unusable;
        stats->vds_flow_table_full = stats_block->vds_flow_table_full;
        stats->vds_interface_tx_discard = stats_block->vds_interface_tx_discard;
        stats->vds_interface_drop = stats_block->vds_interface_drop;
        stats->vds_duplicated = stats_block->vds_duplicated;
        stats->vds_push = stats_block->vds_push;
        stats->vds_ttl_exceeded = stats_block->vds_ttl_exceeded;
        stats->vds_invalid_nh = stats_block->vds_invalid_nh;
        stats->vds_invalid_label = stats_block->vds_invalid_label;
        stats->vds_invalid_protocol = stats_block->vds_invalid_protocol;
        stats->vds_interface_rx_discard = stats_block->vds_interface_rx_discard;
        stats->vds_invalid_mcast_source = stats_block->vds_invalid_mcast_source;
        stats->vds_head_alloc_fail = stats_block->vds_head_alloc_fail;
        stats->vds_head_space_reserve_fail = stats_block->vds_head_space_reserve_fail;
        stats->vds_pcow_fail = stats_block->vds_pcow_fail;
        stats->vds_mcast_df_bit = stats_block->vds_mcast_df_bit;
        stats->vds_mcast_clone_fail = stats_block->vds_mcast_clone_fail;
        stats->vds_composite_invalid_interface =
            stats_block->vds_composite_invalid_interface;
        stats->vds_rewrite_fail = stats_block->vds_rewrite_fail;
        stats->vds_misc = stats_block->vds_misc;
        stats->vds_invalid_packet = stats_block->vds_invalid_packet;
        stats->vds_cksum_err = stats_block->vds_cksum_err;
        stats->vds_clone_fail = stats_block->vds_clone_fail;
        stats->vds_no_fmd = stats_block->vds_no_fmd;
        stats->vds_cloned_original = stats_block->vds_cloned_original;
        stats->vds_invalid_vnid = stats_block->vds_invalid_vnid;
        stats->vds_frag_err = stats_block->vds_frag_err;
        stats->vds_invalid_source = stats_block->vds_invalid_source;
        stats->vds_arp_no_route = stats_block->vds_arp_no_route;
        stats->vds_l2_no_route = stats_block->vds_l2_no_route;
        stats->vds_arp_reply_no_route =
            stats_block->vds_arp_reply_no_route;
    }

    vr_drop_stats_fill_response(response, stats);

exit_get:
    vr_message_response(VR_DROP_STATS_OBJECT_ID, ret ? NULL : response, ret);
    if (stats != NULL)
        vr_free(stats);

    if (response != NULL)
        vr_free(response);

    return;
}
static void
vr_mem_stats_get(void)
{
    int ret = 0;
    unsigned int cpu, i;
    int64_t alloced = 0, freed = 0;

    struct vrouter *router = vrouter_get(0);
    struct vr_malloc_stats *stats_block;
    vr_mem_stats_req *response = NULL;

    if (!router && (ret = -ENOENT))
        goto exit_get;

    response = vr_zalloc(sizeof(*response), VR_MEM_STATS_REQ_OBJECT);
    if (!response && (ret = -ENOMEM))
        goto exit_get;


    for (cpu = 0; cpu < vr_num_cpus; cpu++) {
        stats_block = (struct vr_malloc_stats *)router->vr_malloc_stats[cpu];
        response->vms_assembler_table_object += (stats_block[VR_ASSEMBLER_TABLE_OBJECT].ms_alloc -
                stats_block[VR_ASSEMBLER_TABLE_OBJECT].ms_free);
        response->vms_bridge_mac_object += (stats_block[VR_BRIDGE_MAC_OBJECT].ms_alloc -
                stats_block[VR_BRIDGE_MAC_OBJECT].ms_free);
        response->vms_btable_object += (stats_block[VR_BTABLE_OBJECT].ms_alloc -
                stats_block[VR_BTABLE_OBJECT].ms_free);
        response->vms_build_info_object += (stats_block[VR_BUILD_INFO_OBJECT].ms_alloc -
                stats_block[VR_BUILD_INFO_OBJECT].ms_free);
        response->vms_defer_object += (stats_block[VR_DEFER_OBJECT].ms_alloc -
                stats_block[VR_DEFER_OBJECT].ms_free);
        response->vms_drop_stats_object += (stats_block[VR_DROP_STATS_OBJECT].ms_alloc -
                stats_block[VR_DROP_STATS_OBJECT].ms_free);
        response->vms_drop_stats_req_object += (stats_block[VR_DROP_STATS_REQ_OBJECT].ms_alloc -
                stats_block[VR_DROP_STATS_REQ_OBJECT].ms_free);
        response->vms_flow_queue_object += (stats_block[VR_FLOW_QUEUE_OBJECT].ms_alloc -
                stats_block[VR_FLOW_QUEUE_OBJECT].ms_free);
        response->vms_flow_req_object += (stats_block[VR_FLOW_REQ_OBJECT].ms_alloc -
                stats_block[VR_FLOW_REQ_OBJECT].ms_free);
        response->vms_flow_req_path_object += (stats_block[VR_FLOW_REQ_PATH_OBJECT].ms_alloc -
                stats_block[VR_FLOW_REQ_PATH_OBJECT].ms_free);
        response->vms_flow_hold_stat_object += (stats_block[VR_FLOW_HOLD_STAT_OBJECT].ms_alloc -
                stats_block[VR_FLOW_HOLD_STAT_OBJECT].ms_free);
        response->vms_flow_link_local_object += (stats_block[VR_FLOW_LINK_LOCAL_OBJECT].ms_alloc -
                stats_block[VR_FLOW_LINK_LOCAL_OBJECT].ms_free);
        response->vms_flow_metadata_object += (stats_block[VR_FLOW_METADATA_OBJECT].ms_alloc -
                stats_block[VR_FLOW_METADATA_OBJECT].ms_free);
        response->vms_flow_table_info_object += (stats_block[VR_FLOW_TABLE_INFO_OBJECT].ms_alloc -
                stats_block[VR_FLOW_TABLE_INFO_OBJECT].ms_free);
        response->vms_fragment_object += (stats_block[VR_FRAGMENT_OBJECT].ms_alloc -
                stats_block[VR_FRAGMENT_OBJECT].ms_free);
        response->vms_fragment_queue_object += (stats_block[VR_FRAGMENT_QUEUE_OBJECT].ms_alloc -
                stats_block[VR_FRAGMENT_QUEUE_OBJECT].ms_free);
        response->vms_fragment_queue_element_object += (stats_block[VR_FRAGMENT_QUEUE_ELEMENT_OBJECT].ms_alloc -
                stats_block[VR_FRAGMENT_QUEUE_ELEMENT_OBJECT].ms_free);
        response->vms_fragment_scanner_object += (stats_block[VR_FRAGMENT_SCANNER_OBJECT].ms_alloc -
                stats_block[VR_FRAGMENT_SCANNER_OBJECT].ms_free);
        response->vms_hpacket_pool_object += (stats_block[VR_HPACKET_POOL_OBJECT].ms_alloc -
                stats_block[VR_HPACKET_POOL_OBJECT].ms_free);
        response->vms_htable_object += (stats_block[VR_HTABLE_OBJECT].ms_alloc -
                stats_block[VR_HTABLE_OBJECT].ms_free);
        response->vms_interface_object += (stats_block[VR_INTERFACE_OBJECT].ms_alloc -
                stats_block[VR_INTERFACE_OBJECT].ms_free);
        response->vms_interface_mac_object += (stats_block[VR_INTERFACE_MAC_OBJECT].ms_alloc -
                stats_block[VR_INTERFACE_MAC_OBJECT].ms_free);
        response->vms_interface_req_object += (stats_block[VR_INTERFACE_REQ_OBJECT].ms_alloc -
                stats_block[VR_INTERFACE_REQ_OBJECT].ms_free);
        response->vms_interface_req_mac_object += (stats_block[VR_INTERFACE_REQ_MAC_OBJECT].ms_alloc -
                stats_block[VR_INTERFACE_REQ_MAC_OBJECT].ms_free);
        response->vms_interface_req_name_object += (stats_block[VR_INTERFACE_REQ_NAME_OBJECT].ms_alloc -
                stats_block[VR_INTERFACE_REQ_NAME_OBJECT].ms_free);
        response->vms_interface_stats_object += (stats_block[VR_INTERFACE_STATS_OBJECT].ms_alloc -
                stats_block[VR_INTERFACE_STATS_OBJECT].ms_free);
        response->vms_interface_table_object += (stats_block[VR_INTERFACE_TABLE_OBJECT].ms_alloc -
                stats_block[VR_INTERFACE_TABLE_OBJECT].ms_free);
        response->vms_interface_vrf_table_object += (stats_block[VR_INTERFACE_VRF_TABLE_OBJECT].ms_alloc -
                stats_block[VR_INTERFACE_VRF_TABLE_OBJECT].ms_free);
        response->vms_itable_object += (stats_block[VR_ITABLE_OBJECT].ms_alloc -
                stats_block[VR_ITABLE_OBJECT].ms_free);
        response->vms_malloc_object += (stats_block[VR_MALLOC_OBJECT].ms_alloc -
                stats_block[VR_MALLOC_OBJECT].ms_free);
        response->vms_message_object += (stats_block[VR_MESSAGE_OBJECT].ms_alloc -
                stats_block[VR_MESSAGE_OBJECT].ms_free);
        response->vms_message_response_object += (stats_block[VR_MESSAGE_RESPONSE_OBJECT].ms_alloc -
                stats_block[VR_MESSAGE_RESPONSE_OBJECT].ms_free);
        response->vms_message_dump_object += (stats_block[VR_MESSAGE_DUMP_OBJECT].ms_alloc -
                stats_block[VR_MESSAGE_DUMP_OBJECT].ms_free);
        response->vms_mem_stats_req_object += (stats_block[VR_MEM_STATS_REQ_OBJECT].ms_alloc -
                stats_block[VR_MEM_STATS_REQ_OBJECT].ms_free);
        response->vms_mirror_object += (stats_block[VR_MIRROR_OBJECT].ms_alloc -
                stats_block[VR_MIRROR_OBJECT].ms_free);
        response->vms_mirror_table_object += (stats_block[VR_MIRROR_TABLE_OBJECT].ms_alloc -
                stats_block[VR_MIRROR_TABLE_OBJECT].ms_free);
        response->vms_mirror_meta_object += (stats_block[VR_MIRROR_META_OBJECT].ms_alloc -
                stats_block[VR_MIRROR_META_OBJECT].ms_free);
        response->vms_mtrie_object += (stats_block[VR_MTRIE_OBJECT].ms_alloc -
                stats_block[VR_MTRIE_OBJECT].ms_free);
        response->vms_mtrie_bucket_object += (stats_block[VR_MTRIE_BUCKET_OBJECT].ms_alloc -
                stats_block[VR_MTRIE_BUCKET_OBJECT].ms_free);
        response->vms_mtrie_stats_object += (stats_block[VR_MTRIE_STATS_OBJECT].ms_alloc -
                stats_block[VR_MTRIE_STATS_OBJECT].ms_free);
        response->vms_mtrie_table_object += (stats_block[VR_MTRIE_TABLE_OBJECT].ms_alloc -
                stats_block[VR_MTRIE_TABLE_OBJECT].ms_free);
        response->vms_nexthop_object += (stats_block[VR_NEXTHOP_OBJECT].ms_alloc -
                stats_block[VR_NEXTHOP_OBJECT].ms_free);
        response->vms_nexthop_component_object += (stats_block[VR_NEXTHOP_COMPONENT_OBJECT].ms_alloc -
                stats_block[VR_NEXTHOP_COMPONENT_OBJECT].ms_free);
        response->vms_nexthop_req_list_object += (stats_block[VR_NEXTHOP_REQ_LIST_OBJECT].ms_alloc -
                stats_block[VR_NEXTHOP_REQ_LIST_OBJECT].ms_free);
        response->vms_nexthop_req_encap_object += (stats_block[VR_NEXTHOP_REQ_ENCAP_OBJECT].ms_alloc -
                stats_block[VR_NEXTHOP_REQ_ENCAP_OBJECT].ms_free);
        response->vms_nexthop_req_object += (stats_block[VR_NEXTHOP_REQ_OBJECT].ms_alloc -
                stats_block[VR_NEXTHOP_REQ_OBJECT].ms_free);
        response->vms_route_table_object += (stats_block[VR_ROUTE_TABLE_OBJECT].ms_alloc -
                stats_block[VR_ROUTE_TABLE_OBJECT].ms_free);
        response->vms_route_req_mac_object += (stats_block[VR_ROUTE_REQ_MAC_OBJECT].ms_alloc -
                stats_block[VR_ROUTE_REQ_MAC_OBJECT].ms_free);
        response->vms_timer_object += (stats_block[VR_TIMER_OBJECT].ms_alloc -
                stats_block[VR_TIMER_OBJECT].ms_free);
        response->vms_usock_object += (stats_block[VR_USOCK_OBJECT].ms_alloc -
                stats_block[VR_USOCK_OBJECT].ms_free);
        response->vms_usock_poll_object += (stats_block[VR_USOCK_POLL_OBJECT].ms_alloc -
                stats_block[VR_USOCK_POLL_OBJECT].ms_free);
        response->vms_usock_buf_object += (stats_block[VR_USOCK_BUF_OBJECT].ms_alloc -
                stats_block[VR_USOCK_BUF_OBJECT].ms_free);
        response->vms_usock_iovec_object += (stats_block[VR_USOCK_IOVEC_OBJECT].ms_alloc -
                stats_block[VR_USOCK_IOVEC_OBJECT].ms_free);
        response->vms_vrouter_req_object += (stats_block[VR_VROUTER_REQ_OBJECT].ms_alloc -
                stats_block[VR_VROUTER_REQ_OBJECT].ms_free);
        for (i = 0; i < VR_VROUTER_MAX_OBJECT; i++) {
            alloced += stats_block[i].ms_alloc;
            freed += stats_block[i].ms_free;
        }
    }


    response->vms_alloced = alloced;
    response->vms_freed = freed;

exit_get:
    vr_message_response(VR_MEM_STATS_OBJECT_ID, ret ? NULL : response, ret);
    if (response != NULL)
        vr_free(response, VR_MEM_STATS_REQ_OBJECT);

    return;
}