718cf2ccb9
Mainly focus on files that use BSD 2-Clause license, however the tool I was using misidentified many licenses so this was mostly a manual - error prone - task. The Software Package Data Exchange (SPDX) group provides a specification to make it easier for automated tools to detect and summarize well known opensource licenses. We are gradually adopting the specification, noting that the tags are considered only advisory and do not, in any way, superceed or replace the license texts.
602 lines
14 KiB
C
602 lines
14 KiB
C
/*-
|
|
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
|
|
*
|
|
* Copyright (c) 2005-2011 Daniel Braniss <danny@cs.huji.ac.il>
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
* $FreeBSD$
|
|
*/
|
|
|
|
/*
|
|
| $Id: iscsivar.h 743 2009-08-08 10:54:53Z danny $
|
|
*/
|
|
#define ISCSI_MAX_LUNS 128 // don't touch this
|
|
#if ISCSI_MAX_LUNS > 8
|
|
/*
|
|
| for this to work
|
|
| sysctl kern.cam.cam_srch_hi=1
|
|
*/
|
|
#endif
|
|
|
|
#ifndef ISCSI_INITIATOR_DEBUG
|
|
#define ISCSI_INITIATOR_DEBUG 1
|
|
#endif
|
|
|
|
#ifdef ISCSI_INITIATOR_DEBUG
|
|
extern int iscsi_debug;
|
|
#define debug(level, fmt, args...) do {if(level <= iscsi_debug)\
|
|
printf("%s: " fmt "\n", __func__ , ##args);} while(0)
|
|
#define sdebug(level, fmt, args...) do {if(level <= iscsi_debug)\
|
|
printf("%d] %s: " fmt "\n", sp->sid, __func__ , ##args);} while(0)
|
|
#define debug_called(level) do {if(level <= iscsi_debug)\
|
|
printf("%s: called\n", __func__);} while(0)
|
|
#else
|
|
#define debug(level, fmt, args...)
|
|
#define debug_called(level)
|
|
#define sdebug(level, fmt, args...)
|
|
#endif /* ISCSI_INITIATOR_DEBUG */
|
|
|
|
#define xdebug(fmt, args...) printf(">>> %s: " fmt "\n", __func__ , ##args)
|
|
|
|
#define MAX_SESSIONS ISCSI_MAX_TARGETS
|
|
#define MAX_PDUS (MAX_SESSIONS*256) // XXX: at the moment this is arbitrary
|
|
|
|
typedef uint32_t digest_t(const void *, int len, uint32_t ocrc);
|
|
|
|
MALLOC_DECLARE(M_ISCSI);
|
|
MALLOC_DECLARE(M_ISCSIBUF);
|
|
|
|
#define ISOK2DIG(dig, pp) ((dig != NULL) && ((pp->ipdu.bhs.opcode & 0x1f) != ISCSI_LOGIN_CMD))
|
|
|
|
#ifndef BIT
|
|
#define BIT(n) (1 <<(n))
|
|
#endif
|
|
|
|
#define ISC_SM_RUN BIT(0)
|
|
#define ISC_SM_RUNNING BIT(1)
|
|
|
|
#define ISC_LINK_UP BIT(2)
|
|
#define ISC_CON_RUN BIT(3)
|
|
#define ISC_CON_RUNNING BIT(4)
|
|
#define ISC_KILL BIT(5)
|
|
#define ISC_OQNOTEMPTY BIT(6)
|
|
#define ISC_OWAITING BIT(7)
|
|
#define ISC_FFPHASE BIT(8)
|
|
|
|
#define ISC_CAMDEVS BIT(9)
|
|
#define ISC_SCANWAIT BIT(10)
|
|
|
|
#define ISC_MEMWAIT BIT(11)
|
|
#define ISC_SIGNALED BIT(12)
|
|
|
|
#define ISC_HOLD BIT(15)
|
|
#define ISC_HOLDED BIT(16)
|
|
|
|
#define ISC_SHUTDOWN BIT(31)
|
|
|
|
/*
|
|
| some stats
|
|
*/
|
|
struct i_stats {
|
|
int npdu; // number of pdus malloc'ed.
|
|
int nrecv; // unprocessed received pdus
|
|
int nsent; // sent pdus
|
|
|
|
int nrsp, max_rsp;
|
|
int nrsv, max_rsv;
|
|
int ncsnd, max_csnd;
|
|
int nisnd, max_isnd;
|
|
int nwsnd, max_wsnd;
|
|
int nhld, max_hld;
|
|
|
|
struct bintime t_sent;
|
|
struct bintime t_recv;
|
|
};
|
|
|
|
/*
|
|
| one per 'session'
|
|
*/
|
|
|
|
typedef TAILQ_HEAD(, pduq) queue_t;
|
|
|
|
typedef struct isc_session {
|
|
TAILQ_ENTRY(isc_session) sp_link;
|
|
int flags;
|
|
struct cdev *dev;
|
|
struct socket *soc;
|
|
struct file *fp;
|
|
struct thread *td;
|
|
|
|
struct proc *proc; // the userland process
|
|
int signal;
|
|
struct proc *soc_proc;
|
|
struct proc *stp; // the sm thread
|
|
|
|
struct isc_softc *isc;
|
|
|
|
digest_t *hdrDigest; // the digest alg. if any
|
|
digest_t *dataDigest; // the digest alg. if any
|
|
|
|
int sid; // Session ID
|
|
sn_t sn; // sequence number stuff;
|
|
int cws; // current window size
|
|
|
|
int target_nluns; // this and target_lun are
|
|
// hopefully temporal till I
|
|
// figure out a better way.
|
|
int target_lun[ISCSI_MAX_LUNS/(sizeof(int)*8) + 1];
|
|
|
|
struct mtx rsp_mtx;
|
|
struct mtx rsv_mtx;
|
|
struct mtx snd_mtx;
|
|
struct mtx hld_mtx;
|
|
struct mtx io_mtx;
|
|
queue_t rsp;
|
|
queue_t rsv;
|
|
queue_t csnd;
|
|
queue_t isnd;
|
|
queue_t wsnd;
|
|
queue_t hld;
|
|
|
|
isc_opt_t opt; // negotiable values
|
|
|
|
struct i_stats stats;
|
|
bhs_t bhs;
|
|
struct uio uio;
|
|
struct iovec iov;
|
|
/*
|
|
| cam stuff
|
|
*/
|
|
struct cam_sim *cam_sim;
|
|
struct cam_path *cam_path;
|
|
struct mtx cam_mtx;
|
|
/*
|
|
| sysctl stuff
|
|
*/
|
|
struct sysctl_ctx_list clist;
|
|
struct sysctl_oid *oid;
|
|
int douio; //XXX: turn on/off uio on read
|
|
} isc_session_t;
|
|
|
|
typedef struct pduq {
|
|
TAILQ_ENTRY(pduq) pq_link;
|
|
|
|
caddr_t buf;
|
|
u_int len; // the total length of the pdu
|
|
pdu_t pdu;
|
|
union ccb *ccb;
|
|
|
|
struct uio uio;
|
|
struct iovec iov[5]; // XXX: careful ...
|
|
struct mbuf *mp;
|
|
struct bintime ts;
|
|
queue_t *pduq;
|
|
} pduq_t;
|
|
/*
|
|
*/
|
|
struct isc_softc {
|
|
struct mtx isc_mtx;
|
|
TAILQ_HEAD(,isc_session) isc_sess;
|
|
int nsess;
|
|
struct cdev *dev;
|
|
char isid[6]; // Initiator Session ID (48 bits)
|
|
struct unrhdr *unit;
|
|
struct sx unit_sx;
|
|
|
|
uma_zone_t pdu_zone; // pool of free pdu's
|
|
TAILQ_HEAD(,pduq) freepdu;
|
|
|
|
#ifdef ISCSI_INITIATOR_DEBUG
|
|
int npdu_alloc, npdu_max; // for instrumentation
|
|
#endif
|
|
#ifdef DO_EVENTHANDLER
|
|
eventhandler_tag eh;
|
|
#endif
|
|
/*
|
|
| sysctl stuff
|
|
*/
|
|
struct sysctl_ctx_list clist;
|
|
struct sysctl_oid *oid;
|
|
};
|
|
|
|
#ifdef ISCSI_INITIATOR_DEBUG
|
|
extern struct mtx iscsi_dbg_mtx;
|
|
#endif
|
|
|
|
void isc_start_receiver(isc_session_t *sp);
|
|
void isc_stop_receiver(isc_session_t *sp);
|
|
|
|
int isc_sendPDU(isc_session_t *sp, pduq_t *pq);
|
|
int isc_qout(isc_session_t *sp, pduq_t *pq);
|
|
int i_prepPDU(isc_session_t *sp, pduq_t *pq);
|
|
|
|
int ism_fullfeature(struct cdev *dev, int flag);
|
|
|
|
int i_pdu_flush(isc_session_t *sc);
|
|
int i_setopt(isc_session_t *sp, isc_opt_t *opt);
|
|
void i_freeopt(isc_opt_t *opt);
|
|
|
|
int ic_init(isc_session_t *sp);
|
|
void ic_destroy(isc_session_t *sp);
|
|
void ic_lost_target(isc_session_t *sp, int target);
|
|
int ic_getCamVals(isc_session_t *sp, iscsi_cam_t *cp);
|
|
|
|
void ism_recv(isc_session_t *sp, pduq_t *pq);
|
|
int ism_start(isc_session_t *sp);
|
|
void ism_restart(isc_session_t *sp);
|
|
void ism_stop(isc_session_t *sp);
|
|
|
|
int scsi_encap(struct cam_sim *sim, union ccb *ccb);
|
|
int scsi_decap(isc_session_t *sp, pduq_t *opq, pduq_t *pq);
|
|
void iscsi_r2t(isc_session_t *sp, pduq_t *opq, pduq_t *pq);
|
|
void iscsi_done(isc_session_t *sp, pduq_t *opq, pduq_t *pq);
|
|
void iscsi_reject(isc_session_t *sp, pduq_t *opq, pduq_t *pq);
|
|
void iscsi_async(isc_session_t *sp, pduq_t *pq);
|
|
void iscsi_cleanup(isc_session_t *sp);
|
|
int iscsi_requeue(isc_session_t *sp);
|
|
|
|
// Serial Number Arithmetic
|
|
#define _MAXINCR 0x7FFFFFFF // 2 ^ 31 - 1
|
|
#define SNA_GT(i1, i2) ((i1 != i2) && (\
|
|
(i1 < i2 && i2 - i1 > _MAXINCR) ||\
|
|
(i1 > i2 && i1 - i2 < _MAXINCR))?1: 0)
|
|
|
|
/*
|
|
| inlines
|
|
*/
|
|
#ifdef _CAM_CAM_XPT_SIM_H
|
|
|
|
#if __FreeBSD_version < 600000
|
|
#define CAM_LOCK(arg)
|
|
#define CAM_ULOCK(arg)
|
|
|
|
static __inline void
|
|
XPT_DONE(isc_session_t *sp, union ccb *ccb)
|
|
{
|
|
mtx_lock(&Giant);
|
|
xpt_done(ccb);
|
|
mtx_unlock(&Giant);
|
|
}
|
|
#elif __FreeBSD_version >= 700000
|
|
#define CAM_LOCK(arg) mtx_lock(&arg->cam_mtx)
|
|
#define CAM_UNLOCK(arg) mtx_unlock(&arg->cam_mtx)
|
|
|
|
static __inline void
|
|
XPT_DONE(isc_session_t *sp, union ccb *ccb)
|
|
{
|
|
CAM_LOCK(sp);
|
|
xpt_done(ccb);
|
|
CAM_UNLOCK(sp);
|
|
}
|
|
#else
|
|
//__FreeBSD_version >= 600000
|
|
#define CAM_LOCK(arg)
|
|
#define CAM_UNLOCK(arg)
|
|
#define XPT_DONE(ignore, arg) xpt_done(arg)
|
|
#endif
|
|
|
|
#endif /* _CAM_CAM_XPT_SIM_H */
|
|
|
|
static __inline pduq_t *
|
|
pdu_alloc(struct isc_softc *isc, int wait)
|
|
{
|
|
pduq_t *pq;
|
|
|
|
pq = (pduq_t *)uma_zalloc(isc->pdu_zone, wait /* M_WAITOK or M_NOWAIT*/);
|
|
if(pq == NULL) {
|
|
debug(7, "out of mem");
|
|
return NULL;
|
|
}
|
|
#ifdef ISCSI_INITIATOR_DEBUG
|
|
mtx_lock(&iscsi_dbg_mtx);
|
|
isc->npdu_alloc++;
|
|
if(isc->npdu_alloc > isc->npdu_max)
|
|
isc->npdu_max = isc->npdu_alloc;
|
|
mtx_unlock(&iscsi_dbg_mtx);
|
|
#endif
|
|
memset(pq, 0, sizeof(pduq_t));
|
|
|
|
return pq;
|
|
}
|
|
|
|
static __inline void
|
|
pdu_free(struct isc_softc *isc, pduq_t *pq)
|
|
{
|
|
if(pq->mp)
|
|
m_freem(pq->mp);
|
|
#ifdef NO_USE_MBUF
|
|
if(pq->buf != NULL)
|
|
free(pq->buf, M_ISCSIBUF);
|
|
#endif
|
|
uma_zfree(isc->pdu_zone, pq);
|
|
#ifdef ISCSI_INITIATOR_DEBUG
|
|
mtx_lock(&iscsi_dbg_mtx);
|
|
isc->npdu_alloc--;
|
|
mtx_unlock(&iscsi_dbg_mtx);
|
|
#endif
|
|
}
|
|
|
|
static __inline void
|
|
i_nqueue_rsp(isc_session_t *sp, pduq_t *pq)
|
|
{
|
|
mtx_lock(&sp->rsp_mtx);
|
|
if(++sp->stats.nrsp > sp->stats.max_rsp)
|
|
sp->stats.max_rsp = sp->stats.nrsp;
|
|
TAILQ_INSERT_TAIL(&sp->rsp, pq, pq_link);
|
|
mtx_unlock(&sp->rsp_mtx);
|
|
}
|
|
|
|
static __inline pduq_t *
|
|
i_dqueue_rsp(isc_session_t *sp)
|
|
{
|
|
pduq_t *pq;
|
|
|
|
mtx_lock(&sp->rsp_mtx);
|
|
if((pq = TAILQ_FIRST(&sp->rsp)) != NULL) {
|
|
sp->stats.nrsp--;
|
|
TAILQ_REMOVE(&sp->rsp, pq, pq_link);
|
|
}
|
|
mtx_unlock(&sp->rsp_mtx);
|
|
|
|
return pq;
|
|
}
|
|
|
|
static __inline void
|
|
i_nqueue_rsv(isc_session_t *sp, pduq_t *pq)
|
|
{
|
|
mtx_lock(&sp->rsv_mtx);
|
|
if(++sp->stats.nrsv > sp->stats.max_rsv)
|
|
sp->stats.max_rsv = sp->stats.nrsv;
|
|
TAILQ_INSERT_TAIL(&sp->rsv, pq, pq_link);
|
|
mtx_unlock(&sp->rsv_mtx);
|
|
}
|
|
|
|
static __inline pduq_t *
|
|
i_dqueue_rsv(isc_session_t *sp)
|
|
{
|
|
pduq_t *pq;
|
|
|
|
mtx_lock(&sp->rsv_mtx);
|
|
if((pq = TAILQ_FIRST(&sp->rsv)) != NULL) {
|
|
sp->stats.nrsv--;
|
|
TAILQ_REMOVE(&sp->rsv, pq, pq_link);
|
|
}
|
|
mtx_unlock(&sp->rsv_mtx);
|
|
|
|
return pq;
|
|
}
|
|
|
|
static __inline void
|
|
i_nqueue_csnd(isc_session_t *sp, pduq_t *pq)
|
|
{
|
|
mtx_lock(&sp->snd_mtx);
|
|
if(++sp->stats.ncsnd > sp->stats.max_csnd)
|
|
sp->stats.max_csnd = sp->stats.ncsnd;
|
|
TAILQ_INSERT_TAIL(&sp->csnd, pq, pq_link);
|
|
mtx_unlock(&sp->snd_mtx);
|
|
}
|
|
|
|
static __inline pduq_t *
|
|
i_dqueue_csnd(isc_session_t *sp)
|
|
{
|
|
pduq_t *pq;
|
|
|
|
mtx_lock(&sp->snd_mtx);
|
|
if((pq = TAILQ_FIRST(&sp->csnd)) != NULL) {
|
|
sp->stats.ncsnd--;
|
|
TAILQ_REMOVE(&sp->csnd, pq, pq_link);
|
|
}
|
|
mtx_unlock(&sp->snd_mtx);
|
|
|
|
return pq;
|
|
}
|
|
|
|
static __inline void
|
|
i_nqueue_isnd(isc_session_t *sp, pduq_t *pq)
|
|
{
|
|
mtx_lock(&sp->snd_mtx);
|
|
if(++sp->stats.nisnd > sp->stats.max_isnd)
|
|
sp->stats.max_isnd = sp->stats.nisnd;
|
|
TAILQ_INSERT_TAIL(&sp->isnd, pq, pq_link);
|
|
mtx_unlock(&sp->snd_mtx);
|
|
}
|
|
|
|
static __inline pduq_t *
|
|
i_dqueue_isnd(isc_session_t *sp)
|
|
{
|
|
pduq_t *pq;
|
|
|
|
mtx_lock(&sp->snd_mtx);
|
|
if((pq = TAILQ_FIRST(&sp->isnd)) != NULL) {
|
|
sp->stats.nisnd--;
|
|
TAILQ_REMOVE(&sp->isnd, pq, pq_link);
|
|
}
|
|
mtx_unlock(&sp->snd_mtx);
|
|
|
|
return pq;
|
|
}
|
|
|
|
static __inline void
|
|
i_nqueue_wsnd(isc_session_t *sp, pduq_t *pq)
|
|
{
|
|
mtx_lock(&sp->snd_mtx);
|
|
if(++sp->stats.nwsnd > sp->stats.max_wsnd)
|
|
sp->stats.max_wsnd = sp->stats.nwsnd;
|
|
TAILQ_INSERT_TAIL(&sp->wsnd, pq, pq_link);
|
|
mtx_unlock(&sp->snd_mtx);
|
|
}
|
|
|
|
static __inline pduq_t *
|
|
i_dqueue_wsnd(isc_session_t *sp)
|
|
{
|
|
pduq_t *pq;
|
|
|
|
mtx_lock(&sp->snd_mtx);
|
|
if((pq = TAILQ_FIRST(&sp->wsnd)) != NULL) {
|
|
sp->stats.nwsnd--;
|
|
TAILQ_REMOVE(&sp->wsnd, pq, pq_link);
|
|
}
|
|
mtx_unlock(&sp->snd_mtx);
|
|
|
|
return pq;
|
|
}
|
|
|
|
static __inline pduq_t *
|
|
i_dqueue_snd(isc_session_t *sp, int which)
|
|
{
|
|
pduq_t *pq;
|
|
|
|
pq = NULL;
|
|
mtx_lock(&sp->snd_mtx);
|
|
if((which & BIT(0)) && (pq = TAILQ_FIRST(&sp->isnd)) != NULL) {
|
|
sp->stats.nisnd--;
|
|
TAILQ_REMOVE(&sp->isnd, pq, pq_link);
|
|
pq->pduq = &sp->isnd; // remember where you came from
|
|
} else
|
|
if((which & BIT(1)) && (pq = TAILQ_FIRST(&sp->wsnd)) != NULL) {
|
|
sp->stats.nwsnd--;
|
|
TAILQ_REMOVE(&sp->wsnd, pq, pq_link);
|
|
pq->pduq = &sp->wsnd; // remember where you came from
|
|
} else
|
|
if((which & BIT(2)) && (pq = TAILQ_FIRST(&sp->csnd)) != NULL) {
|
|
sp->stats.ncsnd--;
|
|
TAILQ_REMOVE(&sp->csnd, pq, pq_link);
|
|
pq->pduq = &sp->csnd; // remember where you came from
|
|
}
|
|
mtx_unlock(&sp->snd_mtx);
|
|
|
|
return pq;
|
|
}
|
|
|
|
static __inline void
|
|
i_rqueue_pdu(isc_session_t *sp, pduq_t *pq)
|
|
{
|
|
mtx_lock(&sp->snd_mtx);
|
|
KASSERT(pq->pduq != NULL, ("pq->pduq is NULL"));
|
|
TAILQ_INSERT_TAIL(pq->pduq, pq, pq_link);
|
|
mtx_unlock(&sp->snd_mtx);
|
|
}
|
|
|
|
/*
|
|
| Waiting for ACK (or something :-)
|
|
*/
|
|
static __inline void
|
|
i_nqueue_hld(isc_session_t *sp, pduq_t *pq)
|
|
{
|
|
getbintime(&pq->ts);
|
|
mtx_lock(&sp->hld_mtx);
|
|
if(++sp->stats.nhld > sp->stats.max_hld)
|
|
sp->stats.max_hld = sp->stats.nhld;
|
|
TAILQ_INSERT_TAIL(&sp->hld, pq, pq_link);
|
|
mtx_unlock(&sp->hld_mtx);
|
|
return;
|
|
}
|
|
|
|
static __inline void
|
|
i_remove_hld(isc_session_t *sp, pduq_t *pq)
|
|
{
|
|
mtx_lock(&sp->hld_mtx);
|
|
sp->stats.nhld--;
|
|
TAILQ_REMOVE(&sp->hld, pq, pq_link);
|
|
mtx_unlock(&sp->hld_mtx);
|
|
}
|
|
|
|
static __inline pduq_t *
|
|
i_dqueue_hld(isc_session_t *sp)
|
|
{
|
|
pduq_t *pq;
|
|
|
|
mtx_lock(&sp->hld_mtx);
|
|
if((pq = TAILQ_FIRST(&sp->hld)) != NULL) {
|
|
sp->stats.nhld--;
|
|
TAILQ_REMOVE(&sp->hld, pq, pq_link);
|
|
}
|
|
mtx_unlock(&sp->hld_mtx);
|
|
|
|
return pq;
|
|
}
|
|
|
|
static __inline pduq_t *
|
|
i_search_hld(isc_session_t *sp, int itt, int keep)
|
|
{
|
|
pduq_t *pq, *tmp;
|
|
|
|
pq = NULL;
|
|
|
|
mtx_lock(&sp->hld_mtx);
|
|
TAILQ_FOREACH_SAFE(pq, &sp->hld, pq_link, tmp) {
|
|
if(pq->pdu.ipdu.bhs.itt == itt) {
|
|
if(!keep) {
|
|
sp->stats.nhld--;
|
|
TAILQ_REMOVE(&sp->hld, pq, pq_link);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
mtx_unlock(&sp->hld_mtx);
|
|
|
|
return pq;
|
|
}
|
|
|
|
static __inline void
|
|
i_acked_hld(isc_session_t *sp, pdu_t *op)
|
|
{
|
|
pduq_t *pq, *tmp;
|
|
u_int exp = sp->sn.expCmd;
|
|
|
|
pq = NULL;
|
|
mtx_lock(&sp->hld_mtx);
|
|
TAILQ_FOREACH_SAFE(pq, &sp->hld, pq_link, tmp) {
|
|
if((op && op->ipdu.bhs.itt == pq->pdu.ipdu.bhs.itt)
|
|
|| (pq->ccb == NULL
|
|
&& (pq->pdu.ipdu.bhs.opcode != ISCSI_WRITE_DATA)
|
|
&& SNA_GT(exp, ntohl(pq->pdu.ipdu.bhs.ExpStSN)))) {
|
|
sp->stats.nhld--;
|
|
TAILQ_REMOVE(&sp->hld, pq, pq_link);
|
|
pdu_free(sp->isc, pq);
|
|
}
|
|
}
|
|
mtx_unlock(&sp->hld_mtx);
|
|
}
|
|
|
|
static __inline void
|
|
i_mbufcopy(struct mbuf *mp, caddr_t dp, int len)
|
|
{
|
|
struct mbuf *m;
|
|
caddr_t bp;
|
|
|
|
for(m = mp; m != NULL; m = m->m_next) {
|
|
bp = mtod(m, caddr_t);
|
|
/*
|
|
| the pdu is word (4 octed) aligned
|
|
| so len <= packet
|
|
*/
|
|
memcpy(dp, bp, MIN(len, m->m_len));
|
|
dp += m->m_len;
|
|
len -= m->m_len;
|
|
if(len <= 0)
|
|
break;
|
|
}
|
|
}
|