Lines Matching refs:lgr
232 static void smc_llc_flow_parallel(struct smc_link_group *lgr, u8 flow_type,
238 flow_type != msg_type && !lgr->delayed_event) {
239 lgr->delayed_event = qentry;
246 SMC_LGR_ID_SIZE, &lgr->id,
247 lgr->net->net_cookie,
249 flow_type, lgr->role);
257 struct smc_link_group *lgr = qentry->link->lgr;
259 spin_lock_bh(&lgr->llc_flow_lock);
262 smc_llc_flow_parallel(lgr, flow->type, qentry);
263 spin_unlock_bh(&lgr->llc_flow_lock);
281 spin_unlock_bh(&lgr->llc_flow_lock);
286 int smc_llc_flow_initiate(struct smc_link_group *lgr,
298 if (list_empty(&lgr->list))
300 spin_lock_bh(&lgr->llc_flow_lock);
301 if (lgr->llc_flow_lcl.type == SMC_LLC_FLOW_NONE &&
302 (lgr->llc_flow_rmt.type == SMC_LLC_FLOW_NONE ||
303 lgr->llc_flow_rmt.type == allowed_remote)) {
304 lgr->llc_flow_lcl.type = type;
305 spin_unlock_bh(&lgr->llc_flow_lock);
308 spin_unlock_bh(&lgr->llc_flow_lock);
309 rc = wait_event_timeout(lgr->llc_flow_waiter, (list_empty(&lgr->list) ||
310 (lgr->llc_flow_lcl.type == SMC_LLC_FLOW_NONE &&
311 (lgr->llc_flow_rmt.type == SMC_LLC_FLOW_NONE ||
312 lgr->llc_flow_rmt.type == allowed_remote))),
320 void smc_llc_flow_stop(struct smc_link_group *lgr, struct smc_llc_flow *flow)
322 spin_lock_bh(&lgr->llc_flow_lock);
325 spin_unlock_bh(&lgr->llc_flow_lock);
326 if (!list_empty(&lgr->list) && lgr->delayed_event &&
327 flow == &lgr->llc_flow_lcl)
328 schedule_work(&lgr->llc_event_work);
330 wake_up(&lgr->llc_flow_waiter);
336 struct smc_llc_qentry *smc_llc_wait(struct smc_link_group *lgr,
340 struct smc_llc_flow *flow = &lgr->llc_flow_lcl;
343 wait_event_timeout(lgr->llc_msg_waiter,
346 list_empty(&lgr->list)),
349 (lnk && !smc_link_usable(lnk)) || list_empty(&lgr->list)) {
358 smc_llc_flow_start(&lgr->llc_flow_lcl,
364 SMC_LGR_ID_SIZE, &lgr->id, lgr->net->net_cookie,
366 flow->type, lgr->role,
435 struct smc_link_group *lgr, size_t len)
437 if (lgr->smc_version == SMC_V2) {
463 smc_llc_init_msg_hdr(&confllc->hd, link->lgr, sizeof(*confllc));
474 if (link->lgr->smc_version == SMC_V2 &&
475 link->lgr->peer_smc_release >= SMC_RELEASE_1) {
476 confllc->max_conns = link->lgr->max_conns;
477 confllc->max_links = link->lgr->max_links;
504 smc_llc_init_msg_hdr(&rkeyllc->hd, send_link->lgr, sizeof(*rkeyllc));
508 link = &send_link->lgr->lnk[i];
552 smc_llc_init_msg_hdr(&rkeyllc->hd, link->lgr, sizeof(*rkeyllc));
563 static struct smc_buf_desc *_smc_llc_get_next_rmb(struct smc_link_group *lgr,
569 buf_pos = list_first_entry_or_null(&lgr->rmbs[*buf_lst],
579 static struct smc_buf_desc *smc_llc_get_next_rmb(struct smc_link_group *lgr,
586 return _smc_llc_get_next_rmb(lgr, buf_lst);
588 if (list_is_last(&buf_pos->list, &lgr->rmbs[*buf_lst])) {
590 return _smc_llc_get_next_rmb(lgr, buf_lst);
596 static struct smc_buf_desc *smc_llc_get_first_rmb(struct smc_link_group *lgr,
600 return smc_llc_get_next_rmb(lgr, buf_lst, NULL);
606 struct smc_link_group *lgr = link->lgr;
613 ext->v2_direct = !lgr->uses_gateway;
618 down_write(&lgr->rmbs_lock);
619 ext->num_rkeys = lgr->conns_num;
622 buf_pos = smc_llc_get_first_rmb(lgr, &buf_lst);
625 buf_pos = smc_llc_get_next_rmb(lgr, &buf_lst, buf_pos);
634 buf_pos = smc_llc_get_next_rmb(lgr, &buf_lst, buf_pos);
638 up_write(&lgr->rmbs_lock);
655 if (link->lgr->smc_version == SMC_V2) {
692 smc_llc_init_msg_hdr(&addllc->hd, link->lgr, len);
694 if (link->lgr->smc_version == SMC_V2)
722 smc_llc_init_msg_hdr(&delllc->hd, link->lgr, sizeof(*delllc));
755 smc_llc_init_msg_hdr(&testllc->hd, link->lgr, sizeof(*testllc));
807 static int smc_llc_alloc_alt_link(struct smc_link_group *lgr,
812 if (lgr->type == SMC_LGR_SYMMETRIC ||
813 (lgr->type != SMC_LGR_SINGLE &&
821 if (lgr->lnk[i].state == SMC_LNK_UNUSED)
825 if (lgr->lnk[i].state == SMC_LNK_UNUSED)
837 struct smc_link_group *lgr = link->lgr;
859 *buf_pos = smc_llc_get_next_rmb(lgr, buf_lst, *buf_pos);
875 *buf_pos = smc_llc_get_next_rmb(lgr, buf_lst, *buf_pos);
879 if (lgr->role == SMC_CLNT)
891 struct smc_link_group *lgr = link->lgr;
899 down_write(&lgr->rmbs_lock);
900 num_rkeys_send = lgr->conns_num;
901 buf_pos = smc_llc_get_first_rmb(lgr, &buf_lst);
903 qentry = smc_llc_wait(lgr, NULL, SMC_LLC_WAIT_TIME,
913 smc_rtoken_set(lgr, link->link_idx, link_new->link_idx,
919 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
926 up_write(&lgr->rmbs_lock);
936 smc_llc_init_msg_hdr(&qentry->msg.raw.hdr, qentry->link->lgr,
946 struct smc_link_group *lgr = link->lgr;
951 qentry = smc_llc_wait(lgr, NULL, SMC_LLC_WAIT_FIRST_TIME, 0);
962 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
966 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
993 smcr_lgr_set_type_asym(lgr, lgr_new_t, link_new->link_idx);
995 smcr_lgr_set_type(lgr, lgr_new_t);
1003 struct smc_link_group *lgr = link->lgr;
1006 ext = (struct smc_llc_msg_add_link_v2_ext *)((u8 *)lgr->wr_rx_buf_v2 +
1009 down_write(&lgr->rmbs_lock);
1011 smc_rtoken_set(lgr, link->link_idx, link_new->link_idx,
1016 up_write(&lgr->rmbs_lock);
1034 struct smc_link_group *lgr = smc_get_lgr(link);
1048 if (lgr->type == SMC_LGR_SINGLE && lgr->max_links <= 1) {
1053 ini->vlan_id = lgr->vlan_id;
1054 if (lgr->smc_version == SMC_V2) {
1056 ini->smcrv2.saddr = lgr->saddr;
1059 smc_pnet_find_alt_roce(lgr, ini, link->smcibdev);
1061 (lgr->smc_version == SMC_V2 ||
1067 if (lgr->smc_version == SMC_V2 && !ini->smcrv2.ib_dev_v2) {
1071 } else if (lgr->smc_version < SMC_V2 && !ini->ib_dev) {
1076 lnk_idx = smc_llc_alloc_alt_link(lgr, lgr_new_t);
1079 lnk_new = &lgr->lnk[lnk_idx];
1080 rc = smcr_link_init(lgr, lnk_new, lnk_idx, ini);
1100 if (lgr->smc_version == SMC_V2) {
1133 if (link->lgr->type == SMC_LGR_SYMMETRIC ||
1134 link->lgr->type == SMC_LGR_ASYMMETRIC_PEER)
1137 smc_fill_gid_list(link->lgr, &gidlist, link->smcibdev, link->gid);
1152 smc_llc_init_msg_hdr(&llc->hd, link->lgr, len);
1156 link->lgr->llc_flow_lcl.type = SMC_LLC_FLOW_REQ_ADD_LINK;
1165 struct smc_link_group *lgr = smc_get_lgr(link);
1168 if (lgr->smc_version == SMC_V2) {
1173 if (lgr->type == SMC_LGR_SYMMETRIC ||
1174 lgr->type == SMC_LGR_ASYMMETRIC_PEER)
1177 if (lgr->type == SMC_LGR_SINGLE && lgr->max_links <= 1)
1184 ini->vlan_id = lgr->vlan_id;
1185 smc_pnet_find_alt_roce(lgr, ini, link->smcibdev);
1214 static void smc_llc_process_cli_add_link(struct smc_link_group *lgr)
1218 qentry = smc_llc_flow_qentry_clr(&lgr->llc_flow_lcl);
1220 down_write(&lgr->llc_conf_mutex);
1225 up_write(&lgr->llc_conf_mutex);
1228 static int smc_llc_active_link_count(struct smc_link_group *lgr)
1233 if (!smc_link_active(&lgr->lnk[i]))
1241 static struct smc_link *smc_llc_find_asym_link(struct smc_link_group *lgr)
1251 if (!smc_link_usable(&lgr->lnk[i]) ||
1252 !smc_link_usable(&lgr->lnk[j]))
1254 if (!memcmp(lgr->lnk[i].gid, lgr->lnk[j].gid,
1266 if (!smc_link_usable(&lgr->lnk[k]))
1269 !memcmp(lgr->lnk[i].peer_gid, lgr->lnk[k].peer_gid,
1275 !memcmp(lgr->lnk[j].peer_gid, lgr->lnk[k].peer_gid,
1282 return (asym_idx < 0) ? NULL : &lgr->lnk[asym_idx];
1285 static void smc_llc_delete_asym_link(struct smc_link_group *lgr)
1291 lnk_asym = smc_llc_find_asym_link(lgr);
1296 lnk_new = smc_switch_conns(lgr, lnk_asym, false);
1301 lgr->llc_flow_lcl.type = SMC_LLC_FLOW_DEL_LINK;
1308 qentry = smc_llc_wait(lgr, lnk_new, SMC_LLC_WAIT_TIME,
1314 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
1323 struct smc_link_group *lgr = link->lgr;
1331 down_write(&lgr->rmbs_lock);
1332 num_rkeys_send = lgr->conns_num;
1333 buf_pos = smc_llc_get_first_rmb(lgr, &buf_lst);
1337 qentry = smc_llc_wait(lgr, link, SMC_LLC_WAIT_TIME,
1347 smc_rtoken_set(lgr, link->link_idx, link_new->link_idx,
1353 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
1356 up_write(&lgr->rmbs_lock);
1364 struct smc_link_group *lgr = link->lgr;
1373 qentry = smc_llc_wait(lgr, link, SMC_LLC_WAIT_FIRST_TIME, 0);
1380 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
1387 smcr_lgr_set_type_asym(lgr, lgr_new_t, link_new->link_idx);
1389 smcr_lgr_set_type(lgr, lgr_new_t);
1390 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
1397 smc_llc_init_msg_hdr(&qentry->msg.raw.hdr, qentry->link->lgr,
1407 struct smc_link_group *lgr = link->lgr;
1425 if (lgr->type == SMC_LGR_SINGLE && lgr->max_links <= 1) {
1431 ini->vlan_id = lgr->vlan_id;
1432 if (lgr->smc_version == SMC_V2) {
1434 ini->smcrv2.saddr = lgr->saddr;
1442 smc_pnet_find_alt_roce(lgr, ini, link->smcibdev);
1443 if (lgr->smc_version == SMC_V2 && !ini->smcrv2.ib_dev_v2) {
1447 } else if (lgr->smc_version < SMC_V2 && !ini->ib_dev) {
1452 lnk_idx = smc_llc_alloc_alt_link(lgr, lgr_new_t);
1458 rc = smcr_link_init(lgr, &lgr->lnk[lnk_idx], lnk_idx, ini);
1461 link_new = &lgr->lnk[lnk_idx];
1474 qentry = smc_llc_wait(lgr, link, SMC_LLC_WAIT_TIME, SMC_LLC_ADD_LINK);
1481 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
1485 if (lgr->type == SMC_LGR_SINGLE &&
1487 (lgr->smc_version == SMC_V2 ||
1492 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
1500 if (lgr->smc_version == SMC_V2) {
1524 static void smc_llc_process_srv_add_link(struct smc_link_group *lgr)
1526 struct smc_link *link = lgr->llc_flow_lcl.qentry->link;
1530 qentry = smc_llc_flow_qentry_clr(&lgr->llc_flow_lcl);
1532 down_write(&lgr->llc_conf_mutex);
1534 if (!rc && lgr->type == SMC_LGR_SYMMETRIC) {
1536 smc_llc_delete_asym_link(lgr);
1538 up_write(&lgr->llc_conf_mutex);
1548 smc_llc_init_msg_hdr(&add_llc.hd, link->lgr, sizeof(add_llc));
1556 struct smc_link_group *lgr = container_of(work, struct smc_link_group,
1559 if (list_empty(&lgr->list)) {
1561 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
1565 if (lgr->role == SMC_CLNT)
1566 smc_llc_process_cli_add_link(lgr);
1568 smc_llc_process_srv_add_link(lgr);
1570 if (lgr->llc_flow_lcl.type != SMC_LLC_FLOW_REQ_ADD_LINK)
1571 smc_llc_flow_stop(lgr, &lgr->llc_flow_lcl);
1582 smc_llc_init_msg_hdr(&del_llc.hd, link->lgr, sizeof(del_llc));
1589 static void smc_llc_process_cli_delete_link(struct smc_link_group *lgr)
1597 qentry = smc_llc_flow_qentry_clr(&lgr->llc_flow_lcl);
1602 smc_lgr_terminate_sched(lgr);
1605 down_write(&lgr->llc_conf_mutex);
1608 if (lgr->lnk[lnk_idx].link_id != del_llc->link_num)
1610 lnk_del = &lgr->lnk[lnk_idx];
1620 lnk_asym = smc_llc_find_asym_link(lgr);
1626 smc_switch_conns(lgr, lnk_del, false);
1629 active_links = smc_llc_active_link_count(lgr);
1631 /* expected deletion of asym link, don't change lgr state */
1633 smcr_lgr_set_type(lgr, SMC_LGR_SINGLE);
1635 smcr_lgr_set_type(lgr, SMC_LGR_NONE);
1636 smc_lgr_terminate_sched(lgr);
1639 up_write(&lgr->llc_conf_mutex);
1647 void smc_llc_send_link_delete_all(struct smc_link_group *lgr, bool ord, u32 rsn)
1653 smc_llc_init_msg_hdr(&delllc.hd, lgr, sizeof(delllc));
1660 if (!smc_link_sendable(&lgr->lnk[i]))
1662 if (!smc_llc_send_message_wait(&lgr->lnk[i], &delllc))
1667 static void smc_llc_process_srv_delete_link(struct smc_link_group *lgr)
1675 down_write(&lgr->llc_conf_mutex);
1676 qentry = smc_llc_flow_qentry_clr(&lgr->llc_flow_lcl);
1681 /* delete entire lgr */
1682 smc_llc_send_link_delete_all(lgr, true, ntohl(
1684 smc_lgr_terminate_sched(lgr);
1690 if (lgr->lnk[i].link_id == del_llc->link_num) {
1691 lnk_del = &lgr->lnk[i];
1699 if (smc_switch_conns(lgr, lnk_del, false))
1702 if (!list_empty(&lgr->list)) {
1710 qentry2 = smc_llc_wait(lgr, lnk, SMC_LLC_WAIT_TIME,
1713 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
1718 active_links = smc_llc_active_link_count(lgr);
1720 smcr_lgr_set_type(lgr, SMC_LGR_SINGLE);
1722 smcr_lgr_set_type(lgr, SMC_LGR_NONE);
1723 smc_lgr_terminate_sched(lgr);
1726 if (lgr->type == SMC_LGR_SINGLE && !list_empty(&lgr->list)) {
1731 up_write(&lgr->llc_conf_mutex);
1737 struct smc_link_group *lgr = container_of(work, struct smc_link_group,
1740 if (list_empty(&lgr->list)) {
1742 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
1746 if (lgr->role == SMC_CLNT)
1747 smc_llc_process_cli_delete_link(lgr);
1749 smc_llc_process_srv_delete_link(lgr);
1751 smc_llc_flow_stop(lgr, &lgr->llc_flow_lcl);
1755 static void smc_llc_rmt_conf_rkey(struct smc_link_group *lgr)
1764 qentry = lgr->llc_flow_rmt.qentry;
1779 smc_rtoken_set2(lgr, rk_idx, llc->rtoken[i].link_id,
1789 smc_llc_init_msg_hdr(&llc->hd, link->lgr, sizeof(*llc));
1791 smc_llc_flow_qentry_del(&lgr->llc_flow_rmt);
1795 static void smc_llc_rmt_delete_rkey(struct smc_link_group *lgr)
1803 qentry = lgr->llc_flow_rmt.qentry;
1807 if (lgr->smc_version == SMC_V2) {
1810 memcpy(lgr->wr_rx_buf_v2, llc, sizeof(*llc));
1811 llcv2 = (struct smc_llc_msg_delete_rkey_v2 *)lgr->wr_rx_buf_v2;
1821 smc_llc_init_msg_hdr(&llc->hd, link->lgr, sizeof(*llc));
1841 smc_llc_flow_qentry_del(&lgr->llc_flow_rmt);
1844 static void smc_llc_protocol_violation(struct smc_link_group *lgr, u8 type)
1847 "llc_type %d\n", SMC_LGR_ID_SIZE, &lgr->id,
1848 lgr->net->net_cookie, type);
1849 smc_llc_set_termination_rsn(lgr, SMC_LLC_DEL_PROT_VIOL);
1850 smc_lgr_terminate_sched(lgr);
1854 static void smc_llc_event_flush(struct smc_link_group *lgr)
1858 spin_lock_bh(&lgr->llc_event_q_lock);
1859 list_for_each_entry_safe(qentry, q, &lgr->llc_event_q, list) {
1863 spin_unlock_bh(&lgr->llc_event_q_lock);
1870 struct smc_link_group *lgr = link->lgr;
1881 if (list_empty(&lgr->list))
1882 goto out; /* lgr is terminating */
1883 if (lgr->role == SMC_CLNT) {
1885 if (lgr->llc_flow_lcl.type ==
1888 if (smc_llc_flow_start(&lgr->llc_flow_lcl,
1890 schedule_work(&lgr->llc_add_link_work);
1894 if (lgr->llc_flow_lcl.type == SMC_LLC_FLOW_ADD_LINK &&
1895 !lgr->llc_flow_lcl.qentry) {
1897 smc_llc_flow_qentry_set(&lgr->llc_flow_lcl,
1899 wake_up(&lgr->llc_msg_waiter);
1902 if (lgr->llc_flow_lcl.type ==
1905 lgr->llc_flow_lcl.type = SMC_LLC_FLOW_ADD_LINK;
1906 smc_llc_flow_qentry_set(&lgr->llc_flow_lcl,
1908 schedule_work(&lgr->llc_add_link_work);
1911 if (smc_llc_flow_start(&lgr->llc_flow_lcl, qentry)) {
1912 schedule_work(&lgr->llc_add_link_work);
1914 } else if (smc_llc_flow_start(&lgr->llc_flow_lcl, qentry)) {
1916 schedule_work(&lgr->llc_add_link_work);
1921 if (lgr->llc_flow_lcl.type != SMC_LLC_FLOW_NONE) {
1923 smc_llc_flow_qentry_set(&lgr->llc_flow_lcl, qentry);
1924 wake_up(&lgr->llc_msg_waiter);
1929 if (lgr->llc_flow_lcl.type == SMC_LLC_FLOW_ADD_LINK &&
1930 !lgr->llc_flow_lcl.qentry) {
1932 smc_llc_flow_qentry_set(&lgr->llc_flow_lcl, qentry);
1933 wake_up(&lgr->llc_msg_waiter);
1934 } else if (smc_llc_flow_start(&lgr->llc_flow_lcl, qentry)) {
1935 schedule_work(&lgr->llc_del_link_work);
1940 if (smc_llc_flow_start(&lgr->llc_flow_rmt, qentry)) {
1942 smc_llc_rmt_conf_rkey(lgr);
1943 smc_llc_flow_stop(lgr, &lgr->llc_flow_rmt);
1953 if (smc_llc_flow_start(&lgr->llc_flow_rmt, qentry)) {
1955 smc_llc_rmt_delete_rkey(lgr);
1956 smc_llc_flow_stop(lgr, &lgr->llc_flow_rmt);
1963 if (lgr->role == SMC_CLNT &&
1964 lgr->llc_flow_lcl.type == SMC_LLC_FLOW_REQ_ADD_LINK &&
1966 smc_llc_flow_stop(link->lgr, &lgr->llc_flow_lcl);
1967 } else if (lgr->role == SMC_SERV) {
1968 if (smc_llc_flow_start(&lgr->llc_flow_lcl, qentry)) {
1970 lgr->llc_flow_lcl.type = SMC_LLC_FLOW_ADD_LINK;
1971 schedule_work(&lgr->llc_add_link_work);
1977 smc_llc_protocol_violation(lgr, llc->raw.hdr.common.type);
1987 struct smc_link_group *lgr = container_of(work, struct smc_link_group,
1991 if (!lgr->llc_flow_lcl.type && lgr->delayed_event) {
1992 qentry = lgr->delayed_event;
1993 lgr->delayed_event = NULL;
2001 spin_lock_bh(&lgr->llc_event_q_lock);
2002 if (!list_empty(&lgr->llc_event_q)) {
2003 qentry = list_first_entry(&lgr->llc_event_q,
2006 spin_unlock_bh(&lgr->llc_event_q_lock);
2010 spin_unlock_bh(&lgr->llc_event_q_lock);
2017 enum smc_llc_flowtype flowtype = link->lgr->llc_flow_lcl.type;
2018 struct smc_llc_flow *flow = &link->lgr->llc_flow_lcl;
2045 smc_llc_protocol_violation(link->lgr,
2053 smc_llc_flow_qentry_set(&link->lgr->llc_flow_lcl, qentry);
2054 wake_up(&link->lgr->llc_msg_waiter);
2059 struct smc_link_group *lgr = link->lgr;
2078 spin_lock_irqsave(&lgr->llc_event_q_lock, flags);
2079 list_add_tail(&qentry->list, &lgr->llc_event_q);
2080 spin_unlock_irqrestore(&lgr->llc_event_q_lock, flags);
2081 queue_work(system_highpri_wq, &lgr->llc_event_work);
2137 void smc_llc_lgr_init(struct smc_link_group *lgr, struct smc_sock *smc)
2141 INIT_WORK(&lgr->llc_event_work, smc_llc_event_work);
2142 INIT_WORK(&lgr->llc_add_link_work, smc_llc_add_link_work);
2143 INIT_WORK(&lgr->llc_del_link_work, smc_llc_delete_link_work);
2144 INIT_LIST_HEAD(&lgr->llc_event_q);
2145 spin_lock_init(&lgr->llc_event_q_lock);
2146 spin_lock_init(&lgr->llc_flow_lock);
2147 init_waitqueue_head(&lgr->llc_flow_waiter);
2148 init_waitqueue_head(&lgr->llc_msg_waiter);
2149 init_rwsem(&lgr->llc_conf_mutex);
2150 lgr->llc_testlink_time = READ_ONCE(net->smc.sysctl_smcr_testlink_time);
2153 /* called after lgr was removed from lgr_list */
2154 void smc_llc_lgr_clear(struct smc_link_group *lgr)
2156 smc_llc_event_flush(lgr);
2157 wake_up_all(&lgr->llc_flow_waiter);
2158 wake_up_all(&lgr->llc_msg_waiter);
2159 cancel_work_sync(&lgr->llc_event_work);
2160 cancel_work_sync(&lgr->llc_add_link_work);
2161 cancel_work_sync(&lgr->llc_del_link_work);
2162 if (lgr->delayed_event) {
2163 kfree(lgr->delayed_event);
2164 lgr->delayed_event = NULL;
2179 SMC_LGR_ID_SIZE, &link->lgr->id,
2180 link->lgr->net->net_cookie,
2185 if (link->lgr->llc_testlink_time) {
2186 link->llc_testlink_time = link->lgr->llc_testlink_time;
2198 SMC_LGR_ID_SIZE, &link->lgr->id,
2199 link->lgr->net->net_cookie,
2211 struct smc_link_group *lgr = send_link->lgr;
2219 qentry = smc_llc_wait(lgr, send_link, SMC_LLC_WAIT_TIME,
2225 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
2230 int smc_llc_do_delete_rkey(struct smc_link_group *lgr,
2237 send_link = smc_llc_usable_link(lgr);
2246 qentry = smc_llc_wait(lgr, send_link, SMC_LLC_WAIT_TIME,
2252 smc_llc_flow_qentry_del(&lgr->llc_flow_lcl);
2260 link_uid = htonl(*((u32 *)link->lgr->id) + link->link_id);