2017-07-29 01:22:43 +02:00
|
|
|
Stream Parser (strparser)
|
|
|
|
|
|
|
|
Introduction
|
|
|
|
============
|
2016-08-15 23:51:03 +02:00
|
|
|
|
|
|
|
The stream parser (strparser) is a utility that parses messages of an
|
2017-07-29 01:22:43 +02:00
|
|
|
application layer protocol running over a data stream. The stream
|
2016-08-15 23:51:03 +02:00
|
|
|
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.
|
|
|
|
|
2017-07-29 01:22:43 +02:00
|
|
|
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.
|
|
|
|
|
2016-08-15 23:51:03 +02:00
|
|
|
Interface
|
2017-07-29 01:22:43 +02:00
|
|
|
=========
|
2016-08-15 23:51:03 +02:00
|
|
|
|
|
|
|
The API includes a context structure, a set of callbacks, utility
|
2017-07-29 01:22:43 +02:00
|
|
|
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.
|
2016-08-15 23:51:03 +02:00
|
|
|
|
2017-07-29 01:22:43 +02:00
|
|
|
Functions
|
|
|
|
=========
|
2016-08-15 23:51:03 +02:00
|
|
|
|
2017-07-29 01:22:43 +02:00
|
|
|
strp_init(struct strparser *strp, struct sock *sk,
|
strparser: initialize all callbacks
commit bbb03029a899 ("strparser: Generalize strparser") added more
function pointers to 'struct strp_callbacks'; however, kcm_attach() was
not updated to initialize them. This could cause the ->lock() and/or
->unlock() function pointers to be set to garbage values, causing a
crash in strp_work().
Fix the bug by moving the callback structs into static memory, so
unspecified members are zeroed. Also constify them while we're at it.
This bug was found by syzkaller, which encountered the following splat:
IP: 0x55
PGD 3b1ca067
P4D 3b1ca067
PUD 3b12f067
PMD 0
Oops: 0010 [#1] SMP KASAN
Dumping ftrace buffer:
(ftrace buffer empty)
Modules linked in:
CPU: 2 PID: 1194 Comm: kworker/u8:1 Not tainted 4.13.0-rc4-next-20170811 #2
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS Bochs 01/01/2011
Workqueue: kstrp strp_work
task: ffff88006bb0e480 task.stack: ffff88006bb10000
RIP: 0010:0x55
RSP: 0018:ffff88006bb17540 EFLAGS: 00010246
RAX: dffffc0000000000 RBX: ffff88006ce4bd60 RCX: 0000000000000000
RDX: 1ffff1000d9c97bd RSI: 0000000000000000 RDI: ffff88006ce4bc48
RBP: ffff88006bb17558 R08: ffffffff81467ab2 R09: 0000000000000000
R10: ffff88006bb17438 R11: ffff88006bb17940 R12: ffff88006ce4bc48
R13: ffff88003c683018 R14: ffff88006bb17980 R15: ffff88003c683000
FS: 0000000000000000(0000) GS:ffff88006de00000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 0000000000000055 CR3: 000000003c145000 CR4: 00000000000006e0
DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400
Call Trace:
process_one_work+0xbf3/0x1bc0 kernel/workqueue.c:2098
worker_thread+0x223/0x1860 kernel/workqueue.c:2233
kthread+0x35e/0x430 kernel/kthread.c:231
ret_from_fork+0x2a/0x40 arch/x86/entry/entry_64.S:431
Code: Bad RIP value.
RIP: 0x55 RSP: ffff88006bb17540
CR2: 0000000000000055
---[ end trace f0e4920047069cee ]---
Here is a C reproducer (requires CONFIG_BPF_SYSCALL=y and
CONFIG_AF_KCM=y):
#include <linux/bpf.h>
#include <linux/kcm.h>
#include <linux/types.h>
#include <stdint.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/syscall.h>
#include <unistd.h>
static const struct bpf_insn bpf_insns[3] = {
{ .code = 0xb7 }, /* BPF_MOV64_IMM(0, 0) */
{ .code = 0x95 }, /* BPF_EXIT_INSN() */
};
static const union bpf_attr bpf_attr = {
.prog_type = 1,
.insn_cnt = 2,
.insns = (uintptr_t)&bpf_insns,
.license = (uintptr_t)"",
};
int main(void)
{
int bpf_fd = syscall(__NR_bpf, BPF_PROG_LOAD,
&bpf_attr, sizeof(bpf_attr));
int inet_fd = socket(AF_INET, SOCK_STREAM, 0);
int kcm_fd = socket(AF_KCM, SOCK_DGRAM, 0);
ioctl(kcm_fd, SIOCKCMATTACH,
&(struct kcm_attach) { .fd = inet_fd, .bpf_fd = bpf_fd });
}
Fixes: bbb03029a899 ("strparser: Generalize strparser")
Cc: Dmitry Vyukov <dvyukov@google.com>
Cc: Tom Herbert <tom@quantonium.net>
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-24 23:38:51 +02:00
|
|
|
const struct strp_callbacks *cb)
|
2016-08-15 23:51:03 +02:00
|
|
|
|
2017-07-29 01:22:43 +02:00
|
|
|
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.
|
|
|
|
|
2018-06-24 14:44:01 +02:00
|
|
|
void strp_unpause(struct strparser *strp)
|
2017-07-29 01:22:43 +02:00
|
|
|
|
|
|
|
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.
|
2016-08-15 23:51:03 +02:00
|
|
|
|
|
|
|
Callbacks
|
2017-07-29 01:22:43 +02:00
|
|
|
=========
|
2016-08-15 23:51:03 +02:00
|
|
|
|
2017-07-29 01:22:43 +02:00
|
|
|
There are six callbacks:
|
2016-08-15 23:51:03 +02:00
|
|
|
|
|
|
|
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
|
2017-07-29 01:22:43 +02:00
|
|
|
next application layer message in the stream.
|
2016-08-15 23:51:03 +02:00
|
|
|
|
2017-07-29 01:22:43 +02:00
|
|
|
The skb->cb in the input skb is a struct strp_msg. Only
|
2016-08-15 23:51:03 +02:00
|
|
|
the offset field is relevant in parse_msg and gives the offset
|
|
|
|
where the message starts in the skb.
|
|
|
|
|
|
|
|
The return values of this function are:
|
|
|
|
|
|
|
|
>0 : indicates length of successfully parsed message
|
|
|
|
0 : indicates more data must be received to parse the message
|
|
|
|
-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
|
2017-07-29 01:22:43 +02:00
|
|
|
other < 0 : Error in parsing, give control back to userspace
|
2016-08-15 23:51:03 +02:00
|
|
|
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
|
2017-07-29 01:22:43 +02:00
|
|
|
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.
|
2016-08-15 23:51:03 +02:00
|
|
|
|
|
|
|
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
|
2017-07-29 01:22:43 +02:00
|
|
|
received in rcv_msg (see strp_pause above). This callback
|
2016-08-15 23:51:03 +02:00
|
|
|
must be set.
|
|
|
|
|
2017-07-29 01:22:43 +02:00
|
|
|
The skb->cb in the input skb is a struct strp_msg. This
|
2016-08-15 23:51:03 +02:00
|
|
|
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
|
|
|
|
then full_len since strparser does not trim the skb.
|
|
|
|
|
|
|
|
int (*read_sock_done)(struct strparser *strp, int err);
|
|
|
|
|
|
|
|
read_sock_done is called when the stream parser is done reading
|
2017-07-29 01:22:43 +02:00
|
|
|
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.
|
2016-08-15 23:51:03 +02:00
|
|
|
|
|
|
|
void (*abort_parser)(struct strparser *strp, int err);
|
|
|
|
|
|
|
|
This function is called when stream parser encounters an error
|
2017-07-29 01:22:43 +02:00
|
|
|
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.
|
2016-08-15 23:51:03 +02:00
|
|
|
|
2017-07-29 01:22:43 +02:00
|
|
|
Statistics
|
|
|
|
==========
|
2016-08-15 23:51:03 +02:00
|
|
|
|
2017-07-29 01:22:43 +02:00
|
|
|
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.
|
2016-08-15 23:51:03 +02:00
|
|
|
|
2017-07-29 01:22:43 +02:00
|
|
|
Message assembly limits
|
|
|
|
=======================
|
2016-08-15 23:51:03 +02:00
|
|
|
|
2017-07-29 01:22:43 +02:00
|
|
|
The stream parser provide mechanisms to limit the resources consumed by
|
|
|
|
message assembly.
|
2016-08-15 23:51:03 +02:00
|
|
|
|
2017-07-29 01:22:43 +02:00
|
|
|
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.
|
2016-08-15 23:51:03 +02:00
|
|
|
|
2017-07-29 01:22:43 +02:00
|
|
|
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.
|
2016-08-15 23:51:03 +02:00
|
|
|
|
2017-07-29 01:22:43 +02:00
|
|
|
In general mode the message length limit is passed in as an argument
|
|
|
|
to strp_process.
|
2016-08-15 23:51:03 +02:00
|
|
|
|
2017-07-29 01:22:43 +02:00
|
|
|
Author
|
|
|
|
======
|
2016-08-15 23:51:03 +02:00
|
|
|
|
2017-07-29 01:22:43 +02:00
|
|
|
Tom Herbert (tom@quantonium.net)
|
2016-08-15 23:51:03 +02:00
|
|
|
|