lib-move.c

来自「lustre 1.6.5 source code」· C语言 代码 · 共 1,970 行 · 第 1/5 页

        for (;;) {
                LASSERT (src_niov > 0);
                LASSERT (niov <= dst_niov);

                frag_len = src->iov_len - offset;
                dst->iov_base = ((char *)src->iov_base) + offset;

                if (len <= frag_len) {
                        dst->iov_len = len;
                        return (niov);
                }

                dst->iov_len = frag_len;

                len -= frag_len;
                dst++;
                src++;
                niov++;
                src_niov--;
                offset = 0;
        }
}

#ifndef __KERNEL__
unsigned int
lnet_kiov_nob (unsigned int niov, lnet_kiov_t *kiov)
{
        LASSERT (0);
        return (0);
}

void
lnet_copy_kiov2kiov (unsigned int ndkiov, lnet_kiov_t *dkiov, unsigned int doffset,
                     unsigned int nskiov, lnet_kiov_t *skiov, unsigned int soffset,
                     unsigned int nob)
{
        LASSERT (0);
}

void
lnet_copy_kiov2iov (unsigned int niov, struct iovec *iov, unsigned int iovoffset,
                    unsigned int nkiov, lnet_kiov_t *kiov, unsigned int kiovoffset,
                    unsigned int nob)
{
        LASSERT (0);
}

void
lnet_copy_iov2kiov (unsigned int nkiov, lnet_kiov_t *kiov, unsigned int kiovoffset,
                    unsigned int niov, struct iovec *iov, unsigned int iovoffset,
                    unsigned int nob)
{
        LASSERT (0);
}

int
lnet_extract_kiov (int dst_niov, lnet_kiov_t *dst,
                   int src_niov, lnet_kiov_t *src,
                   unsigned int offset, unsigned int len)
{
        LASSERT (0);
}

#else /* __KERNEL__ */

unsigned int
lnet_kiov_nob (unsigned int niov, lnet_kiov_t *kiov)
{
        unsigned int  nob = 0;

        while (niov-- > 0)
                nob += (kiov++)->kiov_len;

        return (nob);
}

void
lnet_copy_kiov2kiov (unsigned int ndiov, lnet_kiov_t *diov, unsigned int doffset,
                     unsigned int nsiov, lnet_kiov_t *siov, unsigned int soffset,
                     unsigned int nob)
{
        /* NB diov, siov are READ-ONLY */
        unsigned int    this_nob;
        char           *daddr = NULL;
        char           *saddr = NULL;

        if (nob == 0)
                return;

        LASSERT (!in_interrupt ());

        LASSERT (ndiov > 0);
        while (doffset >= diov->kiov_len) {
                doffset -= diov->kiov_len;
                diov++;
                ndiov--;
                LASSERT (ndiov > 0);
        }

        LASSERT (nsiov > 0);
        while (soffset >= siov->kiov_len) {
                soffset -= siov->kiov_len;
                siov++;
                nsiov--;
                LASSERT (nsiov > 0);
        }

        do {
                LASSERT (ndiov > 0);
                LASSERT (nsiov > 0);
                this_nob = MIN(diov->kiov_len - doffset,
                               siov->kiov_len - soffset);
                this_nob = MIN(this_nob, nob);

                if (daddr == NULL)
                        daddr = ((char *)cfs_kmap(diov->kiov_page)) + 
                                diov->kiov_offset + doffset;
                if (saddr == NULL)
                        saddr = ((char *)cfs_kmap(siov->kiov_page)) + 
                                siov->kiov_offset + soffset;

                /* Vanishing risk of kmap deadlock when mapping 2 pages.
                 * However in practice at least one of the kiovs will be mapped
                 * kernel pages and the map/unmap will be NOOPs */

                memcpy (daddr, saddr, this_nob);
                nob -= this_nob;

                if (diov->kiov_len > doffset + this_nob) {
                        daddr += this_nob;
                        doffset += this_nob;
                } else {
                        cfs_kunmap(diov->kiov_page);
                        daddr = NULL;
                        diov++;
                        ndiov--;
                        doffset = 0;
                }

                if (siov->kiov_len > soffset + this_nob) {
                        saddr += this_nob;
                        soffset += this_nob;
                } else {
                        cfs_kunmap(siov->kiov_page);
                        saddr = NULL;
                        siov++;
                        nsiov--;
                        soffset = 0;
                }
        } while (nob > 0);

        if (daddr != NULL)
                cfs_kunmap(diov->kiov_page);
        if (saddr != NULL)
                cfs_kunmap(siov->kiov_page);
}

