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