Lines Matching refs:ep
246 * @ep: Echange to be held
248 static inline void fc_exch_hold(struct fc_exch *ep)
250 atomic_inc(&ep->ex_refcnt);
256 * @ep: The exchange to that will use the header
263 static void fc_exch_setup_hdr(struct fc_exch *ep, struct fc_frame *fp,
269 fr_sof(fp) = ep->class;
270 if (ep->seq.cnt)
271 fr_sof(fp) = fc_sof_normal(ep->class);
275 if (fc_sof_needs_ack(ep->class))
299 fh->fh_ox_id = htons(ep->oxid);
300 fh->fh_rx_id = htons(ep->rxid);
301 fh->fh_seq_id = ep->seq.id;
302 fh->fh_seq_cnt = htons(ep->seq.cnt);
307 * @ep: Exchange to be released
312 static void fc_exch_release(struct fc_exch *ep)
316 if (atomic_dec_and_test(&ep->ex_refcnt)) {
317 mp = ep->em;
318 if (ep->destructor)
319 ep->destructor(&ep->seq, ep->arg);
320 WARN_ON(!(ep->esb_stat & ESB_ST_COMPLETE));
321 mempool_free(ep, mp->ep_pool);
327 * @ep: The exchange whose timer to be canceled
329 static inline void fc_exch_timer_cancel(struct fc_exch *ep)
331 if (cancel_delayed_work(&ep->timeout_work)) {
332 FC_EXCH_DBG(ep, "Exchange timer canceled\n");
333 atomic_dec(&ep->ex_refcnt); /* drop hold for timer */
340 * @ep: The exchange whose timer will start
346 static inline void fc_exch_timer_set_locked(struct fc_exch *ep,
349 if (ep->state & (FC_EX_RST_CLEANUP | FC_EX_DONE))
352 FC_EXCH_DBG(ep, "Exchange timer armed : %d msecs\n", timer_msec);
354 fc_exch_hold(ep); /* hold for timer */
355 if (!queue_delayed_work(fc_exch_workqueue, &ep->timeout_work,
357 FC_EXCH_DBG(ep, "Exchange already queued\n");
358 fc_exch_release(ep);
364 * @ep: The exchange whose timer will start
367 static void fc_exch_timer_set(struct fc_exch *ep, unsigned int timer_msec)
369 spin_lock_bh(&ep->ex_lock);
370 fc_exch_timer_set_locked(ep, timer_msec);
371 spin_unlock_bh(&ep->ex_lock);
376 * @ep: The exchange that is complete
380 static int fc_exch_done_locked(struct fc_exch *ep)
387 * ep, and in that case we only clear the resp and set it as
390 if (ep->state & FC_EX_DONE)
392 ep->esb_stat |= ESB_ST_COMPLETE;
394 if (!(ep->esb_stat & ESB_ST_REC_QUAL)) {
395 ep->state |= FC_EX_DONE;
396 fc_exch_timer_cancel(ep);
424 * @ep: The exchange to assign to the pool
427 struct fc_exch *ep)
429 ((struct fc_exch **)(pool + 1))[index] = ep;
434 * @ep: The exchange to be deleted
436 static void fc_exch_delete(struct fc_exch *ep)
441 pool = ep->pool;
447 index = (ep->xid - ep->em->min_xid) >> fc_cpu_order;
448 if (!(ep->state & FC_EX_QUARANTINE)) {
459 list_del(&ep->ex_list);
461 fc_exch_release(ep); /* drop hold for exch in mp */
467 struct fc_exch *ep;
473 ep = fc_seq_exch(sp);
475 if (ep->esb_stat & (ESB_ST_COMPLETE | ESB_ST_ABNORMAL)) {
480 WARN_ON(!(ep->esb_stat & ESB_ST_SEQ_INIT));
483 fc_exch_setup_hdr(ep, fp, f_ctl);
484 fr_encaps(fp) = ep->encaps;
510 ep->f_ctl = f_ctl & ~FC_FC_FIRST_SEQ; /* not first seq */
512 ep->esb_stat &= ~ESB_ST_SEQ_INIT;
528 struct fc_exch *ep;
530 ep = fc_seq_exch(sp);
531 spin_lock_bh(&ep->ex_lock);
533 spin_unlock_bh(&ep->ex_lock);
540 * @ep: The exchange to allocate a new sequence for
547 static struct fc_seq *fc_seq_alloc(struct fc_exch *ep, u8 seq_id)
551 sp = &ep->seq;
565 struct fc_exch *ep = fc_seq_exch(sp);
567 sp = fc_seq_alloc(ep, ep->seq_id++);
568 FC_EXCH_DBG(ep, "f_ctl %6x seq %2x\n",
569 ep->f_ctl, sp->id);
580 struct fc_exch *ep = fc_seq_exch(sp);
582 spin_lock_bh(&ep->ex_lock);
584 spin_unlock_bh(&ep->ex_lock);
599 struct fc_exch *ep = fc_seq_exch(sp);
602 spin_lock_bh(&ep->ex_lock);
603 while (ep->resp_active && ep->resp_task != current) {
604 prepare_to_wait(&ep->resp_wq, &wait, TASK_UNINTERRUPTIBLE);
605 spin_unlock_bh(&ep->ex_lock);
609 spin_lock_bh(&ep->ex_lock);
611 finish_wait(&ep->resp_wq, &wait);
612 ep->resp = resp;
613 ep->arg = arg;
614 spin_unlock_bh(&ep->ex_lock);
620 * @ep: The exchange to be aborted
634 static int fc_exch_abort_locked(struct fc_exch *ep,
641 FC_EXCH_DBG(ep, "exch: abort, time %d msecs\n", timer_msec);
642 if (ep->esb_stat & (ESB_ST_COMPLETE | ESB_ST_ABNORMAL) ||
643 ep->state & (FC_EX_DONE | FC_EX_RST_CLEANUP)) {
644 FC_EXCH_DBG(ep, "exch: already completed esb %x state %x\n",
645 ep->esb_stat, ep->state);
652 sp = fc_seq_start_next_locked(&ep->seq);
657 fc_exch_timer_set_locked(ep, timer_msec);
659 if (ep->sid) {
663 fp = fc_frame_alloc(ep->lp, 0);
665 ep->esb_stat |= ESB_ST_SEQ_INIT;
666 fc_fill_fc_hdr(fp, FC_RCTL_BA_ABTS, ep->did, ep->sid,
669 error = fc_seq_send_locked(ep->lp, sp, fp);
680 ep->esb_stat |= ESB_ST_ABNORMAL;
695 struct fc_exch *ep;
698 ep = fc_seq_exch(req_sp);
699 spin_lock_bh(&ep->ex_lock);
700 error = fc_exch_abort_locked(ep, timer_msec);
701 spin_unlock_bh(&ep->ex_lock);
706 * fc_invoke_resp() - invoke ep->resp()
707 * @ep: The exchange to be operated on
713 * first unlock of ex_lock after fc_exch_alloc()) ep->resp and ep->arg are
715 * two variables changes if ep->resp_active > 0.
717 * If an fc_seq_set_resp() call is busy modifying ep->resp and ep->arg when
722 * ep->resp() won't be invoked after fc_exch_done() has returned.
725 * ep->resp pointer.
728 * Returns true if and only if ep->resp has been invoked.
730 static bool fc_invoke_resp(struct fc_exch *ep, struct fc_seq *sp,
737 spin_lock_bh(&ep->ex_lock);
738 ep->resp_active++;
739 if (ep->resp_task != current)
740 ep->resp_task = !ep->resp_task ? current : NULL;
741 resp = ep->resp;
742 arg = ep->arg;
743 spin_unlock_bh(&ep->ex_lock);
750 spin_lock_bh(&ep->ex_lock);
751 if (--ep->resp_active == 0)
752 ep->resp_task = NULL;
753 spin_unlock_bh(&ep->ex_lock);
755 if (ep->resp_active == 0)
756 wake_up(&ep->resp_wq);
767 struct fc_exch *ep = container_of(work, struct fc_exch,
769 struct fc_seq *sp = &ep->seq;
773 FC_EXCH_DBG(ep, "Exchange timed out state %x\n", ep->state);
775 spin_lock_bh(&ep->ex_lock);
776 if (ep->state & (FC_EX_RST_CLEANUP | FC_EX_DONE))
779 e_stat = ep->esb_stat;
781 ep->esb_stat = e_stat & ~ESB_ST_REC_QUAL;
782 spin_unlock_bh(&ep->ex_lock);
784 fc_exch_rrq(ep);
788 rc = fc_exch_done_locked(ep);
789 spin_unlock_bh(&ep->ex_lock);
791 fc_exch_delete(ep);
792 fc_invoke_resp(ep, sp, ERR_PTR(-FC_EX_TIMEOUT));
793 fc_seq_set_resp(sp, NULL, ep->arg);
794 fc_seq_exch_abort(sp, 2 * ep->r_a_tov);
798 spin_unlock_bh(&ep->ex_lock);
803 fc_exch_release(ep);
816 struct fc_exch *ep;
822 ep = mempool_alloc(mp->ep_pool, GFP_ATOMIC);
823 if (!ep) {
827 memset(ep, 0, sizeof(*ep));
859 fc_exch_hold(ep); /* hold for exch in mp */
860 spin_lock_init(&ep->ex_lock);
866 spin_lock_bh(&ep->ex_lock);
868 fc_exch_ptr_set(pool, index, ep);
869 list_add_tail(&ep->ex_list, &pool->ex_list);
870 fc_seq_alloc(ep, ep->seq_id++);
877 ep->oxid = ep->xid = (index << fc_cpu_order | cpu) + mp->min_xid;
878 ep->em = mp;
879 ep->pool = pool;
880 ep->lp = lport;
881 ep->f_ctl = FC_FC_FIRST_SEQ; /* next seq is first seq */
882 ep->rxid = FC_XID_UNKNOWN;
883 ep->class = mp->class;
884 ep->resp_active = 0;
885 init_waitqueue_head(&ep->resp_wq);
886 INIT_DELAYED_WORK(&ep->timeout_work, fc_exch_timeout);
888 return ep;
892 mempool_free(ep, mp->ep_pool);
911 struct fc_exch *ep;
915 ep = fc_exch_em_alloc(lport, ema->mp);
916 if (ep)
917 return ep;
932 struct fc_exch *ep = NULL;
947 ep = fc_exch_ptr_get(pool, (xid - mp->min_xid) >> fc_cpu_order);
948 if (ep == &fc_quarantine_exch) {
950 ep = NULL;
952 if (ep) {
953 WARN_ON(ep->xid != xid);
954 fc_exch_hold(ep);
958 return ep;
971 struct fc_exch *ep = fc_seq_exch(sp);
974 spin_lock_bh(&ep->ex_lock);
975 rc = fc_exch_done_locked(ep);
976 spin_unlock_bh(&ep->ex_lock);
978 fc_seq_set_resp(sp, NULL, ep->arg);
980 fc_exch_delete(ep);
996 struct fc_exch *ep;
999 ep = fc_exch_alloc(lport, fp);
1000 if (ep) {
1001 ep->class = fc_frame_class(fp);
1006 ep->f_ctl |= FC_FC_EX_CTX; /* we're responding */
1007 ep->f_ctl &= ~FC_FC_FIRST_SEQ; /* not new */
1009 ep->sid = ntoh24(fh->fh_d_id);
1010 ep->did = ntoh24(fh->fh_s_id);
1011 ep->oid = ep->did;
1018 ep->rxid = ep->xid;
1019 ep->oxid = ntohs(fh->fh_ox_id);
1020 ep->esb_stat |= ESB_ST_RESP | ESB_ST_SEQ_INIT;
1022 ep->esb_stat &= ~ESB_ST_SEQ_INIT;
1024 fc_exch_hold(ep); /* hold for caller */
1025 spin_unlock_bh(&ep->ex_lock); /* lock from fc_exch_alloc */
1027 return ep;
1038 * on the ep that should be released by the caller.
1045 struct fc_exch *ep = NULL;
1059 ep = fc_exch_find(mp, xid);
1060 if (!ep) {
1065 if (ep->rxid == FC_XID_UNKNOWN)
1066 ep->rxid = ntohs(fh->fh_rx_id);
1067 else if (ep->rxid != ntohs(fh->fh_rx_id)) {
1088 ep = fc_exch_find(mp, xid);
1090 if (ep) {
1095 ep = fc_exch_resp(lport, mp, fp);
1096 if (!ep) {
1100 xid = ep->xid; /* get our XID */
1101 } else if (!ep) {
1108 spin_lock_bh(&ep->ex_lock);
1114 sp = &ep->seq;
1118 sp = &ep->seq;
1139 spin_unlock_bh(&ep->ex_lock);
1147 WARN_ON(ep != fc_seq_exch(sp));
1150 ep->esb_stat |= ESB_ST_SEQ_INIT;
1151 spin_unlock_bh(&ep->ex_lock);
1157 fc_exch_done(&ep->seq);
1158 fc_exch_release(ep); /* hold from fc_exch_find/fc_exch_resp */
1174 struct fc_exch *ep;
1182 ep = fc_exch_find(mp, xid);
1183 if (!ep)
1185 if (ep->seq.id == fh->fh_seq_id) {
1189 sp = &ep->seq;
1191 ep->rxid == FC_XID_UNKNOWN) {
1192 ep->rxid = ntohs(fh->fh_rx_id);
1195 fc_exch_release(ep);
1201 * @ep: The exchange to set the addresses for
1207 static void fc_exch_set_addr(struct fc_exch *ep,
1210 ep->oid = orig_id;
1211 if (ep->esb_stat & ESB_ST_RESP) {
1212 ep->sid = resp_id;
1213 ep->did = orig_id;
1215 ep->sid = orig_id;
1216 ep->did = resp_id;
1262 struct fc_exch *ep = fc_seq_exch(sp);
1265 f_ctl |= ep->f_ctl;
1266 fc_fill_fc_hdr(fp, rctl, ep->did, ep->sid, fh_type, f_ctl, 0);
1267 fc_seq_send_locked(ep->lp, sp, fp);
1282 struct fc_exch *ep = fc_seq_exch(sp);
1283 struct fc_lport *lport = ep->lp;
1292 FC_EXCH_DBG(ep, "Drop ACK request, out of memory\n");
1316 fc_exch_setup_hdr(ep, fp, f_ctl);
1406 * @ep: The exchange the abort was on
1413 static void fc_exch_recv_abts(struct fc_exch *ep, struct fc_frame *rx_fp)
1420 if (!ep)
1423 FC_EXCH_DBG(ep, "exch: ABTS received\n");
1424 fp = fc_frame_alloc(ep->lp, sizeof(*ap));
1426 FC_EXCH_DBG(ep, "Drop ABTS request, out of memory\n");
1430 spin_lock_bh(&ep->ex_lock);
1431 if (ep->esb_stat & ESB_ST_COMPLETE) {
1432 spin_unlock_bh(&ep->ex_lock);
1433 FC_EXCH_DBG(ep, "exch: ABTS rejected, exchange complete\n");
1437 if (!(ep->esb_stat & ESB_ST_REC_QUAL)) {
1438 ep->esb_stat |= ESB_ST_REC_QUAL;
1439 fc_exch_hold(ep); /* hold for REC_QUAL */
1441 fc_exch_timer_set_locked(ep, ep->r_a_tov);
1445 sp = &ep->seq;
1455 ep->esb_stat |= ESB_ST_ABNORMAL;
1456 spin_unlock_bh(&ep->ex_lock);
1516 struct fc_exch *ep = NULL;
1541 ep = fc_seq_exch(sp);
1543 ep->encaps = fr_encaps(fp);
1556 if (!fc_invoke_resp(ep, sp, fp))
1558 fc_exch_release(ep); /* release from lookup */
1577 struct fc_exch *ep;
1582 ep = fc_exch_find(mp, ntohs(fh->fh_ox_id));
1583 if (!ep) {
1587 if (ep->esb_stat & ESB_ST_COMPLETE) {
1591 if (ep->rxid == FC_XID_UNKNOWN)
1592 ep->rxid = ntohs(fh->fh_rx_id);
1593 if (ep->sid != 0 && ep->sid != ntoh24(fh->fh_d_id)) {
1597 if (ep->did != ntoh24(fh->fh_s_id) &&
1598 ep->did != FC_FID_FLOGI) {
1603 sp = &ep->seq;
1612 spin_lock_bh(&ep->ex_lock);
1614 ep->esb_stat |= ESB_ST_SEQ_INIT;
1615 spin_unlock_bh(&ep->ex_lock);
1623 spin_lock_bh(&ep->ex_lock);
1624 rc = fc_exch_done_locked(ep);
1625 WARN_ON(fc_seq_exch(sp) != ep);
1626 spin_unlock_bh(&ep->ex_lock);
1628 fc_exch_delete(ep);
1630 FC_EXCH_DBG(ep, "ep is completed already,"
1649 if (!fc_invoke_resp(ep, sp, fp))
1653 fc_exch_release(ep);
1656 fc_exch_release(ep);
1683 * @ep: The exchange that the frame is on
1689 static void fc_exch_abts_resp(struct fc_exch *ep, struct fc_frame *fp)
1699 FC_EXCH_DBG(ep, "exch: BLS rctl %x - %s\n", fh->fh_r_ctl,
1702 if (cancel_delayed_work_sync(&ep->timeout_work)) {
1703 FC_EXCH_DBG(ep, "Exchange timer canceled due to ABTS response\n");
1704 fc_exch_release(ep); /* release from pending timer hold */
1708 spin_lock_bh(&ep->ex_lock);
1722 if ((ep->esb_stat & ESB_ST_REC_QUAL) == 0 &&
1724 ap->ba_seq_id == ep->seq_id) && low != high) {
1725 ep->esb_stat |= ESB_ST_REC_QUAL;
1726 fc_exch_hold(ep); /* hold for recovery qualifier */
1739 sp = &ep->seq;
1743 if (ep->fh_type != FC_TYPE_FCP &&
1745 rc = fc_exch_done_locked(ep);
1746 spin_unlock_bh(&ep->ex_lock);
1748 fc_exch_hold(ep);
1750 fc_exch_delete(ep);
1751 if (!fc_invoke_resp(ep, sp, fp))
1754 fc_exch_timer_set(ep, ep->r_a_tov);
1755 fc_exch_release(ep);
1769 struct fc_exch *ep;
1776 ep = fc_exch_find(mp, (f_ctl & FC_FC_EX_CTX) ?
1778 if (ep && (f_ctl & FC_FC_SEQ_INIT)) {
1779 spin_lock_bh(&ep->ex_lock);
1780 ep->esb_stat |= ESB_ST_SEQ_INIT;
1781 spin_unlock_bh(&ep->ex_lock);
1793 if (ep)
1794 FC_EXCH_DBG(ep, "BLS rctl %x - %s received\n",
1804 if (ep)
1805 fc_exch_abts_resp(ep, fp);
1810 if (ep)
1811 fc_exch_recv_abts(ep, fp);
1820 if (ep)
1821 fc_exch_release(ep); /* release hold taken by fc_exch_find */
1889 * @ep: The exchange to be reset
1893 static void fc_exch_reset(struct fc_exch *ep)
1898 spin_lock_bh(&ep->ex_lock);
1899 ep->state |= FC_EX_RST_CLEANUP;
1900 fc_exch_timer_cancel(ep);
1901 if (ep->esb_stat & ESB_ST_REC_QUAL)
1902 atomic_dec(&ep->ex_refcnt); /* drop hold for rec_qual */
1903 ep->esb_stat &= ~ESB_ST_REC_QUAL;
1904 sp = &ep->seq;
1905 rc = fc_exch_done_locked(ep);
1906 spin_unlock_bh(&ep->ex_lock);
1908 fc_exch_hold(ep);
1911 fc_exch_delete(ep);
1913 FC_EXCH_DBG(ep, "ep is completed already,"
1918 fc_invoke_resp(ep, sp, ERR_PTR(-FC_EX_CLOSED));
1920 fc_seq_set_resp(sp, NULL, ep->arg);
1921 fc_exch_release(ep);
1940 struct fc_exch *ep;
1945 list_for_each_entry_safe(ep, next, &pool->ex_list, ex_list) {
1946 if ((lport == ep->lp) &&
1947 (sid == 0 || sid == ep->sid) &&
1948 (did == 0 || did == ep->did)) {
1949 fc_exch_hold(ep);
1952 fc_exch_reset(ep);
1954 fc_exch_release(ep);
2022 struct fc_exch *ep;
2050 ep = fc_exch_lookup(lport, xid);
2051 if (!ep) {
2057 FC_EXCH_DBG(ep, "REC request from %x: rxid %x oxid %x\n",
2059 if (ep->oid != sid || oxid != ep->oxid)
2061 if (rxid != FC_XID_UNKNOWN && rxid != ep->rxid)
2065 FC_EXCH_DBG(ep, "Drop REC request, out of memory\n");
2074 acc->reca_rx_id = htons(ep->rxid);
2075 if (ep->sid == ep->oid)
2076 hton24(acc->reca_rfid, ep->did);
2078 hton24(acc->reca_rfid, ep->sid);
2079 acc->reca_fc4value = htonl(ep->seq.rec_data);
2080 acc->reca_e_stat = htonl(ep->esb_stat & (ESB_ST_RESP |
2086 fc_exch_release(ep);
2090 fc_exch_release(ep);
2185 struct fc_exch *ep;
2191 ep = fc_exch_alloc(lport, fp);
2192 if (!ep) {
2196 ep->esb_stat |= ESB_ST_SEQ_INIT;
2198 fc_exch_set_addr(ep, ntoh24(fh->fh_s_id), ntoh24(fh->fh_d_id));
2199 ep->resp = resp;
2200 ep->destructor = destructor;
2201 ep->arg = arg;
2202 ep->r_a_tov = lport->r_a_tov;
2203 ep->lp = lport;
2204 sp = &ep->seq;
2206 ep->fh_type = fh->fh_type; /* save for possbile timeout handling */
2207 ep->f_ctl = ntoh24(fh->fh_f_ctl);
2208 fc_exch_setup_hdr(ep, fp, ep->f_ctl);
2211 if (ep->xid <= lport->lro_xid && fh->fh_r_ctl == FC_RCTL_DD_UNSOL_CMD) {
2213 fc_fcp_ddp_setup(fr_fsp(fp), ep->xid);
2220 fc_exch_timer_set_locked(ep, timer_msec);
2221 ep->f_ctl &= ~FC_FC_FIRST_SEQ; /* not first seq */
2223 if (ep->f_ctl & FC_FC_SEQ_INIT)
2224 ep->esb_stat &= ~ESB_ST_SEQ_INIT;
2225 spin_unlock_bh(&ep->ex_lock);
2230 rc = fc_exch_done_locked(ep);
2231 spin_unlock_bh(&ep->ex_lock);
2233 fc_exch_delete(ep);
2240 * @ep: The exchange to send the RRQ on
2245 static void fc_exch_rrq(struct fc_exch *ep)
2252 lport = ep->lp;
2261 hton24(rrq->rrq_s_id, ep->sid);
2262 rrq->rrq_ox_id = htons(ep->oxid);
2263 rrq->rrq_rx_id = htons(ep->rxid);
2265 did = ep->did;
2266 if (ep->esb_stat & ESB_ST_RESP)
2267 did = ep->sid;
2273 if (fc_exch_seq_send(lport, fp, fc_exch_rrq_resp, NULL, ep,
2278 FC_EXCH_DBG(ep, "exch: RRQ send failed\n");
2279 spin_lock_bh(&ep->ex_lock);
2280 if (ep->state & (FC_EX_RST_CLEANUP | FC_EX_DONE)) {
2281 spin_unlock_bh(&ep->ex_lock);
2283 fc_exch_release(ep);
2286 ep->esb_stat |= ESB_ST_REC_QUAL;
2287 fc_exch_timer_set_locked(ep, ep->r_a_tov);
2288 spin_unlock_bh(&ep->ex_lock);
2298 struct fc_exch *ep = NULL; /* request or subject exchange */
2316 ep = fc_exch_lookup(lport, xid);
2318 if (!ep)
2320 spin_lock_bh(&ep->ex_lock);
2321 FC_EXCH_DBG(ep, "RRQ request from %x: xid %x rxid %x oxid %x\n",
2323 if (ep->oxid != ntohs(rp->rrq_ox_id))
2325 if (ep->rxid != ntohs(rp->rrq_rx_id) &&
2326 ep->rxid != FC_XID_UNKNOWN)
2329 if (ep->sid != sid)
2335 if (ep->esb_stat & ESB_ST_REC_QUAL) {
2336 ep->esb_stat &= ~ESB_ST_REC_QUAL;
2337 atomic_dec(&ep->ex_refcnt); /* drop hold for rec qual */
2339 if (ep->esb_stat & ESB_ST_COMPLETE)
2340 fc_exch_timer_cancel(ep);
2342 spin_unlock_bh(&ep->ex_lock);
2351 spin_unlock_bh(&ep->ex_lock);
2355 if (ep)
2356 fc_exch_release(ep); /* drop hold from fc_exch_find */