Lines Matching defs:hca
99 rib_hca_t *hca;
119 static int rib_find_hca_connection(rib_hca_t *hca, struct netbuf *s_svcaddr,
277 static rdma_stat rib_registermem_via_hca(rib_hca_t *hca, caddr_t adsp,
279 static rdma_stat rib_deregistermem_via_hca(rib_hca_t *hca, caddr_t buf,
314 static void rib_destroy_cache(rib_hca_t *hca);
371 static rib_bufpool_t *rib_rbufpool_create(rib_hca_t *hca, int ptype, int num);
505 rib_hca_t *hca, *hcap;
508 hca = rib_stat->hcas_list;
511 while (hca != NULL) {
512 rw_enter(&hca->state_lock, RW_WRITER);
513 hcap = hca;
514 hca = hca->next;
681 * Detach the hca and free resources
710 static void rib_rbufpool_destroy(rib_hca_t *hca, int ptype);
722 rib_create_cq(rib_hca_t *hca, uint32_t cq_size, ibt_cq_handler_t cq_handler,
732 cq->rib_hca = hca;
736 status = ibt_alloc_cq(hca->hca_hdl, &cq_attr, &cq->rib_cq_hdl,
744 ibt_set_cq_handler(cq->rib_cq_hdl, cq_handler, hca);
778 rib_hca_t *hca = ribstat->hcas_list;
780 while (hca && hca->hca_guid != guid)
781 hca = hca->next;
783 return (hca);
789 rib_hca_t *hca;
810 * Open a hca and setup for RDMA
815 hca = kmem_zalloc(sizeof (rib_hca_t), KM_SLEEP);
818 hca_guids[i], &hca->hca_hdl);
820 kmem_free(hca, sizeof (rib_hca_t));
823 hca->hca_guid = hca_guids[i];
824 hca->ibt_clnt_hdl = ribstat->ibt_clnt_hdl;
825 hca->state = HCA_INITED;
830 ibt_status = ibt_query_hca(hca->hca_hdl, &hca->hca_attrs);
841 ibt_status = ibt_alloc_pd(hca->hca_hdl, pd_flags, &hca->pd_hdl);
849 ibt_status = ibt_query_hca_ports(hca->hca_hdl,
850 0, &pinfop, &hca->hca_nports, &size);
854 hca->hca_ports = pinfop;
855 hca->hca_pinfosz = size;
861 * and the other pair for server) on this hca.
865 status = rib_create_cq(hca, cq_size, rib_svc_rcq_handler,
866 &hca->svc_rcq);
871 status = rib_create_cq(hca, cq_size, rib_svc_scq_handler,
872 &hca->svc_scq);
877 status = rib_create_cq(hca, cq_size, rib_clnt_rcq_handler,
878 &hca->clnt_rcq);
883 status = rib_create_cq(hca, cq_size, rib_clnt_scq_handler,
884 &hca->clnt_scq);
893 hca->recv_pool = rib_rbufpool_create(hca,
895 if (hca->recv_pool == NULL) {
899 hca->send_pool = rib_rbufpool_create(hca,
901 if (hca->send_pool == NULL) {
902 rib_rbufpool_destroy(hca, RECV_BUFFER);
906 if (hca->server_side_cache == NULL) {
909 (long long unsigned int) hca->hca_guid);
910 hca->server_side_cache = kmem_cache_create(
916 hca, NULL, 0);
919 avl_create(&hca->avl_tree,
925 rw_init(&hca->bound_services_lock, NULL, RW_DRIVER,
926 hca->iblock);
927 rw_init(&hca->state_lock, NULL, RW_DRIVER, hca->iblock);
928 rw_init(&hca->avl_rw_lock,
929 NULL, RW_DRIVER, hca->iblock);
930 mutex_init(&hca->cache_allocation_lock,
932 hca->avl_init = TRUE;
950 if (hca->cleanup_helper == NULL) {
951 char tq_name[sizeof (hca->hca_guid) * 2 + 1];
954 (unsigned long long int) hca->hca_guid);
955 hca->cleanup_helper = ddi_taskq_create(NULL,
959 mutex_init(&hca->cb_lock, NULL, MUTEX_DRIVER, hca->iblock);
960 cv_init(&hca->cb_cv, NULL, CV_DRIVER, NULL);
961 rw_init(&hca->cl_conn_list.conn_lock, NULL, RW_DRIVER,
962 hca->iblock);
963 rw_init(&hca->srv_conn_list.conn_lock, NULL, RW_DRIVER,
964 hca->iblock);
965 mutex_init(&hca->inuse_lock, NULL, MUTEX_DRIVER, hca->iblock);
966 hca->inuse = TRUE;
968 hca->next = ribstat->hcas_list;
969 ribstat->hcas_list = hca;
971 ibt_free_portinfo(hca->hca_ports, hca->hca_pinfosz);
975 ibt_free_portinfo(hca->hca_ports, hca->hca_pinfosz);
977 (void) ibt_free_pd(hca->hca_hdl, hca->pd_hdl);
979 (void) ibt_close_hca(hca->hca_hdl);
980 kmem_free(hca, sizeof (rib_hca_t));
987 * return success if at least one new hca has been configured.
1552 *handle = (void *)rpt.hca;
1565 rib_clnt_create_chan(rib_hca_t *hca, struct netbuf *raddr, rib_qp_t **qp)
1576 kqp->hca = hca;
1590 mutex_init(&kqp->posted_rbufs_lock, NULL, MUTEX_DRIVER, hca->iblock);
1592 mutex_init(&kqp->send_rbufs_lock, NULL, MUTEX_DRIVER, hca->iblock);
1593 mutex_init(&kqp->replylist_lock, NULL, MUTEX_DRIVER, hca->iblock);
1594 mutex_init(&kqp->rdlist_lock, NULL, MUTEX_DEFAULT, hca->iblock);
1595 mutex_init(&kqp->cb_lock, NULL, MUTEX_DRIVER, hca->iblock);
1597 mutex_init(&kqp->rdmaconn.c_lock, NULL, MUTEX_DRIVER, hca->iblock);
1614 rib_svc_create_chan(rib_hca_t *hca, caddr_t q, uint8_t port, rib_qp_t **qp)
1625 kqp->hca = hca;
1634 qp_attr.rc_scq = hca->svc_scq->rib_cq_hdl;
1635 qp_attr.rc_rcq = hca->svc_rcq->rib_cq_hdl;
1636 qp_attr.rc_pd = hca->pd_hdl;
1646 rw_enter(&hca->state_lock, RW_READER);
1647 if (hca->state != HCA_DETACHED) {
1648 ibt_status = ibt_alloc_rc_channel(hca->hca_hdl,
1652 rw_exit(&hca->state_lock);
1655 rw_exit(&hca->state_lock);
1669 mutex_init(&kqp->replylist_lock, NULL, MUTEX_DEFAULT, hca->iblock);
1670 mutex_init(&kqp->posted_rbufs_lock, NULL, MUTEX_DRIVER, hca->iblock);
1672 mutex_init(&kqp->send_rbufs_lock, NULL, MUTEX_DRIVER, hca->iblock);
1673 mutex_init(&kqp->rdlist_lock, NULL, MUTEX_DEFAULT, hca->iblock);
1674 mutex_init(&kqp->cb_lock, NULL, MUTEX_DRIVER, hca->iblock);
1676 mutex_init(&kqp->rdmaconn.c_lock, NULL, MUTEX_DRIVER, hca->iblock);
1709 rib_hca_t *hca;
1711 hca = (rib_hca_t *)clnt_hdl;
1761 rw_enter(&hca->state_lock, RW_READER);
1762 if (hca->state != HCA_DETACHED)
1764 &hca->cl_conn_list);
1765 rw_exit(&hca->state_lock);
1794 rib_conn_to_srv(rib_hca_t *hca, rib_qp_t *qp, rpcib_ping_t *rptp)
1842 qp_attr.rc_scq = hca->clnt_scq->rib_cq_hdl;
1843 qp_attr.rc_rcq = hca->clnt_rcq->rib_cq_hdl;
1844 qp_attr.rc_pd = hca->pd_hdl;
1857 chan_args.oc_cm_clnt_private = (void *)hca;
1866 rw_enter(&hca->state_lock, RW_READER);
1867 if (hca->state != HCA_DETACHED) {
1868 ibt_status = ibt_alloc_rc_channel(hca->hca_hdl,
1873 rw_exit(&hca->state_lock);
1876 rw_exit(&hca->state_lock);
1930 rib_hca_t *hca;
1959 for (hca = rib_stat->hcas_list; hca; hca = hca->next) {
1960 rw_enter(&hca->state_lock, RW_READER);
1961 if (hca->state == HCA_DETACHED) {
1962 rw_exit(&hca->state_lock);
1967 ipattr.ipa_hca_guid = hca->hca_guid;
1987 rptp->path.pi_hca_guid == hca->hca_guid) {
1988 rptp->hca = hca;
1989 rw_exit(&hca->state_lock);
2004 rw_exit(&hca->state_lock);
2024 rib_hca_t *hca;
2041 hca = qp->hca;
2110 * then the hca is no longer being used.
2113 rw_enter(&hca->state_lock, RW_READER);
2114 if (hca->state == HCA_DETACHED) {
2115 rw_enter(&hca->srv_conn_list.conn_lock, RW_READER);
2116 if (hca->srv_conn_list.conn_hd == NULL) {
2117 rw_enter(&hca->cl_conn_list.conn_lock,
2120 if (hca->cl_conn_list.conn_hd == NULL) {
2121 mutex_enter(&hca->inuse_lock);
2122 hca->inuse = FALSE;
2123 cv_signal(&hca->cb_cv);
2124 mutex_exit(&hca->inuse_lock);
2126 rw_exit(&hca->cl_conn_list.conn_lock);
2128 rw_exit(&hca->srv_conn_list.conn_lock);
2130 rw_exit(&hca->state_lock);
2937 rib_hca_t *hca;
2954 hca = (rib_hca_t *)any;
2980 status = rib_svc_create_chan(hca, (caddr_t)q,
3031 (void) rib_add_connlist(conn, &hca->srv_conn_list);
3036 rw_enter(&hca->state_lock, RW_READER);
3037 if (hca->state == HCA_DETACHED) {
3038 rw_exit(&hca->state_lock);
3041 rw_exit(&hca->state_lock);
3177 &hca->srv_conn_list);
3229 rib_register_service(rib_hca_t *hca, int service_type,
3245 rw_enter(&hca->state_lock, RW_READER);
3246 if (hca->state != HCA_DETACHED) {
3247 ibt_status = ibt_query_hca_ports(hca->hca_hdl, 0, &port_infop,
3249 rw_exit(&hca->state_lock);
3251 rw_exit(&hca->state_lock);
3301 ibt_status = ibt_register_service(hca->ibt_clnt_hdl,
3344 rw_enter(&hca->bound_services_lock, RW_READER);
3346 for (hca_srv = hca->bound_services; hca_srv;
3354 rw_exit(&hca->bound_services_lock);
3371 gid, NULL, hca, &sbp);
3381 rw_enter(&hca->bound_services_lock,
3383 hca_srv->next = hca->bound_services;
3384 hca->bound_services = hca_srv;
3385 rw_exit(&hca->bound_services_lock);
3417 rib_hca_t *hca;
3435 for (hca = rib_stat->hcas_list; hca; hca = hca->next) {
3437 * First check if a hca is still attached
3439 rw_enter(&hca->state_lock, RW_READER);
3440 if (hca->state != HCA_INITED) {
3441 rw_exit(&hca->state_lock);
3444 rw_exit(&hca->state_lock);
3452 status = rib_register_service(hca, NFS,
3480 rib_hca_t *hca;
3496 for (hca = rib_stat->hcas_list; hca; hca = hca->next) {
3498 * First check if a hca is still attached
3500 rw_enter(&hca->state_lock, RW_READER);
3501 if (hca->state == HCA_DETACHED) {
3502 rw_exit(&hca->state_lock);
3505 rib_close_channels(&hca->srv_conn_list);
3506 rib_stop_services(hca);
3507 rw_exit(&hca->state_lock);
3527 rib_stop_services(rib_hca_t *hca)
3536 rw_enter(&hca->bound_services_lock, RW_READER);
3537 srv_list = hca->bound_services;
3538 hca->bound_services = NULL;
3539 rw_exit(&hca->bound_services_lock);
3664 rib_hca_t *hca = (ctoqp(conn))->hca;
3669 status = rib_reg_mem(hca, adsp, buf, buflen, 0, &mr_hdl, &mr_desc);
3683 rib_reg_mem(rib_hca_t *hca, caddr_t adsp, caddr_t buf, uint_t size,
3696 rw_enter(&hca->state_lock, RW_READER);
3697 if (hca->state != HCA_DETACHED) {
3698 ibt_status = ibt_register_mr(hca->hca_hdl, hca->pd_hdl,
3700 rw_exit(&hca->state_lock);
3702 rw_exit(&hca->state_lock);
3720 rib_hca_t *hca = (ctoqp(conn))->hca;
3743 status = rib_reg_mem(hca, adsp, buf, buflen, 0, &mr_hdl, &mr_desc);
3768 rib_hca_t *hca = (ctoqp(conn))->hca;
3775 (void) ibt_deregister_mr(hca->hca_hdl,
3802 rib_hca_t *hca = (ctoqp(conn))->hca;
3815 rw_enter(&hca->state_lock, RW_READER);
3816 if (hca->state != HCA_DETACHED) {
3817 status = ibt_sync_mr(hca->hca_hdl, &mr_segment, 1);
3818 rw_exit(&hca->state_lock);
3820 rw_exit(&hca->state_lock);
3848 rib_rbufpool_create(rib_hca_t *hca, int ptype, int num)
3862 mutex_init(&bp->buflock, NULL, MUTEX_DRIVER, hca->iblock);
3888 rw_enter(&hca->state_lock, RW_READER);
3890 if (hca->state == HCA_DETACHED) {
3891 rw_exit(&hca->state_lock);
3900 ibt_status = ibt_register_mr(hca->hca_hdl,
3901 hca->pd_hdl, &mem_attr,
3906 (void) ibt_deregister_mr(hca->hca_hdl,
3909 rw_exit(&hca->state_lock);
3913 rw_exit(&hca->state_lock);
3939 rib_rbufpool_deregister(rib_hca_t *hca, int ptype)
3950 rbp = hca->send_pool;
3953 rbp = hca->recv_pool;
3967 (void) ibt_deregister_mr(hca->hca_hdl, rbp->mr_hdl[i]);
3972 rib_rbufpool_free(rib_hca_t *hca, int ptype)
3983 rbp = hca->send_pool;
3986 rbp = hca->recv_pool;
4012 rib_rbufpool_destroy(rib_hca_t *hca, int ptype)
4017 rib_rbufpool_deregister(hca, ptype);
4018 rib_rbufpool_free(hca, ptype);
4062 rib_hca_t *hca = qp->hca;
4074 rbp = hca->send_pool;
4077 rbp = hca->recv_pool;
4134 rib_hca_t *hca = qp->hca;
4143 rbp = hca->send_pool;
4146 rbp = hca->recv_pool;
4219 rib_find_hca_connection(rib_hca_t *hca, struct netbuf *s_svcaddr,
4227 rw_enter(&hca->cl_conn_list.conn_lock, RW_READER);
4228 cn = hca->cl_conn_list.conn_hd;
4241 rw_exit(&hca->cl_conn_list.conn_lock);
4270 rw_exit(&hca->cl_conn_list.conn_lock);
4310 rw_exit(&hca->cl_conn_list.conn_lock);
4339 rib_hca_t *hca;
4345 for (hca = rib_stat->hcas_list; hca; hca = hca->next) {
4346 rw_enter(&hca->state_lock, RW_READER);
4347 if (hca->state != HCA_DETACHED) {
4348 status = rib_find_hca_connection(hca, s_svcaddr,
4350 rw_exit(&hca->state_lock);
4356 rw_exit(&hca->state_lock);
4369 hca = rpt->hca;
4384 if (rib_clnt_create_chan(hca, d_svcaddr, &qp) != RDMA_SUCCESS) {
4433 (void) rib_add_connlist(cn, &hca->cl_conn_list);
4434 status = rib_conn_to_srv(hca, qp, rpt);
4500 &qp->hca->srv_conn_list);
4503 &qp->hca->cl_conn_list);
4511 rib_hca_t *hca = ctoqp(conn)->hca;
4537 error = ddi_taskq_dispatch(hca->cleanup_helper, rib_conn_close,
4795 * the hca.
4799 rib_free_hca(rib_hca_t *hca)
4801 (void) ibt_free_cq(hca->clnt_rcq->rib_cq_hdl);
4802 (void) ibt_free_cq(hca->clnt_scq->rib_cq_hdl);
4803 (void) ibt_free_cq(hca->svc_rcq->rib_cq_hdl);
4804 (void) ibt_free_cq(hca->svc_scq->rib_cq_hdl);
4806 kmem_free(hca->clnt_rcq, sizeof (rib_cq_t));
4807 kmem_free(hca->clnt_scq, sizeof (rib_cq_t));
4808 kmem_free(hca->svc_rcq, sizeof (rib_cq_t));
4809 kmem_free(hca->svc_scq, sizeof (rib_cq_t));
4811 rib_rbufpool_destroy(hca, RECV_BUFFER);
4812 rib_rbufpool_destroy(hca, SEND_BUFFER);
4813 rib_destroy_cache(hca);
4816 (void) ibt_free_pd(hca->hca_hdl, hca->pd_hdl);
4817 (void) ibt_close_hca(hca->hca_hdl);
4818 hca->hca_hdl = NULL;
4823 rib_stop_hca_services(rib_hca_t *hca)
4825 rib_stop_services(hca);
4826 rib_close_channels(&hca->cl_conn_list);
4827 rib_close_channels(&hca->srv_conn_list);
4829 rib_purge_connlist(&hca->cl_conn_list);
4830 rib_purge_connlist(&hca->srv_conn_list);
4838 rw_enter(&hca->srv_conn_list.conn_lock, RW_READER);
4839 rw_enter(&hca->cl_conn_list.conn_lock, RW_READER);
4840 if (hca->srv_conn_list.conn_hd == NULL &&
4841 hca->cl_conn_list.conn_hd == NULL) {
4844 * buffers, close hca and be done.
4846 rib_free_hca(hca);
4848 rw_exit(&hca->cl_conn_list.conn_lock);
4849 rw_exit(&hca->srv_conn_list.conn_lock);
4851 if (hca->hca_hdl != NULL) {
4852 mutex_enter(&hca->inuse_lock);
4853 while (hca->inuse)
4854 cv_wait(&hca->cb_cv, &hca->inuse_lock);
4855 mutex_exit(&hca->inuse_lock);
4857 rib_free_hca(hca);
4859 rw_destroy(&hca->bound_services_lock);
4861 if (hca->cleanup_helper != NULL) {
4862 ddi_taskq_destroy(hca->cleanup_helper);
4863 hca->cleanup_helper = NULL;
4873 rib_hca_t *hca = NULL;
4878 hca = *hcap;
4879 rw_enter(&hca->state_lock, RW_WRITER);
4880 if (hca->hca_hdl == hca_hdl) {
4883 * hca list.
4885 hca->state = HCA_DETACHED;
4886 *hcap = hca->next;
4889 rw_exit(&hca->state_lock);
4892 rw_exit(&hca->state_lock);
4896 if (hca == NULL)
4898 ASSERT(hca->hca_hdl == hca_hdl);
4911 rib_stop_hca_services(hca);
4913 kmem_free(hca, sizeof (*hca));
4921 rib_hca_t *hca = (rib_hca_t *)argp;
4923 rw_enter(&hca->avl_rw_lock, RW_WRITER);
4924 rcas = avl_first(&hca->avl_tree);
4926 avl_remove(&hca->avl_tree, rcas);
4934 (void) rib_deregistermem_via_hca(hca,
4937 hca->cache_allocation -= rb->lrc_len;
4942 kmem_cache_free(hca->server_side_cache, rcas);
4943 rcas = avl_first(&hca->avl_tree);
4945 avl_remove(&hca->avl_tree, rcas);
4947 rw_exit(&hca->avl_rw_lock);
4955 rib_hca_t *hca = (rib_hca_t *)argp;
4957 mutex_enter(&hca->cache_allocation_lock);
4958 if (hca->cache_allocation < cache_limit) {
4959 mutex_exit(&hca->cache_allocation_lock);
4962 mutex_exit(&hca->cache_allocation_lock);
4964 rw_enter(&hca->avl_rw_lock, RW_WRITER);
4965 rcas = avl_last(&hca->avl_tree);
4967 avl_remove(&hca->avl_tree, rcas);
4975 (void) rib_deregistermem_via_hca(hca,
4978 hca->cache_allocation -= rb->lrc_len;
4984 if (hca->server_side_cache) {
4985 kmem_cache_free(hca->server_side_cache, rcas);
4988 if (hca->cache_allocation < cache_limit) {
4989 rw_exit(&hca->avl_rw_lock);
4993 rcas = avl_last(&hca->avl_tree);
4995 avl_remove(&hca->avl_tree, rcas);
4997 rw_exit(&hca->avl_rw_lock);
5013 rib_destroy_cache(rib_hca_t *hca)
5015 if (hca->avl_init) {
5016 rib_server_side_cache_reclaim((void *)hca);
5017 if (hca->server_side_cache) {
5018 kmem_cache_destroy(hca->server_side_cache);
5019 hca->server_side_cache = NULL;
5021 avl_destroy(&hca->avl_tree);
5022 mutex_destroy(&hca->cache_allocation_lock);
5023 rw_destroy(&hca->avl_rw_lock);
5025 hca->avl_init = FALSE;
5029 rib_force_cleanup(void *hca)
5031 if (((rib_hca_t *)hca)->cleanup_helper != NULL)
5033 ((rib_hca_t *)hca)->cleanup_helper,
5035 (void *)hca, DDI_NOSLEEP);
5042 rib_hca_t *hca = (ctoqp(conn))->hca;
5047 if (!hca->avl_init)
5052 rw_enter(&hca->avl_rw_lock, RW_READER);
5054 mutex_enter(&hca->cache_allocation_lock);
5055 c_alloc = hca->cache_allocation;
5056 mutex_exit(&hca->cache_allocation_lock);
5058 if ((rcas = (cache_avl_struct_t *)avl_find(&hca->avl_tree, &cas,
5062 rib_force_cleanup((void *)hca);
5063 rw_exit(&hca->avl_rw_lock);
5064 mutex_enter(&hca->cache_allocation_lock);
5065 hca->cache_misses_above_the_limit ++;
5066 mutex_exit(&hca->cache_allocation_lock);
5072 rw_exit(&hca->avl_rw_lock);
5073 rw_enter(&hca->avl_rw_lock, RW_WRITER);
5076 if ((rcas = (cache_avl_struct_t *)avl_find(&hca->avl_tree,
5080 kmem_cache_alloc(hca->server_side_cache, KM_SLEEP);
5088 avl_insert(&hca->avl_tree, rcas, where);
5099 rw_exit(&hca->avl_rw_lock);
5101 mutex_enter(&hca->cache_allocation_lock);
5102 hca->cache_hits++;
5103 hca->cache_allocation -= len;
5104 mutex_exit(&hca->cache_allocation_lock);
5109 rib_force_cleanup((void *)hca);
5110 rw_exit(&hca->avl_rw_lock);
5112 mutex_enter(&hca->cache_allocation_lock);
5113 hca->cache_misses_above_the_limit++;
5114 mutex_exit(&hca->cache_allocation_lock);
5118 rw_exit(&hca->avl_rw_lock);
5119 mutex_enter(&hca->cache_allocation_lock);
5120 hca->cache_misses++;
5121 mutex_exit(&hca->cache_allocation_lock);
5156 rib_hca_t *hca = (ctoqp(conn))->hca;
5158 if (!hca->avl_init)
5162 rw_enter(&hca->avl_rw_lock, RW_READER);
5164 avl_find(&hca->avl_tree, &cas, &where)) == NULL) {
5165 rw_exit(&hca->avl_rw_lock);
5173 rw_exit(&hca->avl_rw_lock);
5174 mutex_enter(&hca->cache_allocation_lock);
5175 hca->cache_allocation += cas.len;
5176 mutex_exit(&hca->cache_allocation_lock);
5184 (void) rib_deregistermem_via_hca(hca,
5191 rib_registermem_via_hca(rib_hca_t *hca, caddr_t adsp, caddr_t buf,
5202 status = rib_reg_mem(hca, adsp, buf, buflen, 0, &mr_hdl, &mr_desc);
5217 rib_deregistermemsync_via_hca(rib_hca_t *hca, caddr_t buf,
5221 (void) rib_deregistermem_via_hca(hca, buf, buf_handle);
5227 rib_deregistermem_via_hca(rib_hca_t *hca, caddr_t buf, struct mrc buf_handle)
5230 (void) ibt_deregister_mr(hca->hca_hdl,
5380 rib_hca_t *hca;
5389 for (hca = rib_stat->hcas_list; hca; hca = hca->next) {
5391 (uint64_t)hca->cache_allocation;
5393 (uint64_t)hca->cache_hits;
5395 (uint64_t)hca->cache_misses;
5397 (uint64_t)hca->cache_misses_above_the_limit;