Lines Matching defs:ep
245 * @ep: Echange to be held
247 static inline void fc_exch_hold(struct fc_exch *ep)
249 atomic_inc(&ep->ex_refcnt);
255 * @ep: The exchange to that will use the header
262 static void fc_exch_setup_hdr(struct fc_exch *ep, struct fc_frame *fp,
268 fr_sof(fp) = ep->class;
269 if (ep->seq.cnt)
270 fr_sof(fp) = fc_sof_normal(ep->class);
274 if (fc_sof_needs_ack((enum fc_sof)ep->class))
298 fh->fh_ox_id = htons(ep->oxid);
299 fh->fh_rx_id = htons(ep->rxid);
300 fh->fh_seq_id = ep->seq.id;
301 fh->fh_seq_cnt = htons(ep->seq.cnt);
306 * @ep: Exchange to be released
311 static void fc_exch_release(struct fc_exch *ep)
315 if (atomic_dec_and_test(&ep->ex_refcnt)) {
316 mp = ep->em;
317 if (ep->destructor)
318 ep->destructor(&ep->seq, ep->arg);
319 WARN_ON(!(ep->esb_stat & ESB_ST_COMPLETE));
320 mempool_free(ep, mp->ep_pool);
326 * @ep: The exchange whose timer to be canceled
328 static inline void fc_exch_timer_cancel(struct fc_exch *ep)
330 if (cancel_delayed_work(&ep->timeout_work)) {
331 FC_EXCH_DBG(ep, "Exchange timer canceled\n");
332 atomic_dec(&ep->ex_refcnt); /* drop hold for timer */
339 * @ep: The exchange whose timer will start
345 static inline void fc_exch_timer_set_locked(struct fc_exch *ep,
348 if (ep->state & (FC_EX_RST_CLEANUP | FC_EX_DONE))
351 FC_EXCH_DBG(ep, "Exchange timer armed : %d msecs\n", timer_msec);
353 fc_exch_hold(ep); /* hold for timer */
354 if (!queue_delayed_work(fc_exch_workqueue, &ep->timeout_work,
356 FC_EXCH_DBG(ep, "Exchange already queued\n");
357 fc_exch_release(ep);
363 * @ep: The exchange whose timer will start
366 static void fc_exch_timer_set(struct fc_exch *ep, unsigned int timer_msec)
368 spin_lock_bh(&ep->ex_lock);
369 fc_exch_timer_set_locked(ep, timer_msec);
370 spin_unlock_bh(&ep->ex_lock);
375 * @ep: The exchange that is complete
379 static int fc_exch_done_locked(struct fc_exch *ep)
386 * ep, and in that case we only clear the resp and set it as
389 if (ep->state & FC_EX_DONE)
391 ep->esb_stat |= ESB_ST_COMPLETE;
393 if (!(ep->esb_stat & ESB_ST_REC_QUAL)) {
394 ep->state |= FC_EX_DONE;
395 fc_exch_timer_cancel(ep);
423 * @ep: The exchange to assign to the pool
426 struct fc_exch *ep)
428 ((struct fc_exch **)(pool + 1))[index] = ep;
433 * @ep: The exchange to be deleted
435 static void fc_exch_delete(struct fc_exch *ep)
440 pool = ep->pool;
446 index = (ep->xid - ep->em->min_xid) >> fc_cpu_order;
447 if (!(ep->state & FC_EX_QUARANTINE)) {
458 list_del(&ep->ex_list);
460 fc_exch_release(ep); /* drop hold for exch in mp */
466 struct fc_exch *ep;
472 ep = fc_seq_exch(sp);
474 if (ep->esb_stat & (ESB_ST_COMPLETE | ESB_ST_ABNORMAL)) {
479 WARN_ON(!(ep->esb_stat & ESB_ST_SEQ_INIT));
482 fc_exch_setup_hdr(ep, fp, f_ctl);
483 fr_encaps(fp) = ep->encaps;
509 ep->f_ctl = f_ctl & ~FC_FC_FIRST_SEQ; /* not first seq */
511 ep->esb_stat &= ~ESB_ST_SEQ_INIT;
527 struct fc_exch *ep;
529 ep = fc_seq_exch(sp);
530 spin_lock_bh(&ep->ex_lock);
532 spin_unlock_bh(&ep->ex_lock);
539 * @ep: The exchange to allocate a new sequence for
546 static struct fc_seq *fc_seq_alloc(struct fc_exch *ep, u8 seq_id)
550 sp = &ep->seq;
564 struct fc_exch *ep = fc_seq_exch(sp);
566 sp = fc_seq_alloc(ep, ep->seq_id++);
567 FC_EXCH_DBG(ep, "f_ctl %6x seq %2x\n",
568 ep->f_ctl, sp->id);
579 struct fc_exch *ep = fc_seq_exch(sp);
581 spin_lock_bh(&ep->ex_lock);
583 spin_unlock_bh(&ep->ex_lock);
598 struct fc_exch *ep = fc_seq_exch(sp);
601 spin_lock_bh(&ep->ex_lock);
602 while (ep->resp_active && ep->resp_task != current) {
603 prepare_to_wait(&ep->resp_wq, &wait, TASK_UNINTERRUPTIBLE);
604 spin_unlock_bh(&ep->ex_lock);
608 spin_lock_bh(&ep->ex_lock);
610 finish_wait(&ep->resp_wq, &wait);
611 ep->resp = resp;
612 ep->arg = arg;
613 spin_unlock_bh(&ep->ex_lock);
619 * @ep: The exchange to be aborted
633 static int fc_exch_abort_locked(struct fc_exch *ep,
640 FC_EXCH_DBG(ep, "exch: abort, time %d msecs\n", timer_msec);
641 if (ep->esb_stat & (ESB_ST_COMPLETE | ESB_ST_ABNORMAL) ||
642 ep->state & (FC_EX_DONE | FC_EX_RST_CLEANUP)) {
643 FC_EXCH_DBG(ep, "exch: already completed esb %x state %x\n",
644 ep->esb_stat, ep->state);
651 sp = fc_seq_start_next_locked(&ep->seq);
656 fc_exch_timer_set_locked(ep, timer_msec);
658 if (ep->sid) {
662 fp = fc_frame_alloc(ep->lp, 0);
664 ep->esb_stat |= ESB_ST_SEQ_INIT;
665 fc_fill_fc_hdr(fp, FC_RCTL_BA_ABTS, ep->did, ep->sid,
668 error = fc_seq_send_locked(ep->lp, sp, fp);
679 ep->esb_stat |= ESB_ST_ABNORMAL;
694 struct fc_exch *ep;
697 ep = fc_seq_exch(req_sp);
698 spin_lock_bh(&ep->ex_lock);
699 error = fc_exch_abort_locked(ep, timer_msec);
700 spin_unlock_bh(&ep->ex_lock);
705 * fc_invoke_resp() - invoke ep->resp()
706 * @ep: The exchange to be operated on
712 * first unlock of ex_lock after fc_exch_alloc()) ep->resp and ep->arg are
714 * two variables changes if ep->resp_active > 0.
716 * If an fc_seq_set_resp() call is busy modifying ep->resp and ep->arg when
721 * ep->resp() won't be invoked after fc_exch_done() has returned.
724 * ep->resp pointer.
727 * Returns true if and only if ep->resp has been invoked.
729 static bool fc_invoke_resp(struct fc_exch *ep, struct fc_seq *sp,
736 spin_lock_bh(&ep->ex_lock);
737 ep->resp_active++;
738 if (ep->resp_task != current)
739 ep->resp_task = !ep->resp_task ? current : NULL;
740 resp = ep->resp;
741 arg = ep->arg;
742 spin_unlock_bh(&ep->ex_lock);
749 spin_lock_bh(&ep->ex_lock);
750 if (--ep->resp_active == 0)
751 ep->resp_task = NULL;
752 spin_unlock_bh(&ep->ex_lock);
754 if (ep->resp_active == 0)
755 wake_up(&ep->resp_wq);
766 struct fc_exch *ep = container_of(work, struct fc_exch,
768 struct fc_seq *sp = &ep->seq;
772 FC_EXCH_DBG(ep, "Exchange timed out state %x\n", ep->state);
774 spin_lock_bh(&ep->ex_lock);
775 if (ep->state & (FC_EX_RST_CLEANUP | FC_EX_DONE))
778 e_stat = ep->esb_stat;
780 ep->esb_stat = e_stat & ~ESB_ST_REC_QUAL;
781 spin_unlock_bh(&ep->ex_lock);
783 fc_exch_rrq(ep);
787 rc = fc_exch_done_locked(ep);
788 spin_unlock_bh(&ep->ex_lock);
790 fc_exch_delete(ep);
791 fc_invoke_resp(ep, sp, ERR_PTR(-FC_EX_TIMEOUT));
792 fc_seq_set_resp(sp, NULL, ep->arg);
793 fc_seq_exch_abort(sp, 2 * ep->r_a_tov);
797 spin_unlock_bh(&ep->ex_lock);
802 fc_exch_release(ep);
815 struct fc_exch *ep;
821 ep = mempool_alloc(mp->ep_pool, GFP_ATOMIC);
822 if (!ep) {
826 memset(ep, 0, sizeof(*ep));
857 fc_exch_hold(ep); /* hold for exch in mp */
858 spin_lock_init(&ep->ex_lock);
864 spin_lock_bh(&ep->ex_lock);
866 fc_exch_ptr_set(pool, index, ep);
867 list_add_tail(&ep->ex_list, &pool->ex_list);
868 fc_seq_alloc(ep, ep->seq_id++);
875 ep->oxid = ep->xid = (index << fc_cpu_order | cpu) + mp->min_xid;
876 ep->em = mp;
877 ep->pool = pool;
878 ep->lp = lport;
879 ep->f_ctl = FC_FC_FIRST_SEQ; /* next seq is first seq */
880 ep->rxid = FC_XID_UNKNOWN;
881 ep->class = mp->class;
882 ep->resp_active = 0;
883 init_waitqueue_head(&ep->resp_wq);
884 INIT_DELAYED_WORK(&ep->timeout_work, fc_exch_timeout);
886 return ep;
890 mempool_free(ep, mp->ep_pool);
909 struct fc_exch *ep;
913 ep = fc_exch_em_alloc(lport, ema->mp);
914 if (ep)
915 return ep;
930 struct fc_exch *ep = NULL;
945 ep = fc_exch_ptr_get(pool, (xid - mp->min_xid) >> fc_cpu_order);
946 if (ep == &fc_quarantine_exch) {
948 ep = NULL;
950 if (ep) {
951 WARN_ON(ep->xid != xid);
952 fc_exch_hold(ep);
956 return ep;
969 struct fc_exch *ep = fc_seq_exch(sp);
972 spin_lock_bh(&ep->ex_lock);
973 rc = fc_exch_done_locked(ep);
974 spin_unlock_bh(&ep->ex_lock);
976 fc_seq_set_resp(sp, NULL, ep->arg);
978 fc_exch_delete(ep);
994 struct fc_exch *ep;
997 ep = fc_exch_alloc(lport, fp);
998 if (ep) {
999 ep->class = fc_frame_class(fp);
1004 ep->f_ctl |= FC_FC_EX_CTX; /* we're responding */
1005 ep->f_ctl &= ~FC_FC_FIRST_SEQ; /* not new */
1007 ep->sid = ntoh24(fh->fh_d_id);
1008 ep->did = ntoh24(fh->fh_s_id);
1009 ep->oid = ep->did;
1016 ep->rxid = ep->xid;
1017 ep->oxid = ntohs(fh->fh_ox_id);
1018 ep->esb_stat |= ESB_ST_RESP | ESB_ST_SEQ_INIT;
1020 ep->esb_stat &= ~ESB_ST_SEQ_INIT;
1022 fc_exch_hold(ep); /* hold for caller */
1023 spin_unlock_bh(&ep->ex_lock); /* lock from fc_exch_alloc */
1025 return ep;
1036 * on the ep that should be released by the caller.
1043 struct fc_exch *ep = NULL;
1057 ep = fc_exch_find(mp, xid);
1058 if (!ep) {
1063 if (ep->rxid == FC_XID_UNKNOWN)
1064 ep->rxid = ntohs(fh->fh_rx_id);
1065 else if (ep->rxid != ntohs(fh->fh_rx_id)) {
1086 ep = fc_exch_find(mp, xid);
1088 if (ep) {
1093 ep = fc_exch_resp(lport, mp, fp);
1094 if (!ep) {
1098 xid = ep->xid; /* get our XID */
1099 } else if (!ep) {
1106 spin_lock_bh(&ep->ex_lock);
1112 sp = &ep->seq;
1116 sp = &ep->seq;
1137 spin_unlock_bh(&ep->ex_lock);
1145 WARN_ON(ep != fc_seq_exch(sp));
1148 ep->esb_stat |= ESB_ST_SEQ_INIT;
1149 spin_unlock_bh(&ep->ex_lock);
1155 fc_exch_done(&ep->seq);
1156 fc_exch_release(ep); /* hold from fc_exch_find/fc_exch_resp */
1172 struct fc_exch *ep;
1180 ep = fc_exch_find(mp, xid);
1181 if (!ep)
1183 if (ep->seq.id == fh->fh_seq_id) {
1187 sp = &ep->seq;
1189 ep->rxid == FC_XID_UNKNOWN) {
1190 ep->rxid = ntohs(fh->fh_rx_id);
1193 fc_exch_release(ep);
1199 * @ep: The exchange to set the addresses for
1205 static void fc_exch_set_addr(struct fc_exch *ep,
1208 ep->oid = orig_id;
1209 if (ep->esb_stat & ESB_ST_RESP) {
1210 ep->sid = resp_id;
1211 ep->did = orig_id;
1213 ep->sid = orig_id;
1214 ep->did = resp_id;
1260 struct fc_exch *ep = fc_seq_exch(sp);
1263 f_ctl |= ep->f_ctl;
1264 fc_fill_fc_hdr(fp, rctl, ep->did, ep->sid, fh_type, f_ctl, 0);
1265 fc_seq_send_locked(ep->lp, sp, fp);
1280 struct fc_exch *ep = fc_seq_exch(sp);
1281 struct fc_lport *lport = ep->lp;
1290 FC_EXCH_DBG(ep, "Drop ACK request, out of memory\n");
1314 fc_exch_setup_hdr(ep, fp, f_ctl);
1404 * @ep: The exchange the abort was on
1411 static void fc_exch_recv_abts(struct fc_exch *ep, struct fc_frame *rx_fp)
1418 if (!ep)
1421 FC_EXCH_DBG(ep, "exch: ABTS received\n");
1422 fp = fc_frame_alloc(ep->lp, sizeof(*ap));
1424 FC_EXCH_DBG(ep, "Drop ABTS request, out of memory\n");
1428 spin_lock_bh(&ep->ex_lock);
1429 if (ep->esb_stat & ESB_ST_COMPLETE) {
1430 spin_unlock_bh(&ep->ex_lock);
1431 FC_EXCH_DBG(ep, "exch: ABTS rejected, exchange complete\n");
1435 if (!(ep->esb_stat & ESB_ST_REC_QUAL)) {
1436 ep->esb_stat |= ESB_ST_REC_QUAL;
1437 fc_exch_hold(ep); /* hold for REC_QUAL */
1439 fc_exch_timer_set_locked(ep, ep->r_a_tov);
1443 sp = &ep->seq;
1453 ep->esb_stat |= ESB_ST_ABNORMAL;
1454 spin_unlock_bh(&ep->ex_lock);
1514 struct fc_exch *ep = NULL;
1539 ep = fc_seq_exch(sp);
1541 ep->encaps = fr_encaps(fp);
1554 if (!fc_invoke_resp(ep, sp, fp))
1556 fc_exch_release(ep); /* release from lookup */
1575 struct fc_exch *ep;
1580 ep = fc_exch_find(mp, ntohs(fh->fh_ox_id));
1581 if (!ep) {
1585 if (ep->esb_stat & ESB_ST_COMPLETE) {
1589 if (ep->rxid == FC_XID_UNKNOWN)
1590 ep->rxid = ntohs(fh->fh_rx_id);
1591 if (ep->sid != 0 && ep->sid != ntoh24(fh->fh_d_id)) {
1595 if (ep->did != ntoh24(fh->fh_s_id) &&
1596 ep->did != FC_FID_FLOGI) {
1601 sp = &ep->seq;
1610 spin_lock_bh(&ep->ex_lock);
1612 ep->esb_stat |= ESB_ST_SEQ_INIT;
1613 spin_unlock_bh(&ep->ex_lock);
1621 spin_lock_bh(&ep->ex_lock);
1622 rc = fc_exch_done_locked(ep);
1623 WARN_ON(fc_seq_exch(sp) != ep);
1624 spin_unlock_bh(&ep->ex_lock);
1626 fc_exch_delete(ep);
1628 FC_EXCH_DBG(ep, "ep is completed already,"
1647 if (!fc_invoke_resp(ep, sp, fp))
1651 fc_exch_release(ep);
1654 fc_exch_release(ep);
1681 * @ep: The exchange that the frame is on
1687 static void fc_exch_abts_resp(struct fc_exch *ep, struct fc_frame *fp)
1697 FC_EXCH_DBG(ep, "exch: BLS rctl %x - %s\n", fh->fh_r_ctl,
1700 if (cancel_delayed_work_sync(&ep->timeout_work)) {
1701 FC_EXCH_DBG(ep, "Exchange timer canceled due to ABTS response\n");
1702 fc_exch_release(ep); /* release from pending timer hold */
1706 spin_lock_bh(&ep->ex_lock);
1720 if ((ep->esb_stat & ESB_ST_REC_QUAL) == 0 &&
1722 ap->ba_seq_id == ep->seq_id) && low != high) {
1723 ep->esb_stat |= ESB_ST_REC_QUAL;
1724 fc_exch_hold(ep); /* hold for recovery qualifier */
1737 sp = &ep->seq;
1741 if (ep->fh_type != FC_TYPE_FCP &&
1743 rc = fc_exch_done_locked(ep);
1744 spin_unlock_bh(&ep->ex_lock);
1746 fc_exch_hold(ep);
1748 fc_exch_delete(ep);
1749 if (!fc_invoke_resp(ep, sp, fp))
1752 fc_exch_timer_set(ep, ep->r_a_tov);
1753 fc_exch_release(ep);
1767 struct fc_exch *ep;
1774 ep = fc_exch_find(mp, (f_ctl & FC_FC_EX_CTX) ?
1776 if (ep && (f_ctl & FC_FC_SEQ_INIT)) {
1777 spin_lock_bh(&ep->ex_lock);
1778 ep->esb_stat |= ESB_ST_SEQ_INIT;
1779 spin_unlock_bh(&ep->ex_lock);
1791 if (ep)
1792 FC_EXCH_DBG(ep, "BLS rctl %x - %s received\n",
1802 if (ep)
1803 fc_exch_abts_resp(ep, fp);
1808 if (ep)
1809 fc_exch_recv_abts(ep, fp);
1818 if (ep)
1819 fc_exch_release(ep); /* release hold taken by fc_exch_find */
1887 * @ep: The exchange to be reset
1891 static void fc_exch_reset(struct fc_exch *ep)
1896 spin_lock_bh(&ep->ex_lock);
1897 ep->state |= FC_EX_RST_CLEANUP;
1898 fc_exch_timer_cancel(ep);
1899 if (ep->esb_stat & ESB_ST_REC_QUAL)
1900 atomic_dec(&ep->ex_refcnt); /* drop hold for rec_qual */
1901 ep->esb_stat &= ~ESB_ST_REC_QUAL;
1902 sp = &ep->seq;
1903 rc = fc_exch_done_locked(ep);
1904 spin_unlock_bh(&ep->ex_lock);
1906 fc_exch_hold(ep);
1909 fc_exch_delete(ep);
1911 FC_EXCH_DBG(ep, "ep is completed already,"
1916 fc_invoke_resp(ep, sp, ERR_PTR(-FC_EX_CLOSED));
1918 fc_seq_set_resp(sp, NULL, ep->arg);
1919 fc_exch_release(ep);
1938 struct fc_exch *ep;
1943 list_for_each_entry_safe(ep, next, &pool->ex_list, ex_list) {
1944 if ((lport == ep->lp) &&
1945 (sid == 0 || sid == ep->sid) &&
1946 (did == 0 || did == ep->did)) {
1947 fc_exch_hold(ep);
1950 fc_exch_reset(ep);
1952 fc_exch_release(ep);
2020 struct fc_exch *ep;
2048 ep = fc_exch_lookup(lport, xid);
2049 if (!ep) {
2055 FC_EXCH_DBG(ep, "REC request from %x: rxid %x oxid %x\n",
2057 if (ep->oid != sid || oxid != ep->oxid)
2059 if (rxid != FC_XID_UNKNOWN && rxid != ep->rxid)
2063 FC_EXCH_DBG(ep, "Drop REC request, out of memory\n");
2072 acc->reca_rx_id = htons(ep->rxid);
2073 if (ep->sid == ep->oid)
2074 hton24(acc->reca_rfid, ep->did);
2076 hton24(acc->reca_rfid, ep->sid);
2077 acc->reca_fc4value = htonl(ep->seq.rec_data);
2078 acc->reca_e_stat = htonl(ep->esb_stat & (ESB_ST_RESP |
2084 fc_exch_release(ep);
2088 fc_exch_release(ep);
2183 struct fc_exch *ep;
2189 ep = fc_exch_alloc(lport, fp);
2190 if (!ep) {
2194 ep->esb_stat |= ESB_ST_SEQ_INIT;
2196 fc_exch_set_addr(ep, ntoh24(fh->fh_s_id), ntoh24(fh->fh_d_id));
2197 ep->resp = resp;
2198 ep->destructor = destructor;
2199 ep->arg = arg;
2200 ep->r_a_tov = lport->r_a_tov;
2201 ep->lp = lport;
2202 sp = &ep->seq;
2204 ep->fh_type = fh->fh_type; /* save for possbile timeout handling */
2205 ep->f_ctl = ntoh24(fh->fh_f_ctl);
2206 fc_exch_setup_hdr(ep, fp, ep->f_ctl);
2209 if (ep->xid <= lport->lro_xid && fh->fh_r_ctl == FC_RCTL_DD_UNSOL_CMD) {
2211 fc_fcp_ddp_setup(fr_fsp(fp), ep->xid);
2218 fc_exch_timer_set_locked(ep, timer_msec);
2219 ep->f_ctl &= ~FC_FC_FIRST_SEQ; /* not first seq */
2221 if (ep->f_ctl & FC_FC_SEQ_INIT)
2222 ep->esb_stat &= ~ESB_ST_SEQ_INIT;
2223 spin_unlock_bh(&ep->ex_lock);
2228 rc = fc_exch_done_locked(ep);
2229 spin_unlock_bh(&ep->ex_lock);
2231 fc_exch_delete(ep);
2238 * @ep: The exchange to send the RRQ on
2243 static void fc_exch_rrq(struct fc_exch *ep)
2250 lport = ep->lp;
2259 hton24(rrq->rrq_s_id, ep->sid);
2260 rrq->rrq_ox_id = htons(ep->oxid);
2261 rrq->rrq_rx_id = htons(ep->rxid);
2263 did = ep->did;
2264 if (ep->esb_stat & ESB_ST_RESP)
2265 did = ep->sid;
2271 if (fc_exch_seq_send(lport, fp, fc_exch_rrq_resp, NULL, ep,
2276 FC_EXCH_DBG(ep, "exch: RRQ send failed\n");
2277 spin_lock_bh(&ep->ex_lock);
2278 if (ep->state & (FC_EX_RST_CLEANUP | FC_EX_DONE)) {
2279 spin_unlock_bh(&ep->ex_lock);
2281 fc_exch_release(ep);
2284 ep->esb_stat |= ESB_ST_REC_QUAL;
2285 fc_exch_timer_set_locked(ep, ep->r_a_tov);
2286 spin_unlock_bh(&ep->ex_lock);
2296 struct fc_exch *ep = NULL; /* request or subject exchange */
2314 ep = fc_exch_lookup(lport, xid);
2316 if (!ep)
2318 spin_lock_bh(&ep->ex_lock);
2319 FC_EXCH_DBG(ep, "RRQ request from %x: xid %x rxid %x oxid %x\n",
2321 if (ep->oxid != ntohs(rp->rrq_ox_id))
2323 if (ep->rxid != ntohs(rp->rrq_rx_id) &&
2324 ep->rxid != FC_XID_UNKNOWN)
2327 if (ep->sid != sid)
2333 if (ep->esb_stat & ESB_ST_REC_QUAL) {
2334 ep->esb_stat &= ~ESB_ST_REC_QUAL;
2335 atomic_dec(&ep->ex_refcnt); /* drop hold for rec qual */
2337 if (ep->esb_stat & ESB_ST_COMPLETE)
2338 fc_exch_timer_cancel(ep);
2340 spin_unlock_bh(&ep->ex_lock);
2349 spin_unlock_bh(&ep->ex_lock);
2353 if (ep)
2354 fc_exch_release(ep); /* drop hold from fc_exch_find */