Changeset 558e177e in rtems


Ignore:
Timestamp:
May 9, 2005, 12:47:45 PM (15 years ago)
Author:
Ralf Corsepius <ralf.corsepius@…>
Branches:
4.10, 4.11, 4.8, 4.9, master
Children:
b7680258
Parents:
00a578a
Message:

Partial update from FreeBSD.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • cpukit/libnetworking/kern/uipc_mbuf.c

    r00a578a r558e177e  
    1111 *    notice, this list of conditions and the following disclaimer in the
    1212 *    documentation and/or other materials provided with the distribution.
    13  * 3. All advertising materials mentioning features or use of this software
    14  *    must display the following acknowledgement:
    15  *      This product includes software developed by the University of
    16  *      California, Berkeley and its contributors.
    1713 * 4. Neither the name of the University nor the names of its contributors
    1814 *    may be used to endorse or promote products derived from this software
     
    166162
    167163struct mbuf *
    168 m_free(m)
    169         struct mbuf *m;
    170 {
    171         register struct mbuf *n;
     164m_free(struct mbuf *m)
     165{
     166        struct mbuf *n;
    172167
    173168        MFREE(m, n);
     
    176171
    177172void
    178 m_freem(m)
    179         register struct mbuf *m;
    180 {
    181         register struct mbuf *n;
    182 
    183         if (m == NULL)
     173m_freem(struct mbuf *mb)
     174{
     175        struct mbuf *n;
     176
     177        if (mb == NULL)
    184178                return;
    185179        do {
    186                 MFREE(m, n);
    187                 m = n;
    188         } while (m);
     180                MFREE(mb, n);
     181                mb = n;
     182        } while (mb);
    189183}
    190184
     
    199193 */
    200194struct mbuf *
    201 m_prepend(m, len, how)
    202         register struct mbuf *m;
    203         int len, how;
     195m_prepend(struct mbuf *m, int len, int how)
    204196{
    205197        struct mbuf *mn;
     
    230222
    231223struct mbuf *
    232 m_copym(m, off0, len, wait)
    233         register struct mbuf *m;
    234         int off0, wait;
    235         register int len;
    236 {
    237         register struct mbuf *n, **np;
    238         register int off = off0;
     224m_copym(struct mbuf *m, int off0, int len, int wait)
     225{
     226        struct mbuf *n, **np;
     227        int off = off0;
    239228        struct mbuf *top;
    240229        int copyhdr = 0;
     
    245234                copyhdr = 1;
    246235        while (off > 0) {
    247                 if (m == 0)
     236                if (m == NULL)
    248237                        panic("m_copym");
    249238                if (off < m->m_len)
     
    255244        top = 0;
    256245        while (len > 0) {
    257                 if (m == 0) {
     246                if (m == NULL) {
    258247                        if (len != M_COPYALL)
    259248                                panic("m_copym");
     
    262251                MGET(n, wait, m->m_type);
    263252                *np = n;
    264                 if (n == 0)
     253                if (n == NULL)
    265254                        goto nospace;
    266255                if (copyhdr) {
     
    291280                np = &n->m_next;
    292281        }
    293         if (top == 0)
     282        if (top == NULL)
    294283                MCFail++;
    295284        return (top);
     
    297286        m_freem(top);
    298287        MCFail++;
    299         return (0);
     288        return (NULL);
    300289}
    301290
     
    305294 */
    306295struct mbuf *
    307 m_copypacket(m, how)
    308         struct mbuf *m;
    309         int how;
     296m_copypacket(struct mbuf *m, int how)
    310297{
    311298        struct mbuf *top, *n, *o;
     
    361348 */
    362349int
    363 m_copydata(m, off, len, cp)
    364         register struct mbuf *m;
    365         register int off;
    366         register int len;
    367         caddr_t cp;
    368 {
    369         register unsigned count;
    370 /*      struct mbuf *m0 = m; */
     350m_copydata(const struct mbuf *m, int off, int len, caddr_t cp)
     351{
     352        u_int count;
    371353
    372354        if (off < 0 || len < 0)
     
    414396 */
    415397void
    416 m_cat(m, n)
    417         register struct mbuf *m, *n;
     398m_cat(struct mbuf *m, struct mbuf *n)
    418399{
    419400        while (m->m_next)
     
    435416
    436417void
    437 m_adj(mp, req_len)
    438         struct mbuf *mp;
    439         int req_len;
    440 {
    441         register int len = req_len;
    442         register struct mbuf *m;
    443         register int count;
     418m_adj(struct mbuf *mp, int req_len)
     419{
     420        int len = req_len;
     421        struct mbuf *m;
     422        int count;
    444423
    445424        if ((m = mp) == NULL)
     
    519498
    520499struct mbuf *
    521 m_pullup(n, len)
    522         register struct mbuf *n;
    523         int len;
    524 {
    525         register struct mbuf *m;
    526         register int count;
     500m_pullup(struct mbuf *n, int len)
     501{
     502        struct mbuf *m;
     503        int count;
    527504        int space;
    528505
     
    543520                        goto bad;
    544521                MGET(m, M_DONTWAIT, n->m_type);
    545                 if (m == 0)
     522                if (m == NULL)
    546523                        goto bad;
    547524                m->m_len = 0;
     
    571548        m->m_next = n;
    572549        return (m);
    573 bad:
     550 bad:
    574551        m_freem(n);
    575552        MPFail++;
    576         return (0);
     553        return (NULL);
    577554}
    578555
     
    583560 */
    584561struct mbuf *
    585 m_split(m0, len0, wait)
    586         register struct mbuf *m0;
    587         int len0, wait;
    588 {
    589         register struct mbuf *m, *n;
    590         unsigned len = len0, remain;
     562m_split(struct mbuf *m0, int len0, int wait)
     563{
     564        struct mbuf *m, *n;
     565        u_int len = len0, remain;
    591566
    592567        for (m = m0; m && len > m->m_len; m = m->m_next)
    593568                len -= m->m_len;
    594         if (m == 0)
    595                 return (0);
     569        if (m == NULL)
     570                return (NULL);
    596571        remain = m->m_len - len;
    597572        if (m0->m_flags & M_PKTHDR) {
    598573                MGETHDR(n, wait, m0->m_type);
    599                 if (n == 0)
    600                         return (0);
     574                if (n == NULL)
     575                        return (NULL);
    601576                n->m_pkthdr.rcvif = m0->m_pkthdr.rcvif;
    602577                n->m_pkthdr.len = m0->m_pkthdr.len - len0;
     
    617592        } else if (remain == 0) {
    618593                n = m->m_next;
    619                 m->m_next = 0;
     594                m->m_next = NULL;
    620595                return (n);
    621596        } else {
     
    642617        m->m_len = len;
    643618        n->m_next = m->m_next;
    644         m->m_next = 0;
     619        m->m_next = NULL;
    645620        return (n);
    646621}
     
    649624 */
    650625struct mbuf *
    651 m_devget(buf, totlen, off0, ifp, copy)
    652         char *buf;
    653         int totlen, off0;
    654         struct ifnet *ifp;
    655         void (*copy) __P((char *from, caddr_t to, u_int len));
    656 {
    657         register struct mbuf *m;
    658         struct mbuf *top = 0, **mp = &top;
    659         register int off = off0, len;
    660         register char *cp;
     626m_devget(char *buf, int totlen, int off0, struct ifnet *ifp,
     627        void (*copy)(char *from, caddr_t to, u_int len))
     628{
     629        struct mbuf *m;
     630        struct mbuf *top = NULL, **mp = &top;
     631        int len;
     632        int off = off0;
     633        char *cp;
    661634        char *epkt;
    662635
     
    702675                }
    703676                if (copy)
    704                         copy(cp, mtod(m, caddr_t), (unsigned)len);
     677                        copy(cp, mtod(m, caddr_t), (u_int)len);
    705678                else
    706                         bcopy(cp, mtod(m, caddr_t), (unsigned)len);
     679                        bcopy(cp, mtod(m, caddr_t), (u_int)len);
    707680                cp += len;
    708681                *mp = m;
     
    727700        caddr_t cp;
    728701{
    729         register int mlen;
    730         register struct mbuf *m = m0, *n;
     702        int mlen;
     703        struct mbuf *m = m0, *n;
    731704        int totlen = 0;
    732705
    733         if (m0 == 0)
     706        if (m0 == NULL)
    734707                return 0;
    735708        while (off > (mlen = m->m_len)) {
    736709                off -= mlen;
    737710                totlen += mlen;
    738                 if (m->m_next == 0) {
     711                if (m->m_next == NULL) {
    739712                        n = m_getclr(M_DONTWAIT, m->m_type);
    740                         if (n == 0) {
     713                        if (n == NULL) {
    741714                                /*panic("m_copyback() : malformed chain\n");*/
    742715                                return -1;
     
    749722        while (len > 0) {
    750723                mlen = min (m->m_len - off, len);
    751                 bcopy(cp, off + mtod(m, caddr_t), (unsigned)mlen);
     724                bcopy(cp, off + mtod(m, caddr_t), (u_int)mlen);
    752725                cp += mlen;
    753726                len -= mlen;
     
    759732                        break;
    760733                }
    761                 if (m->m_next == 0) {
     734                if (m->m_next == NULL) {
    762735                        n = m_get(M_DONTWAIT, m->m_type);
    763736                        if (n == 0) {
Note: See TracChangeset for help on using the changeset viewer.