void
lnet_copy_kiov2iov (unsigned int niov, struct iovec *iov, unsigned int iovoffset,
                    unsigned int nkiov, lnet_kiov_t *kiov, unsigned int kiovoffset,
                    unsigned int nob)
{
        /* NB iov, kiov are READ-ONLY */
        unsigned int    this_nob;
        char           *addr = NULL;

        if (nob == 0)
                return;

        LASSERT (!in_interrupt ());

        LASSERT (niov > 0);
        while (iovoffset >= iov->iov_len) {
                iovoffset -= iov->iov_len;
                iov++;
                niov--;
                LASSERT (niov > 0);
        }

        LASSERT (nkiov > 0);
        while (kiovoffset >= kiov->kiov_len) {
                kiovoffset -= kiov->kiov_len;
                kiov++;
                nkiov--;
                LASSERT (nkiov > 0);
        }

        do {
                LASSERT (niov > 0);
                LASSERT (nkiov > 0);
                this_nob = MIN(iov->iov_len - iovoffset,
                               kiov->kiov_len - kiovoffset);
                this_nob = MIN(this_nob, nob);

                if (addr == NULL)
                        addr = ((char *)cfs_kmap(kiov->kiov_page)) + 
                                kiov->kiov_offset + kiovoffset;

                memcpy ((char *)iov->iov_base + iovoffset, addr, this_nob);
                nob -= this_nob;

                if (iov->iov_len > iovoffset + this_nob) {
                        iovoffset += this_nob;
                } else {
                        iov++;
                        niov--;
                        iovoffset = 0;
                }

                if (kiov->kiov_len > kiovoffset + this_nob) {
                        addr += this_nob;
                        kiovoffset += this_nob;
                } else {
                        cfs_kunmap(kiov->kiov_page);
                        addr = NULL;
                        kiov++;
                        nkiov--;
                        kiovoffset = 0;
                }

        } while (nob > 0);

        if (addr != NULL)
                cfs_kunmap(kiov->kiov_page);
}

void
lnet_copy_iov2kiov (unsigned int nkiov, lnet_kiov_t *kiov, unsigned int kiovoffset,
                    unsigned int niov, struct iovec *iov, unsigned int iovoffset,
                    unsigned int nob)
{
        /* NB kiov, iov are READ-ONLY */
        unsigned int    this_nob;
        char           *addr = NULL;

        if (nob == 0)
                return;

        LASSERT (!in_interrupt ());

        LASSERT (nkiov > 0);
        while (kiovoffset >= kiov->kiov_len) {
                kiovoffset -= kiov->kiov_len;
                kiov++;
                nkiov--;
                LASSERT (nkiov > 0);
        }

        LASSERT (niov > 0);
        while (iovoffset >= iov->iov_len) {
                iovoffset -= iov->iov_len;
                iov++;
                niov--;
                LASSERT (niov > 0);
        }

        do {
                LASSERT (nkiov > 0);
                LASSERT (niov > 0);
                this_nob = MIN(kiov->kiov_len - kiovoffset,
                               iov->iov_len - iovoffset);
                this_nob = MIN(this_nob, nob);

                if (addr == NULL)
                        addr = ((char *)cfs_kmap(kiov->kiov_page)) + 
                                kiov->kiov_offset + kiovoffset;

                memcpy (addr, (char *)iov->iov_base + iovoffset, this_nob);
                nob -= this_nob;

                if (kiov->kiov_len > kiovoffset + this_nob) {
                        addr += this_nob;
                        kiovoffset += this_nob;
                } else {
                        cfs_kunmap(kiov->kiov_page);
                        addr = NULL;
                        kiov++;
                        nkiov--;
                        kiovoffset = 0;
                }

                if (iov->iov_len > iovoffset + this_nob) {
                        iovoffset += this_nob;
                } else {
                        iov++;
                        niov--;
                        iovoffset = 0;
                }
        } while (nob > 0);

        if (addr != NULL)
                cfs_kunmap(kiov->kiov_page);
}

