The Tor Browser / file comparison

comparison: netwerk/sctp/src/netinet/sctp_ss_functions.c

netwerk/sctp/src/netinet/sctp_ss_functions.c

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:b7f9326ac5fd
1 /*-
2 * Copyright (c) 2010-2012, by Michael Tuexen. All rights reserved.
3 * Copyright (c) 2010-2012, by Randall Stewart. All rights reserved.
4 * Copyright (c) 2010-2012, by Robin Seggelmann. All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are met:
8 *
9 * a) Redistributions of source code must retain the above copyright notice,
10 * this list of conditions and the following disclaimer.
11 *
12 * b) Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in
14 * the documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
18 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
20 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
26 * THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #ifdef __FreeBSD__
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD: head/sys/netinet/sctp_ss_functions.c 235828 2012-05-23 11:26:28Z tuexen $");
32 #endif
33
34 #include <netinet/sctp_pcb.h>
35 #if defined(__Userspace__)
36 #include <netinet/sctp_os_userspace.h>
37 #endif
38
39 /*
40 * Default simple round-robin algorithm.
41 * Just interates the streams in the order they appear.
42 */
43
44 static void
45 sctp_ss_default_add(struct sctp_tcb *, struct sctp_association *,
46 struct sctp_stream_out *,
47 struct sctp_stream_queue_pending *, int);
48
49 static void
50 sctp_ss_default_remove(struct sctp_tcb *, struct sctp_association *,
51 struct sctp_stream_out *,
52 struct sctp_stream_queue_pending *, int);
53
54 static void
55 sctp_ss_default_init(struct sctp_tcb *stcb, struct sctp_association *asoc,
56 int holds_lock)
57 {
58 uint16_t i;
59
60 TAILQ_INIT(&asoc->ss_data.out_wheel);
61 /*
62 * If there is data in the stream queues already,
63 * the scheduler of an existing association has
64 * been changed. We need to add all stream queues
65 * to the wheel.
66 */
67 for (i = 0; i < stcb->asoc.streamoutcnt; i++) {
68 stcb->asoc.ss_functions.sctp_ss_add_to_stream(stcb, &stcb->asoc,
69 &stcb->asoc.strmout[i],
70 NULL, holds_lock);
71 }
72 return;
73 }
74
75 static void
76 sctp_ss_default_clear(struct sctp_tcb *stcb, struct sctp_association *asoc,
77 int clear_values SCTP_UNUSED, int holds_lock)
78 {
79 if (holds_lock == 0) {
80 SCTP_TCB_SEND_LOCK(stcb);
81 }
82 while (!TAILQ_EMPTY(&asoc->ss_data.out_wheel)) {
83 struct sctp_stream_out *strq = TAILQ_FIRST(&asoc->ss_data.out_wheel);
84 TAILQ_REMOVE(&asoc->ss_data.out_wheel, TAILQ_FIRST(&asoc->ss_data.out_wheel), ss_params.rr.next_spoke);
85 strq->ss_params.rr.next_spoke.tqe_next = NULL;
86 strq->ss_params.rr.next_spoke.tqe_prev = NULL;
87 }
88 asoc->last_out_stream = NULL;
89 if (holds_lock == 0) {
90 SCTP_TCB_SEND_UNLOCK(stcb);
91 }
92 return;
93 }
94
95 static void
96 sctp_ss_default_init_stream(struct sctp_stream_out *strq, struct sctp_stream_out *with_strq SCTP_UNUSED)
97 {
98 strq->ss_params.rr.next_spoke.tqe_next = NULL;
99 strq->ss_params.rr.next_spoke.tqe_prev = NULL;
100 return;
101 }
102
103 static void
104 sctp_ss_default_add(struct sctp_tcb *stcb, struct sctp_association *asoc,
105 struct sctp_stream_out *strq,
106 struct sctp_stream_queue_pending *sp SCTP_UNUSED, int holds_lock)
107 {
108 if (holds_lock == 0) {
109 SCTP_TCB_SEND_LOCK(stcb);
110 }
111 /* Add to wheel if not already on it and stream queue not empty */
112 if (!TAILQ_EMPTY(&strq->outqueue) &&
113 (strq->ss_params.rr.next_spoke.tqe_next == NULL) &&
114 (strq->ss_params.rr.next_spoke.tqe_prev == NULL)) {
115 TAILQ_INSERT_TAIL(&asoc->ss_data.out_wheel,
116 strq, ss_params.rr.next_spoke);
117 }
118 if (holds_lock == 0) {
119 SCTP_TCB_SEND_UNLOCK(stcb);
120 }
121 return;
122 }
123
124 static int
125 sctp_ss_default_is_empty(struct sctp_tcb *stcb SCTP_UNUSED, struct sctp_association *asoc)
126 {
127 if (TAILQ_EMPTY(&asoc->ss_data.out_wheel)) {
128 return (1);
129 } else {
130 return (0);
131 }
132 }
133
134 static void
135 sctp_ss_default_remove(struct sctp_tcb *stcb, struct sctp_association *asoc,
136 struct sctp_stream_out *strq,
137 struct sctp_stream_queue_pending *sp SCTP_UNUSED, int holds_lock)
138 {
139 if (holds_lock == 0) {
140 SCTP_TCB_SEND_LOCK(stcb);
141 }
142 /* Remove from wheel if stream queue is empty and actually is on the wheel */
143 if (TAILQ_EMPTY(&strq->outqueue) &&
144 (strq->ss_params.rr.next_spoke.tqe_next != NULL ||
145 strq->ss_params.rr.next_spoke.tqe_prev != NULL)) {
146 if (asoc->last_out_stream == strq) {
147 asoc->last_out_stream = TAILQ_PREV(asoc->last_out_stream,
148 sctpwheel_listhead,
149 ss_params.rr.next_spoke);
150 if (asoc->last_out_stream == NULL) {
151 asoc->last_out_stream = TAILQ_LAST(&asoc->ss_data.out_wheel,
152 sctpwheel_listhead);
153 }
154 if (asoc->last_out_stream == strq) {
155 asoc->last_out_stream = NULL;
156 }
157 }
158 TAILQ_REMOVE(&asoc->ss_data.out_wheel, strq, ss_params.rr.next_spoke);
159 strq->ss_params.rr.next_spoke.tqe_next = NULL;
160 strq->ss_params.rr.next_spoke.tqe_prev = NULL;
161 }
162 if (holds_lock == 0) {
163 SCTP_TCB_SEND_UNLOCK(stcb);
164 }
165 return;
166 }
167
168
169 static struct sctp_stream_out *
170 sctp_ss_default_select(struct sctp_tcb *stcb SCTP_UNUSED, struct sctp_nets *net,
171 struct sctp_association *asoc)
172 {
173 struct sctp_stream_out *strq, *strqt;
174
175 strqt = asoc->last_out_stream;
176 default_again:
177 /* Find the next stream to use */
178 if (strqt == NULL) {
179 strq = TAILQ_FIRST(&asoc->ss_data.out_wheel);
180 } else {
181 strq = TAILQ_NEXT(strqt, ss_params.rr.next_spoke);
182 if (strq == NULL) {
183 strq = TAILQ_FIRST(&asoc->ss_data.out_wheel);
184 }
185 }
186
187 /* If CMT is off, we must validate that
188 * the stream in question has the first
189 * item pointed towards are network destination
190 * requested by the caller. Note that if we
191 * turn out to be locked to a stream (assigning
192 * TSN's then we must stop, since we cannot
193 * look for another stream with data to send
194 * to that destination). In CMT's case, by
195 * skipping this check, we will send one
196 * data packet towards the requested net.
197 */
198 if (net != NULL && strq != NULL &&
199 SCTP_BASE_SYSCTL(sctp_cmt_on_off) == 0) {
200 if (TAILQ_FIRST(&strq->outqueue) &&
201 TAILQ_FIRST(&strq->outqueue)->net != NULL &&
202 TAILQ_FIRST(&strq->outqueue)->net != net) {
203 if (strq == asoc->last_out_stream) {
204 return (NULL);
205 } else {
206 strqt = strq;
207 goto default_again;
208 }
209 }
210 }
211 return (strq);
212 }
213
214 static void
215 sctp_ss_default_scheduled(struct sctp_tcb *stcb SCTP_UNUSED, struct sctp_nets *net SCTP_UNUSED,
216 struct sctp_association *asoc SCTP_UNUSED,
217 struct sctp_stream_out *strq, int moved_how_much SCTP_UNUSED)
218 {
219 asoc->last_out_stream = strq;
220 return;
221 }
222
223 static void
224 sctp_ss_default_packet_done(struct sctp_tcb *stcb SCTP_UNUSED, struct sctp_nets *net SCTP_UNUSED,
225 struct sctp_association *asoc SCTP_UNUSED)
226 {
227 /* Nothing to be done here */
228 return;
229 }
230
231 static int
232 sctp_ss_default_get_value(struct sctp_tcb *stcb SCTP_UNUSED, struct sctp_association *asoc SCTP_UNUSED,
233 struct sctp_stream_out *strq SCTP_UNUSED, uint16_t *value SCTP_UNUSED)
234 {
235 /* Nothing to be done here */
236 return (-1);
237 }
238
239 static int
240 sctp_ss_default_set_value(struct sctp_tcb *stcb SCTP_UNUSED, struct sctp_association *asoc SCTP_UNUSED,
241 struct sctp_stream_out *strq SCTP_UNUSED, uint16_t value SCTP_UNUSED)
242 {
243 /* Nothing to be done here */
244 return (-1);
245 }
246
247 /*
248 * Real round-robin algorithm.
249 * Always interates the streams in ascending order.
250 */
251 static void
252 sctp_ss_rr_add(struct sctp_tcb *stcb, struct sctp_association *asoc,
253 struct sctp_stream_out *strq,
254 struct sctp_stream_queue_pending *sp SCTP_UNUSED, int holds_lock)
255 {
256 struct sctp_stream_out *strqt;
257
258 if (holds_lock == 0) {
259 SCTP_TCB_SEND_LOCK(stcb);
260 }
261 if (!TAILQ_EMPTY(&strq->outqueue) &&
262 (strq->ss_params.rr.next_spoke.tqe_next == NULL) &&
263 (strq->ss_params.rr.next_spoke.tqe_prev == NULL)) {
264 if (TAILQ_EMPTY(&asoc->ss_data.out_wheel)) {
265 TAILQ_INSERT_HEAD(&asoc->ss_data.out_wheel, strq, ss_params.rr.next_spoke);
266 } else {
267 strqt = TAILQ_FIRST(&asoc->ss_data.out_wheel);
268 while (strqt != NULL && (strqt->stream_no < strq->stream_no)) {
269 strqt = TAILQ_NEXT(strqt, ss_params.rr.next_spoke);
270 }
271 if (strqt != NULL) {
272 TAILQ_INSERT_BEFORE(strqt, strq, ss_params.rr.next_spoke);
273 } else {
274 TAILQ_INSERT_TAIL(&asoc->ss_data.out_wheel, strq, ss_params.rr.next_spoke);
275 }
276 }
277 }
278 if (holds_lock == 0) {
279 SCTP_TCB_SEND_UNLOCK(stcb);
280 }
281 return;
282 }
283
284 /*
285 * Real round-robin per packet algorithm.
286 * Always interates the streams in ascending order and
287 * only fills messages of the same stream in a packet.
288 */
289 static struct sctp_stream_out *
290 sctp_ss_rrp_select(struct sctp_tcb *stcb SCTP_UNUSED, struct sctp_nets *net SCTP_UNUSED,
291 struct sctp_association *asoc)
292 {
293 return (asoc->last_out_stream);
294 }
295
296 static void
297 sctp_ss_rrp_packet_done(struct sctp_tcb *stcb SCTP_UNUSED, struct sctp_nets *net,
298 struct sctp_association *asoc)
299 {
300 struct sctp_stream_out *strq, *strqt;
301
302 strqt = asoc->last_out_stream;
303 rrp_again:
304 /* Find the next stream to use */
305 if (strqt == NULL) {
306 strq = TAILQ_FIRST(&asoc->ss_data.out_wheel);
307 } else {
308 strq = TAILQ_NEXT(strqt, ss_params.rr.next_spoke);
309 if (strq == NULL) {
310 strq = TAILQ_FIRST(&asoc->ss_data.out_wheel);
311 }
312 }
313
314 /* If CMT is off, we must validate that
315 * the stream in question has the first
316 * item pointed towards are network destination
317 * requested by the caller. Note that if we
318 * turn out to be locked to a stream (assigning
319 * TSN's then we must stop, since we cannot
320 * look for another stream with data to send
321 * to that destination). In CMT's case, by
322 * skipping this check, we will send one
323 * data packet towards the requested net.
324 */
325 if (net != NULL && strq != NULL &&
326 SCTP_BASE_SYSCTL(sctp_cmt_on_off) == 0) {
327 if (TAILQ_FIRST(&strq->outqueue) &&
328 TAILQ_FIRST(&strq->outqueue)->net != NULL &&
329 TAILQ_FIRST(&strq->outqueue)->net != net) {
330 if (strq == asoc->last_out_stream) {
331 strq = NULL;
332 } else {
333 strqt = strq;
334 goto rrp_again;
335 }
336 }
337 }
338 asoc->last_out_stream = strq;
339 return;
340 }
341
342
343 /*
344 * Priority algorithm.
345 * Always prefers streams based on their priority id.
346 */
347 static void
348 sctp_ss_prio_clear(struct sctp_tcb *stcb, struct sctp_association *asoc,
349 int clear_values, int holds_lock)
350 {
351 if (holds_lock == 0) {
352 SCTP_TCB_SEND_LOCK(stcb);
353 }
354 while (!TAILQ_EMPTY(&asoc->ss_data.out_wheel)) {
355 struct sctp_stream_out *strq = TAILQ_FIRST(&asoc->ss_data.out_wheel);
356 if (clear_values) {
357 strq->ss_params.prio.priority = 0;
358 }
359 TAILQ_REMOVE(&asoc->ss_data.out_wheel, TAILQ_FIRST(&asoc->ss_data.out_wheel), ss_params.prio.next_spoke);
360 strq->ss_params.prio.next_spoke.tqe_next = NULL;
361 strq->ss_params.prio.next_spoke.tqe_prev = NULL;
362
363 }
364 asoc->last_out_stream = NULL;
365 if (holds_lock == 0) {
366 SCTP_TCB_SEND_UNLOCK(stcb);
367 }
368 return;
369 }
370
371 static void
372 sctp_ss_prio_init_stream(struct sctp_stream_out *strq, struct sctp_stream_out *with_strq)
373 {
374 strq->ss_params.prio.next_spoke.tqe_next = NULL;
375 strq->ss_params.prio.next_spoke.tqe_prev = NULL;
376 if (with_strq != NULL) {
377 strq->ss_params.prio.priority = with_strq->ss_params.prio.priority;
378 } else {
379 strq->ss_params.prio.priority = 0;
380 }
381 return;
382 }
383
384 static void
385 sctp_ss_prio_add(struct sctp_tcb *stcb, struct sctp_association *asoc,
386 struct sctp_stream_out *strq, struct sctp_stream_queue_pending *sp SCTP_UNUSED,
387 int holds_lock)
388 {
389 struct sctp_stream_out *strqt;
390
391 if (holds_lock == 0) {
392 SCTP_TCB_SEND_LOCK(stcb);
393 }
394 /* Add to wheel if not already on it and stream queue not empty */
395 if (!TAILQ_EMPTY(&strq->outqueue) &&
396 (strq->ss_params.prio.next_spoke.tqe_next == NULL) &&
397 (strq->ss_params.prio.next_spoke.tqe_prev == NULL)) {
398 if (TAILQ_EMPTY(&asoc->ss_data.out_wheel)) {
399 TAILQ_INSERT_HEAD(&asoc->ss_data.out_wheel, strq, ss_params.prio.next_spoke);
400 } else {
401 strqt = TAILQ_FIRST(&asoc->ss_data.out_wheel);
402 while (strqt != NULL && strqt->ss_params.prio.priority < strq->ss_params.prio.priority) {
403 strqt = TAILQ_NEXT(strqt, ss_params.prio.next_spoke);
404 }
405 if (strqt != NULL) {
406 TAILQ_INSERT_BEFORE(strqt, strq, ss_params.prio.next_spoke);
407 } else {
408 TAILQ_INSERT_TAIL(&asoc->ss_data.out_wheel, strq, ss_params.prio.next_spoke);
409 }
410 }
411 }
412 if (holds_lock == 0) {
413 SCTP_TCB_SEND_UNLOCK(stcb);
414 }
415 return;
416 }
417
418 static void
419 sctp_ss_prio_remove(struct sctp_tcb *stcb, struct sctp_association *asoc,
420 struct sctp_stream_out *strq, struct sctp_stream_queue_pending *sp SCTP_UNUSED,
421 int holds_lock)
422 {
423 if (holds_lock == 0) {
424 SCTP_TCB_SEND_LOCK(stcb);
425 }
426 /* Remove from wheel if stream queue is empty and actually is on the wheel */
427 if (TAILQ_EMPTY(&strq->outqueue) &&
428 (strq->ss_params.prio.next_spoke.tqe_next != NULL ||
429 strq->ss_params.prio.next_spoke.tqe_prev != NULL)) {
430 if (asoc->last_out_stream == strq) {
431 asoc->last_out_stream = TAILQ_PREV(asoc->last_out_stream, sctpwheel_listhead,
432 ss_params.prio.next_spoke);
433 if (asoc->last_out_stream == NULL) {
434 asoc->last_out_stream = TAILQ_LAST(&asoc->ss_data.out_wheel,
435 sctpwheel_listhead);
436 }
437 if (asoc->last_out_stream == strq) {
438 asoc->last_out_stream = NULL;
439 }
440 }
441 TAILQ_REMOVE(&asoc->ss_data.out_wheel, strq, ss_params.prio.next_spoke);
442 strq->ss_params.prio.next_spoke.tqe_next = NULL;
443 strq->ss_params.prio.next_spoke.tqe_prev = NULL;
444 }
445 if (holds_lock == 0) {
446 SCTP_TCB_SEND_UNLOCK(stcb);
447 }
448 return;
449 }
450
451 static struct sctp_stream_out*
452 sctp_ss_prio_select(struct sctp_tcb *stcb SCTP_UNUSED, struct sctp_nets *net,
453 struct sctp_association *asoc)
454 {
455 struct sctp_stream_out *strq, *strqt, *strqn;
456
457 strqt = asoc->last_out_stream;
458 prio_again:
459 /* Find the next stream to use */
460 if (strqt == NULL) {
461 strq = TAILQ_FIRST(&asoc->ss_data.out_wheel);
462 } else {
463 strqn = TAILQ_NEXT(strqt, ss_params.prio.next_spoke);
464 if (strqn != NULL &&
465 strqn->ss_params.prio.priority == strqt->ss_params.prio.priority) {
466 strq = strqn;
467 } else {
468 strq = TAILQ_FIRST(&asoc->ss_data.out_wheel);
469 }
470 }
471
472 /* If CMT is off, we must validate that
473 * the stream in question has the first
474 * item pointed towards are network destination
475 * requested by the caller. Note that if we
476 * turn out to be locked to a stream (assigning
477 * TSN's then we must stop, since we cannot
478 * look for another stream with data to send
479 * to that destination). In CMT's case, by
480 * skipping this check, we will send one
481 * data packet towards the requested net.
482 */
483 if (net != NULL && strq != NULL &&
484 SCTP_BASE_SYSCTL(sctp_cmt_on_off) == 0) {
485 if (TAILQ_FIRST(&strq->outqueue) &&
486 TAILQ_FIRST(&strq->outqueue)->net != NULL &&
487 TAILQ_FIRST(&strq->outqueue)->net != net) {
488 if (strq == asoc->last_out_stream) {
489 return (NULL);
490 } else {
491 strqt = strq;
492 goto prio_again;
493 }
494 }
495 }
496 return (strq);
497 }
498
499 static int
500 sctp_ss_prio_get_value(struct sctp_tcb *stcb SCTP_UNUSED, struct sctp_association *asoc SCTP_UNUSED,
501 struct sctp_stream_out *strq, uint16_t *value)
502 {
503 if (strq == NULL) {
504 return (-1);
505 }
506 *value = strq->ss_params.prio.priority;
507 return (1);
508 }
509
510 static int
511 sctp_ss_prio_set_value(struct sctp_tcb *stcb, struct sctp_association *asoc,
512 struct sctp_stream_out *strq, uint16_t value)
513 {
514 if (strq == NULL) {
515 return (-1);
516 }
517 strq->ss_params.prio.priority = value;
518 sctp_ss_prio_remove(stcb, asoc, strq, NULL, 1);
519 sctp_ss_prio_add(stcb, asoc, strq, NULL, 1);
520 return (1);
521 }
522
523 /*
524 * Fair bandwidth algorithm.
525 * Maintains an equal troughput per stream.
526 */
527 static void
528 sctp_ss_fb_clear(struct sctp_tcb *stcb, struct sctp_association *asoc,
529 int clear_values, int holds_lock)
530 {
531 if (holds_lock == 0) {
532 SCTP_TCB_SEND_LOCK(stcb);
533 }
534 while (!TAILQ_EMPTY(&asoc->ss_data.out_wheel)) {
535 struct sctp_stream_out *strq = TAILQ_FIRST(&asoc->ss_data.out_wheel);
536 if (clear_values) {
537 strq->ss_params.fb.rounds = -1;
538 }
539 TAILQ_REMOVE(&asoc->ss_data.out_wheel, TAILQ_FIRST(&asoc->ss_data.out_wheel), ss_params.fb.next_spoke);
540 strq->ss_params.fb.next_spoke.tqe_next = NULL;
541 strq->ss_params.fb.next_spoke.tqe_prev = NULL;
542 }
543 asoc->last_out_stream = NULL;
544 if (holds_lock == 0) {
545 SCTP_TCB_SEND_UNLOCK(stcb);
546 }
547 return;
548 }
549
550 static void
551 sctp_ss_fb_init_stream(struct sctp_stream_out *strq, struct sctp_stream_out *with_strq)
552 {
553 strq->ss_params.fb.next_spoke.tqe_next = NULL;
554 strq->ss_params.fb.next_spoke.tqe_prev = NULL;
555 if (with_strq != NULL) {
556 strq->ss_params.fb.rounds = with_strq->ss_params.fb.rounds;
557 } else {
558 strq->ss_params.fb.rounds = -1;
559 }
560 return;
561 }
562
563 static void
564 sctp_ss_fb_add(struct sctp_tcb *stcb, struct sctp_association *asoc,
565 struct sctp_stream_out *strq, struct sctp_stream_queue_pending *sp SCTP_UNUSED,
566 int holds_lock)
567 {
568 if (holds_lock == 0) {
569 SCTP_TCB_SEND_LOCK(stcb);
570 }
571 if (!TAILQ_EMPTY(&strq->outqueue) &&
572 (strq->ss_params.fb.next_spoke.tqe_next == NULL) &&
573 (strq->ss_params.fb.next_spoke.tqe_prev == NULL)) {
574 if (strq->ss_params.fb.rounds < 0)
575 strq->ss_params.fb.rounds = TAILQ_FIRST(&strq->outqueue)->length;
576 TAILQ_INSERT_TAIL(&asoc->ss_data.out_wheel, strq, ss_params.fb.next_spoke);
577 }
578 if (holds_lock == 0) {
579 SCTP_TCB_SEND_UNLOCK(stcb);
580 }
581 return;
582 }
583
584 static void
585 sctp_ss_fb_remove(struct sctp_tcb *stcb, struct sctp_association *asoc,
586 struct sctp_stream_out *strq, struct sctp_stream_queue_pending *sp SCTP_UNUSED,
587 int holds_lock)
588 {
589 if (holds_lock == 0) {
590 SCTP_TCB_SEND_LOCK(stcb);
591 }
592 /* Remove from wheel if stream queue is empty and actually is on the wheel */
593 if (TAILQ_EMPTY(&strq->outqueue) &&
594 (strq->ss_params.fb.next_spoke.tqe_next != NULL ||
595 strq->ss_params.fb.next_spoke.tqe_prev != NULL)) {
596 if (asoc->last_out_stream == strq) {
597 asoc->last_out_stream = TAILQ_PREV(asoc->last_out_stream, sctpwheel_listhead,
598 ss_params.fb.next_spoke);
599 if (asoc->last_out_stream == NULL) {
600 asoc->last_out_stream = TAILQ_LAST(&asoc->ss_data.out_wheel,
601 sctpwheel_listhead);
602 }
603 if (asoc->last_out_stream == strq) {
604 asoc->last_out_stream = NULL;
605 }
606 }
607 TAILQ_REMOVE(&asoc->ss_data.out_wheel, strq, ss_params.fb.next_spoke);
608 strq->ss_params.fb.next_spoke.tqe_next = NULL;
609 strq->ss_params.fb.next_spoke.tqe_prev = NULL;
610 }
611 if (holds_lock == 0) {
612 SCTP_TCB_SEND_UNLOCK(stcb);
613 }
614 return;
615 }
616
617 static struct sctp_stream_out*
618 sctp_ss_fb_select(struct sctp_tcb *stcb SCTP_UNUSED, struct sctp_nets *net,
619 struct sctp_association *asoc)
620 {
621 struct sctp_stream_out *strq = NULL, *strqt;
622
623 if (asoc->last_out_stream == NULL ||
624 TAILQ_FIRST(&asoc->ss_data.out_wheel) == TAILQ_LAST(&asoc->ss_data.out_wheel, sctpwheel_listhead)) {
625 strqt = TAILQ_FIRST(&asoc->ss_data.out_wheel);
626 } else {
627 strqt = TAILQ_NEXT(asoc->last_out_stream, ss_params.fb.next_spoke);
628 }
629 do {
630 if ((strqt != NULL) &&
631 ((SCTP_BASE_SYSCTL(sctp_cmt_on_off) > 0) ||
632 (SCTP_BASE_SYSCTL(sctp_cmt_on_off) == 0 &&
633 (net == NULL || (TAILQ_FIRST(&strqt->outqueue) && TAILQ_FIRST(&strqt->outqueue)->net == NULL) ||
634 (net != NULL && TAILQ_FIRST(&strqt->outqueue) && TAILQ_FIRST(&strqt->outqueue)->net != NULL &&
635 TAILQ_FIRST(&strqt->outqueue)->net == net))))) {
636 if ((strqt->ss_params.fb.rounds >= 0) && (strq == NULL ||
637 strqt->ss_params.fb.rounds < strq->ss_params.fb.rounds)) {
638 strq = strqt;
639 }
640 }
641 if (strqt != NULL) {
642 strqt = TAILQ_NEXT(strqt, ss_params.fb.next_spoke);
643 } else {
644 strqt = TAILQ_FIRST(&asoc->ss_data.out_wheel);
645 }
646 } while (strqt != strq);
647 return (strq);
648 }
649
650 static void
651 sctp_ss_fb_scheduled(struct sctp_tcb *stcb SCTP_UNUSED, struct sctp_nets *net SCTP_UNUSED,
652 struct sctp_association *asoc, struct sctp_stream_out *strq,
653 int moved_how_much SCTP_UNUSED)
654 {
655 struct sctp_stream_out *strqt;
656 int subtract;
657
658 subtract = strq->ss_params.fb.rounds;
659 TAILQ_FOREACH(strqt, &asoc->ss_data.out_wheel, ss_params.fb.next_spoke) {
660 strqt->ss_params.fb.rounds -= subtract;
661 if (strqt->ss_params.fb.rounds < 0)
662 strqt->ss_params.fb.rounds = 0;
663 }
664 if (TAILQ_FIRST(&strq->outqueue)) {
665 strq->ss_params.fb.rounds = TAILQ_FIRST(&strq->outqueue)->length;
666 } else {
667 strq->ss_params.fb.rounds = -1;
668 }
669 asoc->last_out_stream = strq;
670 return;
671 }
672
673 /*
674 * First-come, first-serve algorithm.
675 * Maintains the order provided by the application.
676 */
677 static void
678 sctp_ss_fcfs_add(struct sctp_tcb *stcb, struct sctp_association *asoc,
679 struct sctp_stream_out *strq, struct sctp_stream_queue_pending *sp,
680 int holds_lock);
681
682 static void
683 sctp_ss_fcfs_init(struct sctp_tcb *stcb, struct sctp_association *asoc,
684 int holds_lock)
685 {
686 uint32_t x, n = 0, add_more = 1;
687 struct sctp_stream_queue_pending *sp;
688 uint16_t i;
689
690 TAILQ_INIT(&asoc->ss_data.out_list);
691 /*
692 * If there is data in the stream queues already,
693 * the scheduler of an existing association has
694 * been changed. We can only cycle through the
695 * stream queues and add everything to the FCFS
696 * queue.
697 */
698 while (add_more) {
699 add_more = 0;
700 for (i = 0; i < stcb->asoc.streamoutcnt; i++) {
701 sp = TAILQ_FIRST(&stcb->asoc.strmout[i].outqueue);
702 x = 0;
703 /* Find n. message in current stream queue */
704 while (sp != NULL && x < n) {
705 sp = TAILQ_NEXT(sp, next);
706 x++;
707 }
708 if (sp != NULL) {
709 sctp_ss_fcfs_add(stcb, &stcb->asoc, &stcb->asoc.strmout[i], sp, holds_lock);
710 add_more = 1;
711 }
712 }
713 n++;
714 }
715 return;
716 }
717
718 static void
719 sctp_ss_fcfs_clear(struct sctp_tcb *stcb, struct sctp_association *asoc,
720 int clear_values, int holds_lock)
721 {
722 if (clear_values) {
723 if (holds_lock == 0) {
724 SCTP_TCB_SEND_LOCK(stcb);
725 }
726 while (!TAILQ_EMPTY(&asoc->ss_data.out_list)) {
727 TAILQ_REMOVE(&asoc->ss_data.out_list, TAILQ_FIRST(&asoc->ss_data.out_list), ss_next);
728 }
729 if (holds_lock == 0) {
730 SCTP_TCB_SEND_UNLOCK(stcb);
731 }
732 }
733 return;
734 }
735
736 static void
737 sctp_ss_fcfs_init_stream(struct sctp_stream_out *strq SCTP_UNUSED, struct sctp_stream_out *with_strq SCTP_UNUSED)
738 {
739 /* Nothing to be done here */
740 return;
741 }
742
743 static void
744 sctp_ss_fcfs_add(struct sctp_tcb *stcb, struct sctp_association *asoc,
745 struct sctp_stream_out *strq SCTP_UNUSED, struct sctp_stream_queue_pending *sp,
746 int holds_lock)
747 {
748 if (holds_lock == 0) {
749 SCTP_TCB_SEND_LOCK(stcb);
750 }
751 if (sp && (sp->ss_next.tqe_next == NULL) &&
752 (sp->ss_next.tqe_prev == NULL)) {
753 TAILQ_INSERT_TAIL(&asoc->ss_data.out_list, sp, ss_next);
754 }
755 if (holds_lock == 0) {
756 SCTP_TCB_SEND_UNLOCK(stcb);
757 }
758 return;
759 }
760
761 static int
762 sctp_ss_fcfs_is_empty(struct sctp_tcb *stcb SCTP_UNUSED, struct sctp_association *asoc)
763 {
764 if (TAILQ_EMPTY(&asoc->ss_data.out_list)) {
765 return (1);
766 } else {
767 return (0);
768 }
769 }
770
771 static void
772 sctp_ss_fcfs_remove(struct sctp_tcb *stcb, struct sctp_association *asoc,
773 struct sctp_stream_out *strq SCTP_UNUSED, struct sctp_stream_queue_pending *sp,
774 int holds_lock)
775 {
776 if (holds_lock == 0) {
777 SCTP_TCB_SEND_LOCK(stcb);
778 }
779 if (sp &&
780 ((sp->ss_next.tqe_next != NULL) ||
781 (sp->ss_next.tqe_prev != NULL))) {
782 TAILQ_REMOVE(&asoc->ss_data.out_list, sp, ss_next);
783 }
784 if (holds_lock == 0) {
785 SCTP_TCB_SEND_UNLOCK(stcb);
786 }
787 return;
788 }
789
790
791 static struct sctp_stream_out *
792 sctp_ss_fcfs_select(struct sctp_tcb *stcb SCTP_UNUSED, struct sctp_nets *net,
793 struct sctp_association *asoc)
794 {
795 struct sctp_stream_out *strq;
796 struct sctp_stream_queue_pending *sp;
797
798 sp = TAILQ_FIRST(&asoc->ss_data.out_list);
799 default_again:
800 if (sp != NULL) {
801 strq = &asoc->strmout[sp->stream];
802 } else {
803 strq = NULL;
804 }
805
806 /*
807 * If CMT is off, we must validate that
808 * the stream in question has the first
809 * item pointed towards are network destination
810 * requested by the caller. Note that if we
811 * turn out to be locked to a stream (assigning
812 * TSN's then we must stop, since we cannot
813 * look for another stream with data to send
814 * to that destination). In CMT's case, by
815 * skipping this check, we will send one
816 * data packet towards the requested net.
817 */
818 if (net != NULL && strq != NULL &&
819 SCTP_BASE_SYSCTL(sctp_cmt_on_off) == 0) {
820 if (TAILQ_FIRST(&strq->outqueue) &&
821 TAILQ_FIRST(&strq->outqueue)->net != NULL &&
822 TAILQ_FIRST(&strq->outqueue)->net != net) {
823 sp = TAILQ_NEXT(sp, ss_next);
824 goto default_again;
825 }
826 }
827 return (strq);
828 }
829
830 struct sctp_ss_functions sctp_ss_functions[] = {
831 /* SCTP_SS_DEFAULT */
832 {
833 #if defined(__Windows__) || defined(__Userspace_os_Windows)
834 sctp_ss_default_init,
835 sctp_ss_default_clear,
836 sctp_ss_default_init_stream,
837 sctp_ss_default_add,
838 sctp_ss_default_is_empty,
839 sctp_ss_default_remove,
840 sctp_ss_default_select,
841 sctp_ss_default_scheduled,
842 sctp_ss_default_packet_done,
843 sctp_ss_default_get_value,
844 sctp_ss_default_set_value
845 #else
846 .sctp_ss_init = sctp_ss_default_init,
847 .sctp_ss_clear = sctp_ss_default_clear,
848 .sctp_ss_init_stream = sctp_ss_default_init_stream,
849 .sctp_ss_add_to_stream = sctp_ss_default_add,
850 .sctp_ss_is_empty = sctp_ss_default_is_empty,
851 .sctp_ss_remove_from_stream = sctp_ss_default_remove,
852 .sctp_ss_select_stream = sctp_ss_default_select,
853 .sctp_ss_scheduled = sctp_ss_default_scheduled,
854 .sctp_ss_packet_done = sctp_ss_default_packet_done,
855 .sctp_ss_get_value = sctp_ss_default_get_value,
856 .sctp_ss_set_value = sctp_ss_default_set_value
857 #endif
858 },
859 /* SCTP_SS_ROUND_ROBIN */
860 {
861 #if defined(__Windows__) || defined(__Userspace_os_Windows)
862 sctp_ss_default_init,
863 sctp_ss_default_clear,
864 sctp_ss_default_init_stream,
865 sctp_ss_rr_add,
866 sctp_ss_default_is_empty,
867 sctp_ss_default_remove,
868 sctp_ss_default_select,
869 sctp_ss_default_scheduled,
870 sctp_ss_default_packet_done,
871 sctp_ss_default_get_value,
872 sctp_ss_default_set_value
873 #else
874 .sctp_ss_init = sctp_ss_default_init,
875 .sctp_ss_clear = sctp_ss_default_clear,
876 .sctp_ss_init_stream = sctp_ss_default_init_stream,
877 .sctp_ss_add_to_stream = sctp_ss_rr_add,
878 .sctp_ss_is_empty = sctp_ss_default_is_empty,
879 .sctp_ss_remove_from_stream = sctp_ss_default_remove,
880 .sctp_ss_select_stream = sctp_ss_default_select,
881 .sctp_ss_scheduled = sctp_ss_default_scheduled,
882 .sctp_ss_packet_done = sctp_ss_default_packet_done,
883 .sctp_ss_get_value = sctp_ss_default_get_value,
884 .sctp_ss_set_value = sctp_ss_default_set_value
885 #endif
886 },
887 /* SCTP_SS_ROUND_ROBIN_PACKET */
888 {
889 #if defined(__Windows__) || defined(__Userspace_os_Windows)
890 sctp_ss_default_init,
891 sctp_ss_default_clear,
892 sctp_ss_default_init_stream,
893 sctp_ss_rr_add,
894 sctp_ss_default_is_empty,
895 sctp_ss_default_remove,
896 sctp_ss_rrp_select,
897 sctp_ss_default_scheduled,
898 sctp_ss_rrp_packet_done,
899 sctp_ss_default_get_value,
900 sctp_ss_default_set_value
901 #else
902 .sctp_ss_init = sctp_ss_default_init,
903 .sctp_ss_clear = sctp_ss_default_clear,
904 .sctp_ss_init_stream = sctp_ss_default_init_stream,
905 .sctp_ss_add_to_stream = sctp_ss_rr_add,
906 .sctp_ss_is_empty = sctp_ss_default_is_empty,
907 .sctp_ss_remove_from_stream = sctp_ss_default_remove,
908 .sctp_ss_select_stream = sctp_ss_rrp_select,
909 .sctp_ss_scheduled = sctp_ss_default_scheduled,
910 .sctp_ss_packet_done = sctp_ss_rrp_packet_done,
911 .sctp_ss_get_value = sctp_ss_default_get_value,
912 .sctp_ss_set_value = sctp_ss_default_set_value
913 #endif
914 },
915 /* SCTP_SS_PRIORITY */
916 {
917 #if defined(__Windows__) || defined(__Userspace_os_Windows)
918 sctp_ss_default_init,
919 sctp_ss_prio_clear,
920 sctp_ss_prio_init_stream,
921 sctp_ss_prio_add,
922 sctp_ss_default_is_empty,
923 sctp_ss_prio_remove,
924 sctp_ss_prio_select,
925 sctp_ss_default_scheduled,
926 sctp_ss_default_packet_done,
927 sctp_ss_prio_get_value,
928 sctp_ss_prio_set_value
929 #else
930 .sctp_ss_init = sctp_ss_default_init,
931 .sctp_ss_clear = sctp_ss_prio_clear,
932 .sctp_ss_init_stream = sctp_ss_prio_init_stream,
933 .sctp_ss_add_to_stream = sctp_ss_prio_add,
934 .sctp_ss_is_empty = sctp_ss_default_is_empty,
935 .sctp_ss_remove_from_stream = sctp_ss_prio_remove,
936 .sctp_ss_select_stream = sctp_ss_prio_select,
937 .sctp_ss_scheduled = sctp_ss_default_scheduled,
938 .sctp_ss_packet_done = sctp_ss_default_packet_done,
939 .sctp_ss_get_value = sctp_ss_prio_get_value,
940 .sctp_ss_set_value = sctp_ss_prio_set_value
941 #endif
942 },
943 /* SCTP_SS_FAIR_BANDWITH */
944 {
945 #if defined(__Windows__) || defined(__Userspace_os_Windows)
946 sctp_ss_default_init,
947 sctp_ss_fb_clear,
948 sctp_ss_fb_init_stream,
949 sctp_ss_fb_add,
950 sctp_ss_default_is_empty,
951 sctp_ss_fb_remove,
952 sctp_ss_fb_select,
953 sctp_ss_fb_scheduled,
954 sctp_ss_default_packet_done,
955 sctp_ss_default_get_value,
956 sctp_ss_default_set_value
957 #else
958 .sctp_ss_init = sctp_ss_default_init,
959 .sctp_ss_clear = sctp_ss_fb_clear,
960 .sctp_ss_init_stream = sctp_ss_fb_init_stream,
961 .sctp_ss_add_to_stream = sctp_ss_fb_add,
962 .sctp_ss_is_empty = sctp_ss_default_is_empty,
963 .sctp_ss_remove_from_stream = sctp_ss_fb_remove,
964 .sctp_ss_select_stream = sctp_ss_fb_select,
965 .sctp_ss_scheduled = sctp_ss_fb_scheduled,
966 .sctp_ss_packet_done = sctp_ss_default_packet_done,
967 .sctp_ss_get_value = sctp_ss_default_get_value,
968 .sctp_ss_set_value = sctp_ss_default_set_value
969 #endif
970 },
971 /* SCTP_SS_FIRST_COME */
972 {
973 #if defined(__Windows__) || defined(__Userspace_os_Windows)
974 sctp_ss_fcfs_init,
975 sctp_ss_fcfs_clear,
976 sctp_ss_fcfs_init_stream,
977 sctp_ss_fcfs_add,
978 sctp_ss_fcfs_is_empty,
979 sctp_ss_fcfs_remove,
980 sctp_ss_fcfs_select,
981 sctp_ss_default_scheduled,
982 sctp_ss_default_packet_done,
983 sctp_ss_default_get_value,
984 sctp_ss_default_set_value
985 #else
986 .sctp_ss_init = sctp_ss_fcfs_init,
987 .sctp_ss_clear = sctp_ss_fcfs_clear,
988 .sctp_ss_init_stream = sctp_ss_fcfs_init_stream,
989 .sctp_ss_add_to_stream = sctp_ss_fcfs_add,
990 .sctp_ss_is_empty = sctp_ss_fcfs_is_empty,
991 .sctp_ss_remove_from_stream = sctp_ss_fcfs_remove,
992 .sctp_ss_select_stream = sctp_ss_fcfs_select,
993 .sctp_ss_scheduled = sctp_ss_default_scheduled,
994 .sctp_ss_packet_done = sctp_ss_default_packet_done,
995 .sctp_ss_get_value = sctp_ss_default_get_value,
996 .sctp_ss_set_value = sctp_ss_default_set_value
997 #endif
998 }
999 };

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial