VirtualBox

Ignore:
Timestamp:
Dec 3, 2008 9:34:37 PM (16 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
40325
Message:

slirp: code cosmetics for better readability (no semantics change)

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r14470 r14964  
    2222m_init(PNATState pData)
    2323{
    24         m_freelist.m_next = m_freelist.m_prev = &m_freelist;
    25         m_usedlist.m_next = m_usedlist.m_prev = &m_usedlist;
    26         mbuf_alloced = 0;
    27         msize_init(pData);
     24    m_freelist.m_next = m_freelist.m_prev = &m_freelist;
     25    m_usedlist.m_next = m_usedlist.m_prev = &m_usedlist;
     26    mbuf_alloced = 0;
     27    msize_init(pData);
    2828}
    2929
    … …  
    3131msize_init(PNATState pData)
    3232{
    33         /*
    34          * Find a nice value for msize
    35          * XXX if_maxlinkhdr already in mtu
    36          */
    37         msize = (if_mtu>if_mru?if_mtu:if_mru) +
    38                         if_maxlinkhdr + sizeof(struct m_hdr ) + 6;
     33    /*
     34     * Find a nice value for msize
     35     * XXX if_maxlinkhdr already in mtu
     36     */
     37    msize = (if_mtu>if_mru ? if_mtu : if_mru)
     38          + if_maxlinkhdr + sizeof(struct m_hdr ) + 6;
    3939}
    4040
    … …  
    5050m_get(PNATState pData)
    5151{
    52         register struct mbuf *m;
    53         int flags = 0;
    54 
    55         DEBUG_CALL("m_get");
    56 
    57         if (m_freelist.m_next == &m_freelist) {
    58                 m = (struct mbuf *)malloc(msize);
    59                 if (m == NULL) goto end_error;
    60                 mbuf_alloced++;
    61                 if (mbuf_alloced > mbuf_thresh)
    62                         flags = M_DOFREE;
    63                 if (mbuf_alloced > mbuf_max)
    64                         mbuf_max = mbuf_alloced;
    65         } else {
    66                 m = m_freelist.m_next;
    67                 remque(pData, m);
    68         }
    69 
    70         /* Insert it in the used list */
    71         insque(pData, m,&m_usedlist);
    72         m->m_flags = (flags | M_USEDLIST);
    73 
    74         /* Initialise it */
    75         m->m_size = msize - sizeof(struct m_hdr);
    76         m->m_data = m->m_dat;
    77         m->m_len = 0;
    78         m->m_nextpkt = 0;
    79         m->m_prevpkt = 0;
     52    register struct mbuf *m;
     53    int flags = 0;
     54
     55    DEBUG_CALL("m_get");
     56
     57    if (m_freelist.m_next == &m_freelist)
     58    {
     59        m = (struct mbuf *)malloc(msize);
     60        if (m == NULL) goto
     61            end_error;
     62        mbuf_alloced++;
     63        if (mbuf_alloced > mbuf_thresh)
     64            flags = M_DOFREE;
     65        if (mbuf_alloced > mbuf_max)
     66            mbuf_max = mbuf_alloced;
     67    }
     68    else
     69    {
     70        m = m_freelist.m_next;
     71        remque(pData, m);
     72    }
     73
     74    /* Insert it in the used list */
     75    insque(pData, m, &m_usedlist);
     76    m->m_flags = (flags | M_USEDLIST);
     77
     78    /* Initialise it */
     79    m->m_size = msize - sizeof(struct m_hdr);
     80    m->m_data = m->m_dat;
     81    m->m_len = 0;
     82    m->m_nextpkt = 0;
     83    m->m_prevpkt = 0;
     84
    8085end_error:
    81         DEBUG_ARG("m = %lx", (long )m);
    82         return m;
     86    DEBUG_ARG("m = %lx", (long )m);
     87    return m;
    8388}
    8489
    … …  
    8792{
    8893
    89   DEBUG_CALL("m_free");
    90   DEBUG_ARG("m = %lx", (long )m);
    91 
    92   if(m) {
     94    DEBUG_CALL("m_free");
     95    DEBUG_ARG("m = %lx", (long )m);
     96
     97    if(m)
     98    {
    9399        /* Remove from m_usedlist */
    94100        if (m->m_flags & M_USEDLIST)
    95            remque(pData, m);
     101            remque(pData, m);
    96102
    97103        /* If it's M_EXT, free() it */
    98104        if (m->m_flags & M_EXT)
    99            free(m->m_ext);
     105            free(m->m_ext);
    100106
    101107        /*
    102108         * Either free() it or put it on the free list
    103109         */
    104         if (m->m_flags & M_DOFREE) {
    105                 u32ptr_done(pData, ptr_to_u32(pData, m), m);
    106                 free(m);
    107                 mbuf_alloced--;
    108         } else if ((m->m_flags & M_FREELIST) == 0) {
    109                 insque(pData, m,&m_freelist);
    110                 m->m_flags = M_FREELIST; /* Clobber other flags */
    111         }
    112   } /* if(m) */
     110        if (m->m_flags & M_DOFREE)
     111        {
     112            u32ptr_done(pData, ptr_to_u32(pData, m), m);
     113            free(m);
     114            mbuf_alloced--;
     115        }
     116        else if ((m->m_flags & M_FREELIST) == 0)
     117        {
     118            insque(pData, m,&m_freelist);
     119            m->m_flags = M_FREELIST; /* Clobber other flags */
     120        }
     121    } /* if(m) */
    113122}
    114123
    … …  
    121130m_cat(PNATState pData, register struct mbuf *m, register struct mbuf *n)
    122131{
    123         /*
    124          * If there's no room, realloc
    125          */
    126         if (M_FREEROOM(m) < n->m_len)
    127                 m_inc(m,m->m_size+MINCSIZE);
    128 
    129         memcpy(m->m_data+m->m_len, n->m_data, n->m_len);
    130         m->m_len += n->m_len;
    131 
    132         m_free(pData, n);
     132    /*
     133     * If there's no room, realloc
     134     */
     135    if (M_FREEROOM(m) < n->m_len)
     136        m_inc(m,m->m_size+MINCSIZE);
     137
     138    memcpy(m->m_data+m->m_len, n->m_data, n->m_len);
     139    m->m_len += n->m_len;
     140
     141    m_free(pData, n);
    133142}
    134143
    … …  
    136145/* make m size bytes large */
    137146void
    138 m_inc(m, size)
    139         struct mbuf *m;
    140         int size;
    141 {
    142         int datasize;
    143 
    144         /* some compiles throw up on gotos.  This one we can fake. */
    145         if(m->m_size>size) return;
    146 
    147         if (m->m_flags & M_EXT) {
    148           datasize = m->m_data - m->m_ext;
    149           m->m_ext = (char *)realloc(m->m_ext,size);
    150 /*              if (m->m_ext == NULL)
    151  *                      return (struct mbuf *)NULL;
    152  */
    153           m->m_data = m->m_ext + datasize;
    154         } else {
    155           char *dat;
    156           datasize = m->m_data - m->m_dat;
    157           dat = (char *)malloc(size);
    158 /*              if (dat == NULL)
    159  *                      return (struct mbuf *)NULL;
    160  */
    161           memcpy(dat, m->m_dat, m->m_size);
    162 
    163           m->m_ext = dat;
    164           m->m_data = m->m_ext + datasize;
    165           m->m_flags |= M_EXT;
    166         }
    167 
    168         m->m_size = size;
    169 
    170 }
    171 
    172 
    173 
    174 void
    175 m_adj(m, len)
    176         struct mbuf *m;
    177         int len;
    178 {
    179         if (m == NULL)
    180                 return;
    181         if (len >= 0) {
    182                 /* Trim from head */
    183                 m->m_data += len;
    184                 m->m_len -= len;
    185         } else {
    186                 /* Trim from tail */
    187                 len = -len;
    188                 m->m_len -= len;
    189         }
     147m_inc(struct mbuf *m, int size)
     148{
     149    int datasize;
     150
     151    /* some compiles throw up on gotos.  This one we can fake. */
     152    if (m->m_size>size)
     153        return;
     154
     155    if (m->m_flags & M_EXT)
     156    {
     157        datasize = m->m_data - m->m_ext;
     158        m->m_ext = (char *)realloc(m->m_ext,size);
     159#if 0
     160        if (m->m_ext == NULL)
     161            return (struct mbuf *)NULL;
     162#endif
     163        m->m_data = m->m_ext + datasize;
     164    }
     165    else
     166    {
     167        char *dat;
     168        datasize = m->m_data - m->m_dat;
     169        dat = (char *)malloc(size);
     170#if 0
     171        if (dat == NULL)
     172            return (struct mbuf *)NULL;
     173#endif
     174        memcpy(dat, m->m_dat, m->m_size);
     175
     176        m->m_ext = dat;
     177        m->m_data = m->m_ext + datasize;
     178        m->m_flags |= M_EXT;
     179    }
     180
     181    m->m_size = size;
     182}
     183
     184
     185void
     186m_adj(struct mbuf *m, int len)
     187{
     188    if (m == NULL)
     189        return;
     190    if (len >= 0)
     191    {
     192        /* Trim from head */
     193        m->m_data += len;
     194        m->m_len -= len;
     195    }
     196    else
     197    {
     198        /* Trim from tail */
     199        len = -len;
     200        m->m_len -= len;
     201    }
    190202}
    191203
    … …  
    195207 */
    196208int
    197 m_copy(n, m, off, len)
    198         struct mbuf *n, *m;
    199         int off, len;
    200 {
    201         if (len > M_FREEROOM(n))
    202                 return -1;
    203 
    204         memcpy((n->m_data + n->m_len), (m->m_data + off), len);
    205         n->m_len += len;
    206         return 0;
     209m_copy(struct mbuf *n, struct mbuf *m, int off, int len)
     210{
     211    if (len > M_FREEROOM(n))
     212        return -1;
     213
     214    memcpy((n->m_data + n->m_len), (m->m_data + off), len);
     215    n->m_len += len;
     216    return 0;
    207217}
    208218
    … …  
    216226dtom(PNATState pData, void *dat)
    217227{
    218         struct mbuf *m;
    219 
    220         DEBUG_CALL("dtom");
    221         DEBUG_ARG("dat = %lx", (long )dat);
    222 
    223         /* bug corrected for M_EXT buffers */
    224         for (m = m_usedlist.m_next; m != &m_usedlist; m = m->m_next) {
    225           if (m->m_flags & M_EXT) {
    226             if( (char *)dat>=m->m_ext && (char *)dat<(m->m_ext + m->m_size) )
    227               return m;
    228           } else {
    229             if( (char *)dat >= m->m_dat && (char *)dat<(m->m_dat + m->m_size) )
    230               return m;
    231           }
    232         }
    233 
    234         DEBUG_ERROR((dfd, "dtom failed"));
    235 
    236         return (struct mbuf *)0;
    237 }
    238 
     228    struct mbuf *m;
     229
     230    DEBUG_CALL("dtom");
     231    DEBUG_ARG("dat = %lx", (long )dat);
     232
     233    /* bug corrected for M_EXT buffers */
     234    for (m = m_usedlist.m_next; m != &m_usedlist; m = m->m_next)
     235    {
     236        if (m->m_flags & M_EXT)
     237        {
     238            if (   (char *)dat >=  m->m_ext
     239                && (char *)dat <  (m->m_ext + m->m_size))
     240                return m;
     241        }
     242        else
     243        {
     244            if (   (char *)dat >=  m->m_dat
     245                && (char *)dat <  (m->m_dat + m->m_size))
     246                return m;
     247        }
     248    }
     249
     250    DEBUG_ERROR((dfd, "dtom failed"));
     251
     252    return (struct mbuf *)0;
     253}
Note: See TracChangeset for help on using the changeset viewer.

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