strparser: Generalize strparser
Generalize strparser from more than just being used in conjunction with read_sock. strparser will also be used in the send path with zero proxy. The primary change is to create strp_process function that performs the critical processing on skbs. The documentation is also updated to reflect the new uses. Signed-off-by: Tom Herbert <tom@quantonium.net> Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Tom Herbert
committed by
David S. Miller
David S. Miller
parent
20bf50de30
commit
bbb03029a8
@@ -1,45 +1,107 @@
|
||||
Stream Parser
|
||||
-------------
|
||||
Stream Parser (strparser)
|
||||
|
||||
Introduction
|
||||
============
|
||||
|
||||
The stream parser (strparser) is a utility that parses messages of an
|
||||
application layer protocol running over a TCP connection. The stream
|
||||
application layer protocol running over a data stream. The stream
|
||||
parser works in conjunction with an upper layer in the kernel to provide
|
||||
kernel support for application layer messages. For instance, Kernel
|
||||
Connection Multiplexor (KCM) uses the Stream Parser to parse messages
|
||||
using a BPF program.
|
||||
|
||||
The strparser works in one of two modes: receive callback or general
|
||||
mode.
|
||||
|
||||
In receive callback mode, the strparser is called from the data_ready
|
||||
callback of a TCP socket. Messages are parsed and delivered as they are
|
||||
received on the socket.
|
||||
|
||||
In general mode, a sequence of skbs are fed to strparser from an
|
||||
outside source. Message are parsed and delivered as the sequence is
|
||||
processed. This modes allows strparser to be applied to arbitrary
|
||||
streams of data.
|
||||
|
||||
Interface
|
||||
---------
|
||||
=========
|
||||
|
||||
The API includes a context structure, a set of callbacks, utility
|
||||
functions, and a data_ready function. The callbacks include
|
||||
a parse_msg function that is called to perform parsing (e.g.
|
||||
BPF parsing in case of KCM), and a rcv_msg function that is called
|
||||
when a full message has been completed.
|
||||
functions, and a data_ready function for receive callback mode. The
|
||||
callbacks include a parse_msg function that is called to perform
|
||||
parsing (e.g. BPF parsing in case of KCM), and a rcv_msg function
|
||||
that is called when a full message has been completed.
|
||||
|
||||
A stream parser can be instantiated for a TCP connection. This is done
|
||||
by:
|
||||
Functions
|
||||
=========
|
||||
|
||||
strp_init(struct strparser *strp, struct sock *csk,
|
||||
strp_init(struct strparser *strp, struct sock *sk,
|
||||
struct strp_callbacks *cb)
|
||||
|
||||
strp is a struct of type strparser that is allocated by the upper layer.
|
||||
csk is the TCP socket associated with the stream parser. Callbacks are
|
||||
called by the stream parser.
|
||||
Called to initialize a stream parser. strp is a struct of type
|
||||
strparser that is allocated by the upper layer. sk is the TCP
|
||||
socket associated with the stream parser for use with receive
|
||||
callback mode; in general mode this is set to NULL. Callbacks
|
||||
are called by the stream parser (the callbacks are listed below).
|
||||
|
||||
void strp_pause(struct strparser *strp)
|
||||
|
||||
Temporarily pause a stream parser. Message parsing is suspended
|
||||
and no new messages are delivered to the upper layer.
|
||||
|
||||
void strp_pause(struct strparser *strp)
|
||||
|
||||
Unpause a paused stream parser.
|
||||
|
||||
void strp_stop(struct strparser *strp);
|
||||
|
||||
strp_stop is called to completely stop stream parser operations.
|
||||
This is called internally when the stream parser encounters an
|
||||
error, and it is called from the upper layer to stop parsing
|
||||
operations.
|
||||
|
||||
void strp_done(struct strparser *strp);
|
||||
|
||||
strp_done is called to release any resources held by the stream
|
||||
parser instance. This must be called after the stream processor
|
||||
has been stopped.
|
||||
|
||||
int strp_process(struct strparser *strp, struct sk_buff *orig_skb,
|
||||
unsigned int orig_offset, size_t orig_len,
|
||||
size_t max_msg_size, long timeo)
|
||||
|
||||
strp_process is called in general mode for a stream parser to
|
||||
parse an sk_buff. The number of bytes processed or a negative
|
||||
error number is returned. Note that strp_process does not
|
||||
consume the sk_buff. max_msg_size is maximum size the stream
|
||||
parser will parse. timeo is timeout for completing a message.
|
||||
|
||||
void strp_data_ready(struct strparser *strp);
|
||||
|
||||
The upper layer calls strp_tcp_data_ready when data is ready on
|
||||
the lower socket for strparser to process. This should be called
|
||||
from a data_ready callback that is set on the socket. Note that
|
||||
maximum messages size is the limit of the receive socket
|
||||
buffer and message timeout is the receive timeout for the socket.
|
||||
|
||||
void strp_check_rcv(struct strparser *strp);
|
||||
|
||||
strp_check_rcv is called to check for new messages on the socket.
|
||||
This is normally called at initialization of a stream parser
|
||||
instance or after strp_unpause.
|
||||
|
||||
Callbacks
|
||||
---------
|
||||
=========
|
||||
|
||||
There are four callbacks:
|
||||
There are six callbacks:
|
||||
|
||||
int (*parse_msg)(struct strparser *strp, struct sk_buff *skb);
|
||||
|
||||
parse_msg is called to determine the length of the next message
|
||||
in the stream. The upper layer must implement this function. It
|
||||
should parse the sk_buff as containing the headers for the
|
||||
next application layer messages in the stream.
|
||||
next application layer message in the stream.
|
||||
|
||||
The skb->cb in the input skb is a struct strp_rx_msg. Only
|
||||
The skb->cb in the input skb is a struct strp_msg. Only
|
||||
the offset field is relevant in parse_msg and gives the offset
|
||||
where the message starts in the skb.
|
||||
|
||||
@@ -50,26 +112,41 @@ int (*parse_msg)(struct strparser *strp, struct sk_buff *skb);
|
||||
-ESTRPIPE : current message should not be processed by the
|
||||
kernel, return control of the socket to userspace which
|
||||
can proceed to read the messages itself
|
||||
other < 0 : Error is parsing, give control back to userspace
|
||||
other < 0 : Error in parsing, give control back to userspace
|
||||
assuming that synchronization is lost and the stream
|
||||
is unrecoverable (application expected to close TCP socket)
|
||||
|
||||
In the case that an error is returned (return value is less than
|
||||
zero) the stream parser will set the error on TCP socket and wake
|
||||
it up. If parse_msg returned -ESTRPIPE and the stream parser had
|
||||
previously read some bytes for the current message, then the error
|
||||
set on the attached socket is ENODATA since the stream is
|
||||
unrecoverable in that case.
|
||||
zero) and the parser is in receive callback mode, then it will set
|
||||
the error on TCP socket and wake it up. If parse_msg returned
|
||||
-ESTRPIPE and the stream parser had previously read some bytes for
|
||||
the current message, then the error set on the attached socket is
|
||||
ENODATA since the stream is unrecoverable in that case.
|
||||
|
||||
void (*lock)(struct strparser *strp)
|
||||
|
||||
The lock callback is called to lock the strp structure when
|
||||
the strparser is performing an asynchronous operation (such as
|
||||
processing a timeout). In receive callback mode the default
|
||||
function is to lock_sock for the associated socket. In general
|
||||
mode the callback must be set appropriately.
|
||||
|
||||
void (*unlock)(struct strparser *strp)
|
||||
|
||||
The unlock callback is called to release the lock obtained
|
||||
by the lock callback. In receive callback mode the default
|
||||
function is release_sock for the associated socket. In general
|
||||
mode the callback must be set appropriately.
|
||||
|
||||
void (*rcv_msg)(struct strparser *strp, struct sk_buff *skb);
|
||||
|
||||
rcv_msg is called when a full message has been received and
|
||||
is queued. The callee must consume the sk_buff; it can
|
||||
call strp_pause to prevent any further messages from being
|
||||
received in rcv_msg (see strp_pause below). This callback
|
||||
received in rcv_msg (see strp_pause above). This callback
|
||||
must be set.
|
||||
|
||||
The skb->cb in the input skb is a struct strp_rx_msg. This
|
||||
The skb->cb in the input skb is a struct strp_msg. This
|
||||
struct contains two fields: offset and full_len. Offset is
|
||||
where the message starts in the skb, and full_len is the
|
||||
the length of the message. skb->len - offset may be greater
|
||||
@@ -78,59 +155,53 @@ void (*rcv_msg)(struct strparser *strp, struct sk_buff *skb);
|
||||
int (*read_sock_done)(struct strparser *strp, int err);
|
||||
|
||||
read_sock_done is called when the stream parser is done reading
|
||||
the TCP socket. The stream parser may read multiple messages
|
||||
in a loop and this function allows cleanup to occur when existing
|
||||
the loop. If the callback is not set (NULL in strp_init) a
|
||||
default function is used.
|
||||
the TCP socket in receive callback mode. The stream parser may
|
||||
read multiple messages in a loop and this function allows cleanup
|
||||
to occur when exiting the loop. If the callback is not set (NULL
|
||||
in strp_init) a default function is used.
|
||||
|
||||
void (*abort_parser)(struct strparser *strp, int err);
|
||||
|
||||
This function is called when stream parser encounters an error
|
||||
in parsing. The default function stops the stream parser for the
|
||||
TCP socket and sets the error in the socket. The default function
|
||||
can be changed by setting the callback to non-NULL in strp_init.
|
||||
|
||||
Functions
|
||||
---------
|
||||
|
||||
The upper layer calls strp_tcp_data_ready when data is ready on the lower
|
||||
socket for strparser to process. This should be called from a data_ready
|
||||
callback that is set on the socket.
|
||||
|
||||
strp_stop is called to completely stop stream parser operations. This
|
||||
is called internally when the stream parser encounters an error, and
|
||||
it is called from the upper layer when unattaching a TCP socket.
|
||||
|
||||
strp_done is called to unattach the stream parser from the TCP socket.
|
||||
This must be called after the stream processor has be stopped.
|
||||
|
||||
strp_check_rcv is called to check for new messages on the socket. This
|
||||
is normally called at initialization of the a stream parser instance
|
||||
of after strp_unpause.
|
||||
in parsing. The default function stops the stream parser and
|
||||
sets the error in the socket if the parser is in receive callback
|
||||
mode. The default function can be changed by setting the callback
|
||||
to non-NULL in strp_init.
|
||||
|
||||
Statistics
|
||||
----------
|
||||
==========
|
||||
|
||||
Various counters are kept for each stream parser for a TCP socket.
|
||||
These are in the strp_stats structure. strp_aggr_stats is a convenience
|
||||
structure for accumulating statistics for multiple stream parser
|
||||
instances. save_strp_stats and aggregate_strp_stats are helper functions
|
||||
to save and aggregate statistics.
|
||||
Various counters are kept for each stream parser instance. These are in
|
||||
the strp_stats structure. strp_aggr_stats is a convenience structure for
|
||||
accumulating statistics for multiple stream parser instances.
|
||||
save_strp_stats and aggregate_strp_stats are helper functions to save
|
||||
and aggregate statistics.
|
||||
|
||||
Message assembly limits
|
||||
-----------------------
|
||||
=======================
|
||||
|
||||
The stream parser provide mechanisms to limit the resources consumed by
|
||||
message assembly.
|
||||
|
||||
A timer is set when assembly starts for a new message. The message
|
||||
timeout is taken from rcvtime for the associated TCP socket. If the
|
||||
timer fires before assembly completes the stream parser is aborted
|
||||
and the ETIMEDOUT error is set on the TCP socket.
|
||||
A timer is set when assembly starts for a new message. In receive
|
||||
callback mode the message timeout is taken from rcvtime for the
|
||||
associated TCP socket. In general mode, the timeout is passed as an
|
||||
argument in strp_process. If the timer fires before assembly completes
|
||||
the stream parser is aborted and the ETIMEDOUT error is set on the TCP
|
||||
socket if in receive callback mode.
|
||||
|
||||
In receive callback mode, message length is limited to the receive
|
||||
buffer size of the associated TCP socket. If the length returned by
|
||||
parse_msg is greater than the socket buffer size then the stream parser
|
||||
is aborted with EMSGSIZE error set on the TCP socket. Note that this
|
||||
makes the maximum size of receive skbuffs for a socket with a stream
|
||||
parser to be 2*sk_rcvbuf of the TCP socket.
|
||||
|
||||
In general mode the message length limit is passed in as an argument
|
||||
to strp_process.
|
||||
|
||||
Author
|
||||
======
|
||||
|
||||
Tom Herbert (tom@quantonium.net)
|
||||
|
||||
Message length is limited to the receive buffer size of the associated
|
||||
TCP socket. If the length returned by parse_msg is greater than
|
||||
the socket buffer size then the stream parser is aborted with
|
||||
EMSGSIZE error set on the TCP socket. Note that this makes the
|
||||
maximum size of receive skbuffs for a socket with a stream parser
|
||||
to be 2*sk_rcvbuf of the TCP socket.
|
||||
|
||||
Reference in New Issue
Block a user