← Back to branch summary

~jderose/ubuntu/raring/qemu/vde-again

« back to all changes in this revision

Viewing changes to slirp/mbuf.c

  • Committer: Bazaar Package Importer
  • Author(s): Riku Voipio, Josh Triplett, Riku Voipio
  • Date: 2009-07-29 13:28:05 UTC
  • mfrom: (1.4.1 upstream)
  • mto: (12.1.1 sid) (10.1.13 sid)
  • mto: This revision was merged to the branch mainline in revision 13.
  • Revision ID: james.westby@ubuntu.com-20090729132805-cau7rfexh7dawyb8
Tags: 0.10.50+git20090729-1
[ Josh Triplett ]
* Remove myself from Uploaders.

[ Riku Voipio ]
* new upstream RC version
* nuke all linux-user patches (applied upstream)
  06_exit_segfault
  12_signal_powerpc_support
  21_net_soopts
  30_syscall_ipc
  32_syscall_sysctl
  35_syscall_sockaddr
  48_signal_terminate
  55_unmux_socketcall
* nuke all other applied-upstream patches
  01_nostrip (better version upstream)
  07_i386_exec_name (can be reintroduced in debian/rules)
  50_linuxbios_isa_bios_ram (shouldn't be needed anymore)
  51_linuxbios_piix_ram_size (applied)
  56_dhcp (crap)
  60_ppc_ld (reintroduce if needed)
  64_ppc_asm_constraints (ditto)
  66_tls_ld.patch (ditto)
  81_compile_dtb.patch (applied upstream)
  82_qemu-img_decimal (ditto)
* move to git
* simplify build rules
* Correct my email address

Show diffs side-by-side

added added

removed removed

Lines of Context:
slirp/mbuf.c
17
17
 
18
18
#include <slirp.h>
19
19
 
20
 
int mbuf_alloced = 0;
21
 
struct mbuf m_freelist, m_usedlist;
22
20
#define MBUF_THRESH 30
23
 
int mbuf_max = 0;
24
21
 
25
22
/*
26
23
 * Find a nice value for msize
29
26
#define SLIRP_MSIZE (IF_MTU + IF_MAXLINKHDR + sizeof(struct m_hdr ) + 6)
30
27
 
31
28
void
32
 
m_init()
 
29
m_init(Slirp *slirp)
33
30
{
34
 
        m_freelist.m_next = m_freelist.m_prev = &m_freelist;
35
 
        m_usedlist.m_next = m_usedlist.m_prev = &m_usedlist;
 
31
    slirp->m_freelist.m_next = slirp->m_freelist.m_prev = &slirp->m_freelist;
 
32
    slirp->m_usedlist.m_next = slirp->m_usedlist.m_prev = &slirp->m_usedlist;
36
33
}
37
34
 
38
35
/*
44
41
 * which tells m_free to actually free() it
45
42
 */
46
43
struct mbuf *
47
 
m_get()
 
44
m_get(Slirp *slirp)
48
45
{
49
46
        register struct mbuf *m;
50
47
        int flags = 0;
51
48
 
52
49
        DEBUG_CALL("m_get");
53
50
 
54
 
        if (m_freelist.m_next == &m_freelist) {
 
51
        if (slirp->m_freelist.m_next == &slirp->m_freelist) {
55
52
                m = (struct mbuf *)malloc(SLIRP_MSIZE);
56
53
                if (m == NULL) goto end_error;
57
 
                mbuf_alloced++;
58
 
                if (mbuf_alloced > MBUF_THRESH)
 
54
                slirp->mbuf_alloced++;
 
55
                if (slirp->mbuf_alloced > MBUF_THRESH)
59
56
                        flags = M_DOFREE;
60
 
                if (mbuf_alloced > mbuf_max)
61
 
                        mbuf_max = mbuf_alloced;
 
57
                m->slirp = slirp;
62
58
        } else {
63
 
                m = m_freelist.m_next;
 
59
                m = slirp->m_freelist.m_next;
64
60
                remque(m);
65
61
        }
66
62
 
67
63
        /* Insert it in the used list */
68
 
        insque(m,&m_usedlist);
 
64
        insque(m,&slirp->m_usedlist);
69
65
        m->m_flags = (flags | M_USEDLIST);
70
66
 
71
67
        /* Initialise it */
72
68
        m->m_size = SLIRP_MSIZE - sizeof(struct m_hdr);
73
69
        m->m_data = m->m_dat;
74
70
        m->m_len = 0;
75
 
        m->m_nextpkt = 0;
76
 
        m->m_prevpkt = 0;
 
71
        m->m_nextpkt = NULL;
 
72
        m->m_prevpkt = NULL;
77
73
end_error:
78
74
        DEBUG_ARG("m = %lx", (long )m);
79
75
        return m;
80
76
}
81
77
 
82
78
void
83
 
m_free(m)
84
 
        struct mbuf *m;
 
79
m_free(struct mbuf *m)
85
80
{
86
81
 
87
82
  DEBUG_CALL("m_free");
101
96
         */
102
97
        if (m->m_flags & M_DOFREE) {
103
98
                free(m);
104
 
                mbuf_alloced--;
 
99
                m->slirp->mbuf_alloced--;
105
100
        } else if ((m->m_flags & M_FREELIST) == 0) {
106
 
                insque(m,&m_freelist);
 
101
                insque(m,&m->slirp->m_freelist);
107
102
                m->m_flags = M_FREELIST; /* Clobber other flags */
108
103
        }
109
104
  } /* if(m) */
115
110
 * an M_EXT data segment
116
111
 */
117
112
void
118
 
m_cat(m, n)
119
 
        register struct mbuf *m, *n;
 
113
m_cat(struct mbuf *m, struct mbuf *n)
120
114
{
121
115
        /*
122
116
         * If there's no room, realloc
133
127
 
134
128
/* make m size bytes large */
135
129
void
136
 
m_inc(m, size)
137
 
        struct mbuf *m;
138
 
        int size;
 
130
m_inc(struct mbuf *m, int size)
139
131
{
140
132
        int datasize;
141
133
 
145
137
        if (m->m_flags & M_EXT) {
146
138
          datasize = m->m_data - m->m_ext;
147
139
          m->m_ext = (char *)realloc(m->m_ext,size);
148
 
/*              if (m->m_ext == NULL)
149
 
 *                      return (struct mbuf *)NULL;
150
 
 */
151
140
          m->m_data = m->m_ext + datasize;
152
141
        } else {
153
142
          char *dat;
154
143
          datasize = m->m_data - m->m_dat;
155
144
          dat = (char *)malloc(size);
156
 
/*              if (dat == NULL)
157
 
 *                      return (struct mbuf *)NULL;
158
 
 */
159
145
          memcpy(dat, m->m_dat, m->m_size);
160
146
 
161
147
          m->m_ext = dat;
170
156
 
171
157
 
172
158
void
173
 
m_adj(m, len)
174
 
        struct mbuf *m;
175
 
        int len;
 
159
m_adj(struct mbuf *m, int len)
176
160
{
177
161
        if (m == NULL)
178
162
                return;
192
176
 * Copy len bytes from m, starting off bytes into n
193
177
 */
194
178
int
195
 
m_copy(n, m, off, len)
196
 
        struct mbuf *n, *m;
197
 
        int off, len;
 
179
m_copy(struct mbuf *n, struct mbuf *m, int off, int len)
198
180
{
199
181
        if (len > M_FREEROOM(n))
200
182
                return -1;
211
193
 * Fortunately, it's not used often
212
194
 */
213
195
struct mbuf *
214
 
dtom(dat)
215
 
        void *dat;
 
196
dtom(Slirp *slirp, void *dat)
216
197
{
217
198
        struct mbuf *m;
218
199
 
220
201
        DEBUG_ARG("dat = %lx", (long )dat);
221
202
 
222
203
        /* bug corrected for M_EXT buffers */
223
 
        for (m = m_usedlist.m_next; m != &m_usedlist; m = m->m_next) {
 
204
        for (m = slirp->m_usedlist.m_next; m != &slirp->m_usedlist;
 
205
             m = m->m_next) {
224
206
          if (m->m_flags & M_EXT) {
225
207
            if( (char *)dat>=m->m_ext && (char *)dat<(m->m_ext + m->m_size) )
226
208
              return m;