mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
337 lines
8.4 KiB
337 lines
8.4 KiB
// SPDX-License-Identifier: GPL-2.0-or-later |
|
/* SCTP kernel implementation |
|
* (C) Copyright Red Hat Inc. 2017 |
|
* |
|
* This file is part of the SCTP kernel implementation |
|
* |
|
* These functions manipulate sctp stream queue/scheduling. |
|
* |
|
* Please send any bug reports or fixes you make to the |
|
* email addresched(es): |
|
* lksctp developers <[email protected]> |
|
* |
|
* Written or modified by: |
|
* Marcelo Ricardo Leitner <[email protected]> |
|
*/ |
|
|
|
#include <linux/list.h> |
|
#include <net/sctp/sctp.h> |
|
#include <net/sctp/sm.h> |
|
#include <net/sctp/stream_sched.h> |
|
|
|
/* Priority handling |
|
* RFC DRAFT ndata section 3.4 |
|
*/ |
|
|
|
static void sctp_sched_prio_unsched_all(struct sctp_stream *stream); |
|
|
|
static struct sctp_stream_priorities *sctp_sched_prio_new_head( |
|
struct sctp_stream *stream, int prio, gfp_t gfp) |
|
{ |
|
struct sctp_stream_priorities *p; |
|
|
|
p = kmalloc(sizeof(*p), gfp); |
|
if (!p) |
|
return NULL; |
|
|
|
INIT_LIST_HEAD(&p->prio_sched); |
|
INIT_LIST_HEAD(&p->active); |
|
p->next = NULL; |
|
p->prio = prio; |
|
|
|
return p; |
|
} |
|
|
|
static struct sctp_stream_priorities *sctp_sched_prio_get_head( |
|
struct sctp_stream *stream, int prio, gfp_t gfp) |
|
{ |
|
struct sctp_stream_priorities *p; |
|
int i; |
|
|
|
/* Look into scheduled priorities first, as they are sorted and |
|
* we can find it fast IF it's scheduled. |
|
*/ |
|
list_for_each_entry(p, &stream->prio_list, prio_sched) { |
|
if (p->prio == prio) |
|
return p; |
|
if (p->prio > prio) |
|
break; |
|
} |
|
|
|
/* No luck. So we search on all streams now. */ |
|
for (i = 0; i < stream->outcnt; i++) { |
|
if (!SCTP_SO(stream, i)->ext) |
|
continue; |
|
|
|
p = SCTP_SO(stream, i)->ext->prio_head; |
|
if (!p) |
|
/* Means all other streams won't be initialized |
|
* as well. |
|
*/ |
|
break; |
|
if (p->prio == prio) |
|
return p; |
|
} |
|
|
|
/* If not even there, allocate a new one. */ |
|
return sctp_sched_prio_new_head(stream, prio, gfp); |
|
} |
|
|
|
static void sctp_sched_prio_next_stream(struct sctp_stream_priorities *p) |
|
{ |
|
struct list_head *pos; |
|
|
|
pos = p->next->prio_list.next; |
|
if (pos == &p->active) |
|
pos = pos->next; |
|
p->next = list_entry(pos, struct sctp_stream_out_ext, prio_list); |
|
} |
|
|
|
static bool sctp_sched_prio_unsched(struct sctp_stream_out_ext *soute) |
|
{ |
|
bool scheduled = false; |
|
|
|
if (!list_empty(&soute->prio_list)) { |
|
struct sctp_stream_priorities *prio_head = soute->prio_head; |
|
|
|
/* Scheduled */ |
|
scheduled = true; |
|
|
|
if (prio_head->next == soute) |
|
/* Try to move to the next stream */ |
|
sctp_sched_prio_next_stream(prio_head); |
|
|
|
list_del_init(&soute->prio_list); |
|
|
|
/* Also unsched the priority if this was the last stream */ |
|
if (list_empty(&prio_head->active)) { |
|
list_del_init(&prio_head->prio_sched); |
|
/* If there is no stream left, clear next */ |
|
prio_head->next = NULL; |
|
} |
|
} |
|
|
|
return scheduled; |
|
} |
|
|
|
static void sctp_sched_prio_sched(struct sctp_stream *stream, |
|
struct sctp_stream_out_ext *soute) |
|
{ |
|
struct sctp_stream_priorities *prio, *prio_head; |
|
|
|
prio_head = soute->prio_head; |
|
|
|
/* Nothing to do if already scheduled */ |
|
if (!list_empty(&soute->prio_list)) |
|
return; |
|
|
|
/* Schedule the stream. If there is a next, we schedule the new |
|
* one before it, so it's the last in round robin order. |
|
* If there isn't, we also have to schedule the priority. |
|
*/ |
|
if (prio_head->next) { |
|
list_add(&soute->prio_list, prio_head->next->prio_list.prev); |
|
return; |
|
} |
|
|
|
list_add(&soute->prio_list, &prio_head->active); |
|
prio_head->next = soute; |
|
|
|
list_for_each_entry(prio, &stream->prio_list, prio_sched) { |
|
if (prio->prio > prio_head->prio) { |
|
list_add(&prio_head->prio_sched, prio->prio_sched.prev); |
|
return; |
|
} |
|
} |
|
|
|
list_add_tail(&prio_head->prio_sched, &stream->prio_list); |
|
} |
|
|
|
static int sctp_sched_prio_set(struct sctp_stream *stream, __u16 sid, |
|
__u16 prio, gfp_t gfp) |
|
{ |
|
struct sctp_stream_out *sout = SCTP_SO(stream, sid); |
|
struct sctp_stream_out_ext *soute = sout->ext; |
|
struct sctp_stream_priorities *prio_head, *old; |
|
bool reschedule = false; |
|
int i; |
|
|
|
prio_head = sctp_sched_prio_get_head(stream, prio, gfp); |
|
if (!prio_head) |
|
return -ENOMEM; |
|
|
|
reschedule = sctp_sched_prio_unsched(soute); |
|
old = soute->prio_head; |
|
soute->prio_head = prio_head; |
|
if (reschedule) |
|
sctp_sched_prio_sched(stream, soute); |
|
|
|
if (!old) |
|
/* Happens when we set the priority for the first time */ |
|
return 0; |
|
|
|
for (i = 0; i < stream->outcnt; i++) { |
|
soute = SCTP_SO(stream, i)->ext; |
|
if (soute && soute->prio_head == old) |
|
/* It's still in use, nothing else to do here. */ |
|
return 0; |
|
} |
|
|
|
/* No hits, we are good to free it. */ |
|
kfree(old); |
|
|
|
return 0; |
|
} |
|
|
|
static int sctp_sched_prio_get(struct sctp_stream *stream, __u16 sid, |
|
__u16 *value) |
|
{ |
|
*value = SCTP_SO(stream, sid)->ext->prio_head->prio; |
|
return 0; |
|
} |
|
|
|
static int sctp_sched_prio_init(struct sctp_stream *stream) |
|
{ |
|
INIT_LIST_HEAD(&stream->prio_list); |
|
|
|
return 0; |
|
} |
|
|
|
static int sctp_sched_prio_init_sid(struct sctp_stream *stream, __u16 sid, |
|
gfp_t gfp) |
|
{ |
|
INIT_LIST_HEAD(&SCTP_SO(stream, sid)->ext->prio_list); |
|
return sctp_sched_prio_set(stream, sid, 0, gfp); |
|
} |
|
|
|
static void sctp_sched_prio_free(struct sctp_stream *stream) |
|
{ |
|
struct sctp_stream_priorities *prio, *n; |
|
LIST_HEAD(list); |
|
int i; |
|
|
|
/* As we don't keep a list of priorities, to avoid multiple |
|
* frees we have to do it in 3 steps: |
|
* 1. unsched everyone, so the lists are free to use in 2. |
|
* 2. build the list of the priorities |
|
* 3. free the list |
|
*/ |
|
sctp_sched_prio_unsched_all(stream); |
|
for (i = 0; i < stream->outcnt; i++) { |
|
if (!SCTP_SO(stream, i)->ext) |
|
continue; |
|
prio = SCTP_SO(stream, i)->ext->prio_head; |
|
if (prio && list_empty(&prio->prio_sched)) |
|
list_add(&prio->prio_sched, &list); |
|
} |
|
list_for_each_entry_safe(prio, n, &list, prio_sched) { |
|
list_del_init(&prio->prio_sched); |
|
kfree(prio); |
|
} |
|
} |
|
|
|
static void sctp_sched_prio_enqueue(struct sctp_outq *q, |
|
struct sctp_datamsg *msg) |
|
{ |
|
struct sctp_stream *stream; |
|
struct sctp_chunk *ch; |
|
__u16 sid; |
|
|
|
ch = list_first_entry(&msg->chunks, struct sctp_chunk, frag_list); |
|
sid = sctp_chunk_stream_no(ch); |
|
stream = &q->asoc->stream; |
|
sctp_sched_prio_sched(stream, SCTP_SO(stream, sid)->ext); |
|
} |
|
|
|
static struct sctp_chunk *sctp_sched_prio_dequeue(struct sctp_outq *q) |
|
{ |
|
struct sctp_stream *stream = &q->asoc->stream; |
|
struct sctp_stream_priorities *prio; |
|
struct sctp_stream_out_ext *soute; |
|
struct sctp_chunk *ch = NULL; |
|
|
|
/* Bail out quickly if queue is empty */ |
|
if (list_empty(&q->out_chunk_list)) |
|
goto out; |
|
|
|
/* Find which chunk is next. It's easy, it's either the current |
|
* one or the first chunk on the next active stream. |
|
*/ |
|
if (stream->out_curr) { |
|
soute = stream->out_curr->ext; |
|
} else { |
|
prio = list_entry(stream->prio_list.next, |
|
struct sctp_stream_priorities, prio_sched); |
|
soute = prio->next; |
|
} |
|
ch = list_entry(soute->outq.next, struct sctp_chunk, stream_list); |
|
sctp_sched_dequeue_common(q, ch); |
|
|
|
out: |
|
return ch; |
|
} |
|
|
|
static void sctp_sched_prio_dequeue_done(struct sctp_outq *q, |
|
struct sctp_chunk *ch) |
|
{ |
|
struct sctp_stream_priorities *prio; |
|
struct sctp_stream_out_ext *soute; |
|
__u16 sid; |
|
|
|
/* Last chunk on that msg, move to the next stream on |
|
* this priority. |
|
*/ |
|
sid = sctp_chunk_stream_no(ch); |
|
soute = SCTP_SO(&q->asoc->stream, sid)->ext; |
|
prio = soute->prio_head; |
|
|
|
sctp_sched_prio_next_stream(prio); |
|
|
|
if (list_empty(&soute->outq)) |
|
sctp_sched_prio_unsched(soute); |
|
} |
|
|
|
static void sctp_sched_prio_sched_all(struct sctp_stream *stream) |
|
{ |
|
struct sctp_association *asoc; |
|
struct sctp_stream_out *sout; |
|
struct sctp_chunk *ch; |
|
|
|
asoc = container_of(stream, struct sctp_association, stream); |
|
list_for_each_entry(ch, &asoc->outqueue.out_chunk_list, list) { |
|
__u16 sid; |
|
|
|
sid = sctp_chunk_stream_no(ch); |
|
sout = SCTP_SO(stream, sid); |
|
if (sout->ext) |
|
sctp_sched_prio_sched(stream, sout->ext); |
|
} |
|
} |
|
|
|
static void sctp_sched_prio_unsched_all(struct sctp_stream *stream) |
|
{ |
|
struct sctp_stream_priorities *p, *tmp; |
|
struct sctp_stream_out_ext *soute, *souttmp; |
|
|
|
list_for_each_entry_safe(p, tmp, &stream->prio_list, prio_sched) |
|
list_for_each_entry_safe(soute, souttmp, &p->active, prio_list) |
|
sctp_sched_prio_unsched(soute); |
|
} |
|
|
|
static struct sctp_sched_ops sctp_sched_prio = { |
|
.set = sctp_sched_prio_set, |
|
.get = sctp_sched_prio_get, |
|
.init = sctp_sched_prio_init, |
|
.init_sid = sctp_sched_prio_init_sid, |
|
.free = sctp_sched_prio_free, |
|
.enqueue = sctp_sched_prio_enqueue, |
|
.dequeue = sctp_sched_prio_dequeue, |
|
.dequeue_done = sctp_sched_prio_dequeue_done, |
|
.sched_all = sctp_sched_prio_sched_all, |
|
.unsched_all = sctp_sched_prio_unsched_all, |
|
}; |
|
|
|
void sctp_sched_ops_prio_init(void) |
|
{ |
|
sctp_sched_ops_register(SCTP_SS_PRIO, &sctp_sched_prio); |
|
}
|
|
|