int
lnet_extract_kiov (int dst_niov, lnet_kiov_t *dst,
                   int src_niov, lnet_kiov_t *src,
                   unsigned int offset, unsigned int len)
{
        /* Initialise 'dst' to the subset of 'src' starting at 'offset',
         * for exactly 'len' bytes, and return the number of entries.
         * NB not destructive to 'src' */
        unsigned int    frag_len;
        unsigned int    niov;

        if (len == 0)                           /* no data => */
                return (0);                     /* no frags */

        LASSERT (src_niov > 0);
        while (offset >= src->kiov_len) {      /* skip initial frags */
                offset -= src->kiov_len;
                src_niov--;
                src++;
                LASSERT (src_niov > 0);
        }

        niov = 1;
        for (;;) {
                LASSERT (src_niov > 0);
                LASSERT (niov <= dst_niov);

                frag_len = src->kiov_len - offset;
                dst->kiov_page = src->kiov_page;
                dst->kiov_offset = src->kiov_offset + offset;

                if (len <= frag_len) {
                        dst->kiov_len = len;
                        LASSERT (dst->kiov_offset + dst->kiov_len <= CFS_PAGE_SIZE);
                        return (niov);
                }

                dst->kiov_len = frag_len;
                LASSERT (dst->kiov_offset + dst->kiov_len <= CFS_PAGE_SIZE);

                len -= frag_len;
                dst++;
                src++;
                niov++;
                src_niov--;
                offset = 0;
        }
}
#endif

void
lnet_ni_recv(lnet_ni_t *ni, void *private, lnet_msg_t *msg, int delayed,
             unsigned int offset, unsigned int mlen, unsigned int rlen)
{
        unsigned int  niov = 0;
        struct iovec *iov = NULL;
        lnet_kiov_t  *kiov = NULL;
        int           rc;

        LASSERT (!in_interrupt ());
        LASSERT (mlen == 0 || msg != NULL);
        
        if (msg != NULL) {
                LASSERT(msg->msg_receiving);
                LASSERT(!msg->msg_sending);
                LASSERT(rlen == msg->msg_len);
                LASSERT(mlen <= msg->msg_len);

                msg->msg_wanted = mlen;
                msg->msg_offset = offset;
                msg->msg_receiving = 0;

                if (mlen != 0) {
                        niov = msg->msg_niov;
                        iov  = msg->msg_iov;
                        kiov = msg->msg_kiov;
                
                        LASSERT (niov > 0);
                        LASSERT ((iov == NULL) != (kiov == NULL));
                }
        }
        
        rc = (ni->ni_lnd->lnd_recv)(ni, private, msg, delayed,
                                    niov, iov, kiov, offset, mlen, rlen);
        if (rc < 0)
                lnet_finalize(ni, msg, rc);
}

int
lnet_compare_routers(lnet_peer_t *p1, lnet_peer_t *p2)
{
        if (p1->lp_txqnob < p2->lp_txqnob)
                return 1;
        
        if (p1->lp_txqnob > p2->lp_txqnob)
                return -1;
        
        if (p1->lp_txcredits > p2->lp_txcredits)
                return 1;