linux-user: stack_base is now mandatory on all targets
[qemu.git] / slirp / if.c
1 /*
2 * Copyright (c) 1995 Danny Gasparovski.
3 *
4 * Please read the file COPYRIGHT for the
5 * terms and conditions of the copyright.
6 */
7
8 #include <slirp.h>
9 #include "qemu-timer.h"
10
11 #define ifs_init(ifm) ((ifm)->ifs_next = (ifm)->ifs_prev = (ifm))
12
13 static void
14 ifs_insque(struct mbuf *ifm, struct mbuf *ifmhead)
15 {
16 ifm->ifs_next = ifmhead->ifs_next;
17 ifmhead->ifs_next = ifm;
18 ifm->ifs_prev = ifmhead;
19 ifm->ifs_next->ifs_prev = ifm;
20 }
21
22 static void
23 ifs_remque(struct mbuf *ifm)
24 {
25 ifm->ifs_prev->ifs_next = ifm->ifs_next;
26 ifm->ifs_next->ifs_prev = ifm->ifs_prev;
27 }
28
29 void
30 if_init(Slirp *slirp)
31 {
32 slirp->if_fastq.ifq_next = slirp->if_fastq.ifq_prev = &slirp->if_fastq;
33 slirp->if_batchq.ifq_next = slirp->if_batchq.ifq_prev = &slirp->if_batchq;
34 slirp->next_m = &slirp->if_batchq;
35 }
36
37 /*
38 * if_output: Queue packet into an output queue.
39 * There are 2 output queue's, if_fastq and if_batchq.
40 * Each output queue is a doubly linked list of double linked lists
41 * of mbufs, each list belonging to one "session" (socket). This
42 * way, we can output packets fairly by sending one packet from each
43 * session, instead of all the packets from one session, then all packets
44 * from the next session, etc. Packets on the if_fastq get absolute
45 * priority, but if one session hogs the link, it gets "downgraded"
46 * to the batchq until it runs out of packets, then it'll return
47 * to the fastq (eg. if the user does an ls -alR in a telnet session,
48 * it'll temporarily get downgraded to the batchq)
49 */
50 void
51 if_output(struct socket *so, struct mbuf *ifm)
52 {
53 Slirp *slirp = ifm->slirp;
54 struct mbuf *ifq;
55 int on_fastq = 1;
56
57 DEBUG_CALL("if_output");
58 DEBUG_ARG("so = %lx", (long)so);
59 DEBUG_ARG("ifm = %lx", (long)ifm);
60
61 /*
62 * First remove the mbuf from m_usedlist,
63 * since we're gonna use m_next and m_prev ourselves
64 * XXX Shouldn't need this, gotta change dtom() etc.
65 */
66 if (ifm->m_flags & M_USEDLIST) {
67 remque(ifm);
68 ifm->m_flags &= ~M_USEDLIST;
69 }
70
71 /*
72 * See if there's already a batchq list for this session.
73 * This can include an interactive session, which should go on fastq,
74 * but gets too greedy... hence it'll be downgraded from fastq to batchq.
75 * We mustn't put this packet back on the fastq (or we'll send it out of order)
76 * XXX add cache here?
77 */
78 for (ifq = slirp->if_batchq.ifq_prev; ifq != &slirp->if_batchq;
79 ifq = ifq->ifq_prev) {
80 if (so == ifq->ifq_so) {
81 /* A match! */
82 ifm->ifq_so = so;
83 ifs_insque(ifm, ifq->ifs_prev);
84 goto diddit;
85 }
86 }
87
88 /* No match, check which queue to put it on */
89 if (so && (so->so_iptos & IPTOS_LOWDELAY)) {
90 ifq = slirp->if_fastq.ifq_prev;
91 on_fastq = 1;
92 /*
93 * Check if this packet is a part of the last
94 * packet's session
95 */
96 if (ifq->ifq_so == so) {
97 ifm->ifq_so = so;
98 ifs_insque(ifm, ifq->ifs_prev);
99 goto diddit;
100 }
101 } else
102 ifq = slirp->if_batchq.ifq_prev;
103
104 /* Create a new doubly linked list for this session */
105 ifm->ifq_so = so;
106 ifs_init(ifm);
107 insque(ifm, ifq);
108
109 diddit:
110 slirp->if_queued++;
111
112 if (so) {
113 /* Update *_queued */
114 so->so_queued++;
115 so->so_nqueued++;
116 /*
117 * Check if the interactive session should be downgraded to
118 * the batchq. A session is downgraded if it has queued 6
119 * packets without pausing, and at least 3 of those packets
120 * have been sent over the link
121 * (XXX These are arbitrary numbers, probably not optimal..)
122 */
123 if (on_fastq && ((so->so_nqueued >= 6) &&
124 (so->so_nqueued - so->so_queued) >= 3)) {
125
126 /* Remove from current queue... */
127 remque(ifm->ifs_next);
128
129 /* ...And insert in the new. That'll teach ya! */
130 insque(ifm->ifs_next, &slirp->if_batchq);
131 }
132 }
133
134 #ifndef FULL_BOLT
135 /*
136 * This prevents us from malloc()ing too many mbufs
137 */
138 if_start(ifm->slirp);
139 #endif
140 }
141
142 /*
143 * Send a packet
144 * We choose a packet based on it's position in the output queues;
145 * If there are packets on the fastq, they are sent FIFO, before
146 * everything else. Otherwise we choose the first packet from the
147 * batchq and send it. the next packet chosen will be from the session
148 * after this one, then the session after that one, and so on.. So,
149 * for example, if there are 3 ftp session's fighting for bandwidth,
150 * one packet will be sent from the first session, then one packet
151 * from the second session, then one packet from the third, then back
152 * to the first, etc. etc.
153 */
154 void
155 if_start(Slirp *slirp)
156 {
157 uint64_t now = qemu_get_clock_ns(rt_clock);
158 int requeued = 0;
159 struct mbuf *ifm, *ifqt;
160
161 DEBUG_CALL("if_start");
162
163 if (slirp->if_queued == 0)
164 return; /* Nothing to do */
165
166 again:
167 /* check if we can really output */
168 if (!slirp_can_output(slirp->opaque))
169 return;
170
171 /*
172 * See which queue to get next packet from
173 * If there's something in the fastq, select it immediately
174 */
175 if (slirp->if_fastq.ifq_next != &slirp->if_fastq) {
176 ifm = slirp->if_fastq.ifq_next;
177 } else {
178 /* Nothing on fastq, see if next_m is valid */
179 if (slirp->next_m != &slirp->if_batchq)
180 ifm = slirp->next_m;
181 else
182 ifm = slirp->if_batchq.ifq_next;
183
184 /* Set which packet to send on next iteration */
185 slirp->next_m = ifm->ifq_next;
186 }
187 /* Remove it from the queue */
188 ifqt = ifm->ifq_prev;
189 remque(ifm);
190 slirp->if_queued--;
191
192 /* If there are more packets for this session, re-queue them */
193 if (ifm->ifs_next != /* ifm->ifs_prev != */ ifm) {
194 insque(ifm->ifs_next, ifqt);
195 ifs_remque(ifm);
196 }
197
198 /* Update so_queued */
199 if (ifm->ifq_so) {
200 if (--ifm->ifq_so->so_queued == 0)
201 /* If there's no more queued, reset nqueued */
202 ifm->ifq_so->so_nqueued = 0;
203 }
204
205 if (ifm->expiration_date < now) {
206 /* Expired */
207 m_free(ifm);
208 } else {
209 /* Encapsulate the packet for sending */
210 if (if_encap(slirp, ifm)) {
211 m_free(ifm);
212 } else {
213 /* re-queue */
214 insque(ifm, ifqt);
215 requeued++;
216 }
217 }
218
219 if (slirp->if_queued)
220 goto again;
221
222 slirp->if_queued = requeued;
223 }