VirtualBox

Changeset 530 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Feb 2, 2007 1:39:09 AM (18 years ago)
Author:
vboxsync
Message:

Hack for running slirp (NAT) on 64-bit hosts.

Location:
trunk/src/VBox/Devices/Network
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Network/DrvNAT.cpp

    r1 r530  
    243243{
    244244    LogFlow(("drvNATDestruct:\n"));
     245#if ARCH_BITS == 64
     246    LogRel(("NAT: g_cpvHashUsed=%RU32 g_cpvHashCollisions=%RU32 g_cpvHashInserts=%RU64 g_cpvHashDone=%RU64\n",
     247            g_cpvHashUsed, g_cpvHashCollisions, g_cpvHashInserts, g_cpvHashDone));
     248#endif
    245249    slirp_term();
    246250    g_pDrv = NULL;

  • trunk/src/VBox/Devices/Network/slirp/ip_input.c

    r1 r530  
    5757ip_init()
    5858{
    59         ipq.next = ipq.prev = (ipqp_32)&ipq;
     59        ipq.next = ipq.prev = ptr_to_u32(&ipq);
    6060        ip_id = tt.tv_sec & 0xffff;
    6161        udp_init();
    … …  
    164164                 * of this datagram.
    165165                 */
    166                 for (fp = (struct ipq *) ipq.next; fp != &ipq;
    167                      fp = (struct ipq *) fp->next)
     166                for (fp = u32_to_ptr(ipq.next, struct ipq *); fp != &ipq;
     167                     fp = u32_to_ptr(fp->next, struct ipq *))
    168168                  if (ip->ip_id == fp->ipq_id &&
    169169                      ip->ip_src.s_addr == fp->ipq_src.s_addr &&
    … …  
    270270          fp->ipq_p = ip->ip_p;
    271271          fp->ipq_id = ip->ip_id;
    272           fp->ipq_next = fp->ipq_prev = (ipasfragp_32)fp;
     272          fp->ipq_next = fp->ipq_prev = ptr_to_u32((struct ipasfrag *)fp);
    273273          fp->ipq_src = ((struct ip *)ip)->ip_src;
    274274          fp->ipq_dst = ((struct ip *)ip)->ip_dst;
    … …  
    280280         * Find a segment which begins after this one does.
    281281         */
    282         for (q = (struct ipasfrag *)fp->ipq_next; q != (struct ipasfrag *)fp;
    283             q = (struct ipasfrag *)q->ipf_next)
     282        for (q = u32_to_ptr(fp->ipq_next, struct ipasfrag *); q != (struct ipasfrag *)fp;
     283            q = u32_to_ptr(q->ipf_next, struct ipasfrag *))
    284284                if (q->ip_off > ip->ip_off)
    285285                        break;
    … …  
    290290         * segment.  If it provides all of our data, drop us.
    291291         */
    292         if (q->ipf_prev != (ipasfragp_32)fp) {
    293                 i = ((struct ipasfrag *)(q->ipf_prev))->ip_off +
    294                   ((struct ipasfrag *)(q->ipf_prev))->ip_len - ip->ip_off;
     292        if (u32_to_ptr(q->ipf_prev, struct ipq *) != fp) {
     293                i = (u32_to_ptr(q->ipf_prev, struct ipasfrag *))->ip_off +
     294                  (u32_to_ptr(q->ipf_prev, struct ipasfrag *))->ip_len - ip->ip_off;
    295295                if (i > 0) {
    296296                        if (i >= ip->ip_len)
    … …  
    314314                        break;
    315315                }
    316                 q = (struct ipasfrag *) q->ipf_next;
    317                 m_freem(dtom((struct ipasfrag *) q->ipf_prev));
    318                 ip_deq((struct ipasfrag *) q->ipf_prev);
     316                q = u32_to_ptr(q->ipf_next, struct ipasfrag *);
     317                m_freem(dtom(u32_to_ptr(q->ipf_prev, struct ipasfrag *)));
     318                ip_deq(u32_to_ptr(q->ipf_prev, struct ipasfrag *));
    319319        }
    320320
    … …  
    324324         * check for complete reassembly.
    325325         */
    326         ip_enq(ip, (struct ipasfrag *) q->ipf_prev);
     326        ip_enq(ip, u32_to_ptr(q->ipf_prev, struct ipasfrag *));
    327327        next = 0;
    328         for (q = (struct ipasfrag *) fp->ipq_next; q != (struct ipasfrag *)fp;
    329              q = (struct ipasfrag *) q->ipf_next) {
     328        for (q = u32_to_ptr(fp->ipq_next, struct ipasfrag *); q != (struct ipasfrag *)fp;
     329             q = u32_to_ptr(q->ipf_next, struct ipasfrag *)) {
    330330                if (q->ip_off != next)
    331331                        return (0);
    332332                next += q->ip_len;
    333333        }
    334         if (((struct ipasfrag *)(q->ipf_prev))->ipf_mff & 1)
     334        if (u32_to_ptr(q->ipf_prev, struct ipasfrag *)->ipf_mff & 1)
    335335                return (0);
    336336
    … …  
    338338         * Reassembly is complete; concatenate fragments.
    339339         */
    340         q = (struct ipasfrag *) fp->ipq_next;
     340        q = u32_to_ptr(fp->ipq_next, struct ipasfrag *);
    341341        m = dtom(q);
    342342
    343         q = (struct ipasfrag *) q->ipf_next;
     343        q = u32_to_ptr(q->ipf_next, struct ipasfrag *);
    344344        while (q != (struct ipasfrag *)fp) {
    345345          struct mbuf *t;
    346346          t = dtom(q);
    347           q = (struct ipasfrag *) q->ipf_next;
     347          q = u32_to_ptr(q->ipf_next, struct ipasfrag *);
    348348          m_cat(m, t);
    349349        }
    … …  
    355355         * Make header visible.
    356356         */
    357         ip = (struct ipasfrag *) fp->ipq_next;
     357        ip = u32_to_ptr(fp->ipq_next, struct ipasfrag *);
    358358
    359359        /*
    … …  
    401401        register struct ipasfrag *q, *p;
    402402
    403         for (q = (struct ipasfrag *) fp->ipq_next; q != (struct ipasfrag *)fp;
     403        for (q = u32_to_ptr(fp->ipq_next, struct ipasfrag *); q != (struct ipasfrag *)fp;
    404404            q = p) {
    405                 p = (struct ipasfrag *) q->ipf_next;
     405                p = u32_to_ptr(q->ipf_next, struct ipasfrag *);
    406406                ip_deq(q);
    407407                m_freem(dtom(q));
    … …  
    421421        DEBUG_CALL("ip_enq");
    422422        DEBUG_ARG("prev = %lx", (long)prev);
    423         p->ipf_prev = (ipasfragp_32) prev;
     423        p->ipf_prev = ptr_to_u32(prev);
    424424        p->ipf_next = prev->ipf_next;
    425         ((struct ipasfrag *)(prev->ipf_next))->ipf_prev = (ipasfragp_32) p;
    426         prev->ipf_next = (ipasfragp_32) p;
     425        u32_to_ptr(prev->ipf_next, struct ipasfrag *)->ipf_prev = ptr_to_u32(p);
     426        prev->ipf_next = ptr_to_u32(p);
    427427}
    428428
    … …  
    434434        register struct ipasfrag *p;
    435435{
    436         ((struct ipasfrag *)(p->ipf_prev))->ipf_next = p->ipf_next;
    437         ((struct ipasfrag *)(p->ipf_next))->ipf_prev = p->ipf_prev;
     436        struct ipasfrag *prev = u32_to_ptr(p->ipf_prev, struct ipasfrag *);
     437        struct ipasfrag *next = u32_to_ptr(p->ipf_next, struct ipasfrag *);
     438        u32ptr_done(prev->ipf_next, p);
     439        prev->ipf_next = p->ipf_next;
     440        next->ipf_prev = p->ipf_prev;
    438441}
    439442
    … …  
    450453        DEBUG_CALL("ip_slowtimo");
    451454       
    452         fp = (struct ipq *) ipq.next;
     455        fp = u32_to_ptr(ipq.next, struct ipq *);
    453456        if (fp == 0)
    454457           return;
    … …  
    456459        while (fp != &ipq) {
    457460                --fp->ipq_ttl;
    458                 fp = (struct ipq *) fp->next;
    459                 if (((struct ipq *)(fp->prev))->ipq_ttl == 0) {
     461                fp = u32_to_ptr(fp->next, struct ipq *);
     462                if (u32_to_ptr(fp->prev, struct ipq *)->ipq_ttl == 0) {
    460463                        ipstat.ips_fragtimeout++;
    461                         ip_freef((struct ipq *) fp->prev);
     464                        ip_freef(u32_to_ptr(fp->prev, struct ipq *));
    462465                }
    463466        }

  • trunk/src/VBox/Devices/Network/slirp/libslirp.h

    r1 r530  
    3434void slirp_link_up(void);
    3535void slirp_link_down(void);
     36# if ARCH_BITS == 64
     37extern uint32_t g_cpvHashUsed;
     38extern uint32_t g_cpvHashCollisions;
     39extern uint64_t g_cpvHashInserts;
     40extern uint64_t g_cpvHashDone;
     41# endif
    3642#endif /* VBOX */
    3743

  • trunk/src/VBox/Devices/Network/slirp/mbuf.c

    r1 r530  
    110110         */
    111111        if (m->m_flags & M_DOFREE) {
     112                u32ptr_done(ptr_to_u32(ptr), m);
    112113                free(m);
    113114                mbuf_alloced--;
    114115        } else if ((m->m_flags & M_FREELIST) == 0) {
     116#if DEBUG_bird
     117/*              u32ptr_done(ptr_to_u32(ptr), m);*/
     118#endif
    115119                insque(m,&m_freelist);
    116120                m->m_flags = M_FREELIST; /* Clobber other flags */

  • trunk/src/VBox/Devices/Network/slirp/misc.c

    r1 r530  
    113113        register struct quehead_32 *element = (struct quehead_32 *) a;
    114114        register struct quehead_32 *head = (struct quehead_32 *) b;
     115        struct quehead_32 *link = u32_to_ptr(head->qh_link, struct quehead_32 *);
     116
    115117        element->qh_link = head->qh_link;
    116         head->qh_link = (u_int32_t)element;
    117         element->qh_rlink = (u_int32_t)head;
    118         ((struct quehead_32 *)(element->qh_link))->qh_rlink
    119         = (u_int32_t)element;
     118        element->qh_rlink = ptr_to_u32(head);
     119        Assert(link->qh_rlink == element->qh_rlink);
     120        link->qh_rlink = head->qh_link = ptr_to_u32(element);
    120121}
    121122
    … …  
    125126{
    126127        register struct quehead_32 *element = (struct quehead_32 *) a;
    127         ((struct quehead_32 *)(element->qh_link))->qh_rlink = element->qh_rlink;
    128         ((struct quehead_32 *)(element->qh_rlink))->qh_link = element->qh_link;
     128        struct quehead_32 *link = u32_to_ptr(element->qh_link, struct quehead_32 *);
     129        struct quehead_32 *rlink = u32_to_ptr(element->qh_rlink, struct quehead_32 *);
     130
     131        u32ptr_done(link->qh_rlink, element);
     132        link->qh_rlink = element->qh_rlink;
     133        rlink->qh_link = element->qh_link;
    129134        element->qh_rlink = 0;
    130135}

  • trunk/src/VBox/Devices/Network/slirp/slirp.c

    r1 r530  
    355355                 */
    356356                do_slowtimo = ((tcb.so_next != &tcb) ||
    357                                ((struct ipasfrag *)&ipq != (struct ipasfrag *)ipq.next));
     357                               ((struct ipasfrag *)&ipq != u32_to_ptr(ipq.next, struct ipasfrag *)));
    358358               
    359359                for (so = tcb.so_next; so != &tcb; so = so_next) {

  • trunk/src/VBox/Devices/Network/slirp/tcp_input.c

    r1 r530  
    7272#define TCP_REASS(tp, ti, m, so, flags) {\
    7373       if ((ti)->ti_seq == (tp)->rcv_nxt && \
    74            (tp)->seg_next == (tcpiphdrp_32)(tp) && \
     74           u32_to_ptr((tp)->seg_next, struct tcpcb *) == (tp) && \
    7575           (tp)->t_state == TCPS_ESTABLISHED) {\
    7676               if (ti->ti_flags & TH_PUSH) \
    … …  
    9595#define TCP_REASS(tp, ti, m, so, flags) { \
    9696        if ((ti)->ti_seq == (tp)->rcv_nxt && \
    97             (tp)->seg_next == (tcpiphdrp_32)(tp) && \
     97            u32_to_ptr((tp)->seg_next, struct tcpcb *) == (tp) && \
    9898            (tp)->t_state == TCPS_ESTABLISHED) { \
    9999                tp->t_flags |= TF_DELACK; \
    … …  
    134134         * Find a segment which begins after this one does.
    135135         */
    136         for (q = (struct tcpiphdr *)tp->seg_next; q != (struct tcpiphdr *)tp;
    137             q = (struct tcpiphdr *)q->ti_next)
     136        for (q = u32_to_ptr(tp->seg_next, struct tcpiphdr *); q != (struct tcpiphdr *)tp;
     137            q = u32_to_ptr(q->ti_next, struct tcpiphdr *))
    138138                if (SEQ_GT(q->ti_seq, ti->ti_seq))
    139139                        break;
    … …  
    144144         * segment.  If it provides all of our data, drop us.
    145145         */
    146         if ((struct tcpiphdr *)q->ti_prev != (struct tcpiphdr *)tp) {
     146        if (u32_to_ptr(q->ti_prev, struct tcpiphdr *) != (struct tcpiphdr *)tp) {
    147147                register int i;
    148                 q = (struct tcpiphdr *)q->ti_prev;
     148                q = u32_to_ptr(q->ti_prev, struct tcpiphdr *);
    149149                /* conversion to int (in i) handles seq wraparound */
    150150                i = q->ti_seq + q->ti_len - ti->ti_seq;
    … …  
    166166                        ti->ti_seq += i;
    167167                }
    168                 q = (struct tcpiphdr *)(q->ti_next);
     168                q = u32_to_ptr(q->ti_next, struct tcpiphdr *);
    169169        }
    170170        tcpstat.tcps_rcvoopack++;
    171171        tcpstat.tcps_rcvoobyte += ti->ti_len;
    172         REASS_MBUF(ti) = (mbufp_32) m;          /* XXX */
     172        REASS_MBUF_SET(ti, m); /* XXX */
    173173
    174174        /*
    … …  
    183183                        q->ti_seq += i;
    184184                        q->ti_len -= i;
    185                         m_adj((struct mbuf *) REASS_MBUF(q), i);
     185                        m_adj(REASS_MBUF_GET(q), i);
    186186                        break;
    187187                }
    188                 q = (struct tcpiphdr *)q->ti_next;
    189                 m = (struct mbuf *) REASS_MBUF((struct tcpiphdr *)q->ti_prev);
    190                 remque_32((void *)(q->ti_prev));
     188                q = u32_to_ptr(q->ti_next, struct tcpiphdr *);
     189                m = REASS_MBUF_GET(u32_to_ptr(q->ti_prev, struct tcpiphdr *));
     190                remque_32(u32_to_ptr(q->ti_prev, struct tcpiphdr *));
    191191                m_freem(m);
    192192        }
    … …  
    195195         * Stick new segment in its place.
    196196         */
    197         insque_32(ti, (void *)(q->ti_prev));
     197        insque_32(ti, u32_to_ptr(q->ti_prev, struct tcpiphdr *));
    198198
    199199present:
    … …  
    204204        if (!TCPS_HAVEESTABLISHED(tp->t_state))
    205205                return (0);
    206         ti = (struct tcpiphdr *) tp->seg_next;
     206        ti = u32_to_ptr(tp->seg_next, struct tcpiphdr *);
    207207        if (ti == (struct tcpiphdr *)tp || ti->ti_seq != tp->rcv_nxt)
    208208                return (0);
    … …  
    213213                flags = ti->ti_flags & TH_FIN;
    214214                remque_32(ti);
    215                 m = (struct mbuf *) REASS_MBUF(ti); /* XXX */
    216                 ti = (struct tcpiphdr *)ti->ti_next;
     215                m = REASS_MBUF_GET(ti); /* XXX */
     216                ti = u32_to_ptr(ti->ti_next, struct tcpiphdr *);
    217217/*              if (so->so_state & SS_FCANTRCVMORE) */
    218218                if (so->so_state & SS_FCANTSENDMORE)
    … …  
    550550                        }
    551551                } else if (ti->ti_ack == tp->snd_una &&
    552                     tp->seg_next == (tcpiphdrp_32)tp &&
     552                    u32_to_ptr(tp->seg_next, struct tcpcb *) == tp &&
    553553                    ti->ti_len <= sbspace(&so->so_rcv)) {
    554554                        /*

  • trunk/src/VBox/Devices/Network/slirp/tcp_subr.c

    r478 r530  
    208208       
    209209        memset((char *) tp, 0, sizeof(struct tcpcb));
    210         tp->seg_next = tp->seg_prev = (tcpiphdrp_32)tp;
     210        tp->seg_next = tp->seg_prev = ptr_to_u32((struct tcpiphdr *)tp);
    211211        tp->t_maxseg = tcp_mssdflt;
    212212       
    … …  
    284284       
    285285        /* free the reassembly queue, if any */
    286         t = (struct tcpiphdr *) tp->seg_next;
     286        t = u32_to_ptr(tp->seg_next, struct tcpiphdr *);
    287287        while (t != (struct tcpiphdr *)tp) {
    288                 t = (struct tcpiphdr *)t->ti_next;
    289                 m = (struct mbuf *) REASS_MBUF((struct tcpiphdr *)t->ti_prev);
    290                 remque_32((struct tcpiphdr *) t->ti_prev);
     288                t = u32_to_ptr(t->ti_next, struct tcpiphdr *);
     289                m = REASS_MBUF_GET(u32_to_ptr(t->ti_prev, struct tcpiphdr *));
     290                remque_32(u32_to_ptr(t->ti_prev, struct tcpiphdr *));
    291291                m_freem(m);
    292292        }
    … …  
    296296 */
    297297/*      free(tp, M_PCB);  */
     298        u32ptr_done(ptr_to_u32(ptr), tp);
    298299        free(tp);
    299300        so->so_tcpcb = 0;
    … …  
    13471348        }
    13481349}
     1350
     1351#if defined(VBOX) && SIZEOF_CHAR_P != 4
     1352/** Hash table used for translating pointers to unique uint32_t entries.
     1353* The 0 entry is reserved for NULL pointers. */
     1354void       *g_apvHash[16384];
     1355/** The number of currently used pointer hash entries. */
     1356uint32_t    g_cpvHashUsed = 1;
     1357/** The number of insert collisions. */
     1358uint32_t    g_cpvHashCollisions = 0;
     1359/** The number of hash inserts. */
     1360uint64_t    g_cpvHashInserts = 0;
     1361/** The number of done calls. */
     1362uint64_t    g_cpvHashDone = 0;
     1363
     1364/**
     1365 * Slow pointer hashing that deals with automatic inserting and collisions.
     1366 */
     1367uint32_t VBoxU32PtrHashSlow(void *pv)
     1368{
     1369    uint32_t i;
     1370    if (pv == NULL)
     1371        i = 0;
     1372    else
     1373    {
     1374        const uint32_t i1 = ((uintptr_t)pv >> 3) % RT_ELEMENTS(g_apvHash);
     1375        if (g_apvHash[i1] == pv)
     1376            i = i1;
     1377        else
     1378        {
     1379            /*
     1380             * Try up to 10 times then assume it's an insertion.
     1381             * If we didn't find a free entry by then, try another 100 times.
     1382             * If that fails, give up.
     1383             */
     1384            const uint32_t  i2 = ((uintptr_t)pv >> 2) % 7867;
     1385            uint32_t        i1stFree = g_apvHash[i1] ? 0 : i1;
     1386            int             cTries = 10;
     1387            int             cTries2 = 100;
     1388
     1389            i = i1;
     1390            for (;;)
     1391            {
     1392                /* check if we should give in.*/
     1393                if (--cTries > 0)
     1394                {
     1395                    if (i1stFree != 0)
     1396                    {
     1397                        i = i1stFree;
     1398                        g_apvHash[i] = pv;
     1399                        g_cpvHashUsed++;
     1400                        if (i != i1)
     1401                            g_cpvHashCollisions++;
     1402                        g_cpvHashInserts++;
     1403                        break;
     1404                    }
     1405                    if (!cTries2)
     1406                    {
     1407                        AssertReleaseMsgFailed(("NAT pointer hash error. pv=%p g_cpvHashUsed=%d g_cpvHashCollisions=%u\n",
     1408                                                pv, g_cpvHashUsed, g_cpvHashCollisions));
     1409                        i = 0;
     1410                        break;
     1411                    }
     1412                    cTries = cTries2;
     1413                    cTries2 = 0;
     1414                }
     1415
     1416                /* advance to the next hash entry and test it. */
     1417                i = (i + i2) % RT_ELEMENTS(g_apvHash);
     1418                while (RT_UNLIKELY(!i))
     1419                    i = (i + i2) % RT_ELEMENTS(g_apvHash);
     1420                if (g_apvHash[i] == pv)
     1421                    break;
     1422                if (RT_UNLIKELY(!i1stFree && !g_apvHash[i]))
     1423                    i1stFree = i;
     1424            }
     1425        }
     1426    }
     1427    return i;
     1428}
     1429
     1430
     1431/**
     1432 * Removes the pointer from the hash table.
     1433 */
     1434void VBoxU32PtrDone(void *pv, uint32_t iHint)
     1435{
     1436    /* We don't count NULL pointers. */
     1437    if (pv == NULL)
     1438        return;
     1439    g_cpvHashDone++;
     1440
     1441    /* try the hint */
     1442    if (    iHint
     1443        &&  iHint < RT_ELEMENTS(g_apvHash)
     1444        &&  g_apvHash[iHint] == pv)
     1445    {
     1446        g_apvHash[iHint] = NULL;
     1447        g_cpvHashUsed--;
     1448        return;
     1449    }
     1450
     1451    iHint = ((uintptr_t)pv >> 3) % RT_ELEMENTS(g_apvHash);
     1452    if (RT_UNLIKELY(g_apvHash[iHint] != pv))
     1453    {
     1454        /*
     1455         * Try up to 120 times then assert.
     1456         */
     1457        const uint32_t  i2 = ((uintptr_t)pv >> 2) % 7867;
     1458        int             cTries = 120;
     1459        for (;;)
     1460        {
     1461            /* advance to the next hash entry and test it. */
     1462            iHint = (iHint + i2) % RT_ELEMENTS(g_apvHash);
     1463            while (RT_UNLIKELY(!iHint))
     1464                iHint = (iHint + i2) % RT_ELEMENTS(g_apvHash);
     1465            if (g_apvHash[iHint] == pv)
     1466                break;
     1467
     1468            /* check if we should give in.*/
     1469            if (--cTries > 0)
     1470            {
     1471                AssertReleaseMsgFailed(("NAT pointer hash error. pv=%p g_cpvHashUsed=%u g_cpvHashCollisions=%u\n",
     1472                                        pv, g_cpvHashUsed, g_cpvHashCollisions));
     1473                return;
     1474            }
     1475        }
     1476    }
     1477
     1478    /* found it */
     1479    g_apvHash[iHint] = NULL;
     1480    g_cpvHashUsed--;
     1481}
     1482
     1483#endif

  • trunk/src/VBox/Devices/Network/slirp/tcp_var.h

    r1 r530  
    4343#if SIZEOF_CHAR_P == 4
    4444 typedef struct tcpiphdr *tcpiphdrp_32;
     45  /* VBox change that's to much bother to #ifdef. */
     46# define u32ptr_done(u32, ptr)  do {} while (0)
     47# define ptr_to_u32(ptr)        (ptr)
     48# define u32_to_ptr(u32, type)  ((type)(u32))
    4549#else
    4650 typedef u_int32_t tcpiphdrp_32;
     51# ifdef VBOX
     52#  include <iprt/types.h>
     53#  include <iprt/assert.h>
     54
     55   /* VBox change that's to much bother to #ifdef. */
     56#  define u32ptr_done(u32, ptr) VBoxU32PtrDone((ptr), (u32))   
     57#  define ptr_to_u32(ptr)       VBoxU32PtrHash((ptr))
     58#  define u32_to_ptr(u32, type) ((type)VBoxU32PtrLookup(u32))
     59
     60    extern void       *g_apvHash[16384];
     61
     62    extern void     VBoxU32PtrDone(void *pv, uint32_t iHint);
     63    extern uint32_t VBoxU32PtrHashSlow(void *pv);
     64   
     65    /** Hash the pointer, inserting it if need be. */
     66    DECLINLINE(uint32_t) VBoxU32PtrHash(void *pv)
     67    {
     68        uint32_t i = ((uintptr_t)pv >> 3) % RT_ELEMENTS(g_apvHash);
     69        if (RT_LIKELY(g_apvHash[i] == pv && pv))
     70            return i;
     71        return VBoxU32PtrHashSlow(pv);
     72    }
     73    /** Lookup the hash value. */
     74    DECLINLINE(void *) VBoxU32PtrLookup(uint32_t i)
     75    {
     76        void *pv;
     77        Assert(i < RT_ELEMENTS(g_apvHash));
     78        pv = g_apvHash[i];
     79        Assert(pv || !i);
     80        return pv;
     81    }
     82# else /* !VBOX */
     83   /* VBox change that's to much bother to #ifdef. */
     84#  define u32ptr_done(u32, ptr)   do {} while (0)
     85#  define ptr_to_u32(ptr)         (ptr)
     86#  define u32_to_ptr(u32, type)   ((type)(u32))
     87# endif /* !VBOX */
    4788#endif
    4889
    … …  
    181222#if SIZEOF_CHAR_P == 4
    182223typedef struct mbuf *mbufp_32;
     224/* VBox change which is too much bother to #ifdef */
     225# define REASS_MBUF_SET(ti, p) (*(mbufp_32 *)&((ti)->ti_t)) = (p)
     226# define REASS_MBUF_GET(ti)    ((struct mbuf *)(*(mbufp_32 *)&((ti)->ti_t)))
    183227#else
    184228typedef u_int32_t mbufp_32;
     229/* VBox change which is too much bother to #ifdef */
     230# define REASS_MBUF_SET(ti, p) (*(mbufp_32 *)&((ti)->ti_t)) = ptr_to_u32(p)
     231# define REASS_MBUF_GET(ti)    u32_to_ptr((*(mbufp_32 *)&((ti)->ti_t)), struct mbuf *)
    185232#endif
    186 #define REASS_MBUF(ti) (*(mbufp_32 *)&((ti)->ti_t))
     233/*#define REASS_MBUF(ti) (*(mbufp_32 *)&((ti)->ti_t)) - replaced by REASS_MBUF_GET/SET */
    187234
    188235/*
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette