2019-05-23 17:14:41 +08:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
sctp: introduce stream scheduler foundations
This patch introduces the hooks necessary to do stream scheduling, as
per RFC Draft ndata. It also introduces the first scheduler, which is
what we do today but now factored out: first come first served (FCFS).
With stream scheduling now we have to track which chunk was enqueued on
which stream and be able to select another other than the in front of
the main outqueue. So we introduce a list on sctp_stream_out_ext
structure for this purpose.
We reuse sctp_chunk->transmitted_list space for the list above, as the
chunk cannot belong to the two lists at the same time. By using the
union in there, we can have distinct names for these moments.
sctp_sched_ops are the operations expected to be implemented by each
scheduler. The dequeueing is a bit particular to this implementation but
it is to match how we dequeue packets today. We first dequeue and then
check if it fits the packet and if not, we requeue it at head. Thus why
we don't have a peek operation but have dequeue_done instead, which is
called once the chunk can be safely considered as transmitted.
The check removed from sctp_outq_flush is now performed by
sctp_stream_outq_migrate, which is only called during assoc setup.
(sctp_sendmsg() also checks for it)
The only operation that is foreseen but not yet added here is a way to
signalize that a new packet is starting or that the packet is done, for
round robin scheduler per packet, but is intentionally left to the
patch that actually implements it.
Support for I-DATA chunks, also described in this RFC, with user message
interleaving is straightforward as it just requires the schedulers to
probe for the feature and ignore datamsg boundaries when dequeueing.
See-also: https://tools.ietf.org/html/draft-ietf-tsvwg-sctp-ndata-13
Tested-by: Xin Long <lucien.xin@gmail.com>
Signed-off-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-10-04 06:20:13 +08:00
|
|
|
/* SCTP kernel implementation
|
|
|
|
|
* (C) Copyright Red Hat Inc. 2017
|
|
|
|
|
*
|
|
|
|
|
* These are definitions used by the stream schedulers, defined in RFC
|
|
|
|
|
* draft ndata (https://tools.ietf.org/html/draft-ietf-tsvwg-sctp-ndata-11)
|
|
|
|
|
*
|
|
|
|
|
* Please send any bug reports or fixes you make to the
|
|
|
|
|
* email addresses:
|
|
|
|
|
* lksctp developers <linux-sctp@vger.kernel.org>
|
|
|
|
|
*
|
|
|
|
|
* Written or modified by:
|
|
|
|
|
* Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef __sctp_stream_sched_h__
|
|
|
|
|
#define __sctp_stream_sched_h__
|
|
|
|
|
|
|
|
|
|
struct sctp_sched_ops {
|
|
|
|
|
/* Property handling for a given stream */
|
|
|
|
|
int (*set)(struct sctp_stream *stream, __u16 sid, __u16 value,
|
|
|
|
|
gfp_t gfp);
|
|
|
|
|
int (*get)(struct sctp_stream *stream, __u16 sid, __u16 *value);
|
|
|
|
|
|
|
|
|
|
/* Init the specific scheduler */
|
|
|
|
|
int (*init)(struct sctp_stream *stream);
|
|
|
|
|
/* Init a stream */
|
|
|
|
|
int (*init_sid)(struct sctp_stream *stream, __u16 sid, gfp_t gfp);
|
2022-11-26 11:17:20 +08:00
|
|
|
/* free a stream */
|
|
|
|
|
void (*free_sid)(struct sctp_stream *stream, __u16 sid);
|
sctp: introduce stream scheduler foundations
This patch introduces the hooks necessary to do stream scheduling, as
per RFC Draft ndata. It also introduces the first scheduler, which is
what we do today but now factored out: first come first served (FCFS).
With stream scheduling now we have to track which chunk was enqueued on
which stream and be able to select another other than the in front of
the main outqueue. So we introduce a list on sctp_stream_out_ext
structure for this purpose.
We reuse sctp_chunk->transmitted_list space for the list above, as the
chunk cannot belong to the two lists at the same time. By using the
union in there, we can have distinct names for these moments.
sctp_sched_ops are the operations expected to be implemented by each
scheduler. The dequeueing is a bit particular to this implementation but
it is to match how we dequeue packets today. We first dequeue and then
check if it fits the packet and if not, we requeue it at head. Thus why
we don't have a peek operation but have dequeue_done instead, which is
called once the chunk can be safely considered as transmitted.
The check removed from sctp_outq_flush is now performed by
sctp_stream_outq_migrate, which is only called during assoc setup.
(sctp_sendmsg() also checks for it)
The only operation that is foreseen but not yet added here is a way to
signalize that a new packet is starting or that the packet is done, for
round robin scheduler per packet, but is intentionally left to the
patch that actually implements it.
Support for I-DATA chunks, also described in this RFC, with user message
interleaving is straightforward as it just requires the schedulers to
probe for the feature and ignore datamsg boundaries when dequeueing.
See-also: https://tools.ietf.org/html/draft-ietf-tsvwg-sctp-ndata-13
Tested-by: Xin Long <lucien.xin@gmail.com>
Signed-off-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-10-04 06:20:13 +08:00
|
|
|
|
|
|
|
|
/* Enqueue a chunk */
|
|
|
|
|
void (*enqueue)(struct sctp_outq *q, struct sctp_datamsg *msg);
|
|
|
|
|
/* Dequeue a chunk */
|
|
|
|
|
struct sctp_chunk *(*dequeue)(struct sctp_outq *q);
|
|
|
|
|
/* Called only if the chunk fit the packet */
|
|
|
|
|
void (*dequeue_done)(struct sctp_outq *q, struct sctp_chunk *chunk);
|
2024-07-05 04:25:59 +08:00
|
|
|
/* Schedule all chunks already enqueued */
|
|
|
|
|
void (*sched_all)(struct sctp_stream *stream);
|
|
|
|
|
/* Unschedule all chunks already enqueued */
|
|
|
|
|
void (*unsched_all)(struct sctp_stream *stream);
|
sctp: introduce stream scheduler foundations
This patch introduces the hooks necessary to do stream scheduling, as
per RFC Draft ndata. It also introduces the first scheduler, which is
what we do today but now factored out: first come first served (FCFS).
With stream scheduling now we have to track which chunk was enqueued on
which stream and be able to select another other than the in front of
the main outqueue. So we introduce a list on sctp_stream_out_ext
structure for this purpose.
We reuse sctp_chunk->transmitted_list space for the list above, as the
chunk cannot belong to the two lists at the same time. By using the
union in there, we can have distinct names for these moments.
sctp_sched_ops are the operations expected to be implemented by each
scheduler. The dequeueing is a bit particular to this implementation but
it is to match how we dequeue packets today. We first dequeue and then
check if it fits the packet and if not, we requeue it at head. Thus why
we don't have a peek operation but have dequeue_done instead, which is
called once the chunk can be safely considered as transmitted.
The check removed from sctp_outq_flush is now performed by
sctp_stream_outq_migrate, which is only called during assoc setup.
(sctp_sendmsg() also checks for it)
The only operation that is foreseen but not yet added here is a way to
signalize that a new packet is starting or that the packet is done, for
round robin scheduler per packet, but is intentionally left to the
patch that actually implements it.
Support for I-DATA chunks, also described in this RFC, with user message
interleaving is straightforward as it just requires the schedulers to
probe for the feature and ignore datamsg boundaries when dequeueing.
See-also: https://tools.ietf.org/html/draft-ietf-tsvwg-sctp-ndata-13
Tested-by: Xin Long <lucien.xin@gmail.com>
Signed-off-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-10-04 06:20:13 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
int sctp_sched_set_sched(struct sctp_association *asoc,
|
|
|
|
|
enum sctp_sched_type sched);
|
|
|
|
|
int sctp_sched_get_sched(struct sctp_association *asoc);
|
|
|
|
|
int sctp_sched_set_value(struct sctp_association *asoc, __u16 sid,
|
|
|
|
|
__u16 value, gfp_t gfp);
|
|
|
|
|
int sctp_sched_get_value(struct sctp_association *asoc, __u16 sid,
|
|
|
|
|
__u16 *value);
|
|
|
|
|
void sctp_sched_dequeue_done(struct sctp_outq *q, struct sctp_chunk *ch);
|
|
|
|
|
|
|
|
|
|
void sctp_sched_dequeue_common(struct sctp_outq *q, struct sctp_chunk *ch);
|
|
|
|
|
int sctp_sched_init_sid(struct sctp_stream *stream, __u16 sid, gfp_t gfp);
|
|
|
|
|
struct sctp_sched_ops *sctp_sched_ops_from_stream(struct sctp_stream *stream);
|
|
|
|
|
|
2017-11-26 20:16:08 +08:00
|
|
|
void sctp_sched_ops_register(enum sctp_sched_type sched,
|
|
|
|
|
struct sctp_sched_ops *sched_ops);
|
|
|
|
|
void sctp_sched_ops_prio_init(void);
|
|
|
|
|
void sctp_sched_ops_rr_init(void);
|
2023-03-08 05:23:26 +08:00
|
|
|
void sctp_sched_ops_fc_init(void);
|
2023-03-08 05:23:27 +08:00
|
|
|
void sctp_sched_ops_wfq_init(void);
|
2017-11-26 20:16:08 +08:00
|
|
|
|
sctp: introduce stream scheduler foundations
This patch introduces the hooks necessary to do stream scheduling, as
per RFC Draft ndata. It also introduces the first scheduler, which is
what we do today but now factored out: first come first served (FCFS).
With stream scheduling now we have to track which chunk was enqueued on
which stream and be able to select another other than the in front of
the main outqueue. So we introduce a list on sctp_stream_out_ext
structure for this purpose.
We reuse sctp_chunk->transmitted_list space for the list above, as the
chunk cannot belong to the two lists at the same time. By using the
union in there, we can have distinct names for these moments.
sctp_sched_ops are the operations expected to be implemented by each
scheduler. The dequeueing is a bit particular to this implementation but
it is to match how we dequeue packets today. We first dequeue and then
check if it fits the packet and if not, we requeue it at head. Thus why
we don't have a peek operation but have dequeue_done instead, which is
called once the chunk can be safely considered as transmitted.
The check removed from sctp_outq_flush is now performed by
sctp_stream_outq_migrate, which is only called during assoc setup.
(sctp_sendmsg() also checks for it)
The only operation that is foreseen but not yet added here is a way to
signalize that a new packet is starting or that the packet is done, for
round robin scheduler per packet, but is intentionally left to the
patch that actually implements it.
Support for I-DATA chunks, also described in this RFC, with user message
interleaving is straightforward as it just requires the schedulers to
probe for the feature and ignore datamsg boundaries when dequeueing.
See-also: https://tools.ietf.org/html/draft-ietf-tsvwg-sctp-ndata-13
Tested-by: Xin Long <lucien.xin@gmail.com>
Signed-off-by: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-10-04 06:20:13 +08:00
|
|
|
#endif /* __sctp_stream_sched_h__ */
|
