From: Greg Kroah-Hartman Date: Tue, 20 Feb 2024 15:44:15 +0000 (+0100) Subject: 6.1-stable patches X-Git-Tag: v4.19.307~47 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=a38811f87dd82fe745dc7ce0a463aa0552c8e4af;p=thirdparty%2Fkernel%2Fstable-queue.git 6.1-stable patches added patches: bpf-add-struct-for-bin_args-arg-in-bpf_bprintf_prepare.patch bpf-do-cleanup-in-bpf_bprintf_cleanup-only-when-needed.patch bpf-remove-trace_printk_lock.patch net-prevent-mss-overflow-in-skb_segment.patch --- diff --git a/queue-6.1/bpf-add-struct-for-bin_args-arg-in-bpf_bprintf_prepare.patch b/queue-6.1/bpf-add-struct-for-bin_args-arg-in-bpf_bprintf_prepare.patch new file mode 100644 index 00000000000..9b76c26c32f --- /dev/null +++ b/queue-6.1/bpf-add-struct-for-bin_args-arg-in-bpf_bprintf_prepare.patch @@ -0,0 +1,224 @@ +From 78aa1cc9404399a15d2a1205329c6a06236f5378 Mon Sep 17 00:00:00 2001 +From: Jiri Olsa +Date: Thu, 15 Dec 2022 22:44:28 +0100 +Subject: bpf: Add struct for bin_args arg in bpf_bprintf_prepare + +From: Jiri Olsa + +commit 78aa1cc9404399a15d2a1205329c6a06236f5378 upstream. + +Adding struct bpf_bprintf_data to hold bin_args argument for +bpf_bprintf_prepare function. + +We will add another return argument to bpf_bprintf_prepare and +pass the struct to bpf_bprintf_cleanup for proper cleanup in +following changes. + +Signed-off-by: Jiri Olsa +Signed-off-by: Daniel Borkmann +Acked-by: Yonghong Song +Link: https://lore.kernel.org/bpf/20221215214430.1336195-2-jolsa@kernel.org +Signed-off-by: Thadeu Lima de Souza Cascardo +Signed-off-by: Greg Kroah-Hartman +--- + include/linux/bpf.h | 7 ++++++- + kernel/bpf/helpers.c | 24 +++++++++++++----------- + kernel/bpf/verifier.c | 3 ++- + kernel/trace/bpf_trace.c | 34 ++++++++++++++++++++-------------- + 4 files changed, 41 insertions(+), 27 deletions(-) + +--- a/include/linux/bpf.h ++++ b/include/linux/bpf.h +@@ -2740,8 +2740,13 @@ bool btf_id_set_contains(const struct bt + + #define MAX_BPRINTF_VARARGS 12 + ++struct bpf_bprintf_data { ++ u32 *bin_args; ++ bool get_bin_args; ++}; ++ + int bpf_bprintf_prepare(char *fmt, u32 fmt_size, const u64 *raw_args, +- u32 **bin_buf, u32 num_args); ++ u32 num_args, struct bpf_bprintf_data *data); + void bpf_bprintf_cleanup(void); + + /* the implementation of the opaque uapi struct bpf_dynptr */ +--- a/kernel/bpf/helpers.c ++++ b/kernel/bpf/helpers.c +@@ -795,16 +795,16 @@ void bpf_bprintf_cleanup(void) + * Returns a negative value if fmt is an invalid format string or 0 otherwise. + * + * This can be used in two ways: +- * - Format string verification only: when bin_args is NULL ++ * - Format string verification only: when data->get_bin_args is false + * - Arguments preparation: in addition to the above verification, it writes in +- * bin_args a binary representation of arguments usable by bstr_printf where +- * pointers from BPF have been sanitized. ++ * data->bin_args a binary representation of arguments usable by bstr_printf ++ * where pointers from BPF have been sanitized. + * + * In argument preparation mode, if 0 is returned, safe temporary buffers are + * allocated and bpf_bprintf_cleanup should be called to free them after use. + */ + int bpf_bprintf_prepare(char *fmt, u32 fmt_size, const u64 *raw_args, +- u32 **bin_args, u32 num_args) ++ u32 num_args, struct bpf_bprintf_data *data) + { + char *unsafe_ptr = NULL, *tmp_buf = NULL, *tmp_buf_end, *fmt_end; + size_t sizeof_cur_arg, sizeof_cur_ip; +@@ -817,12 +817,12 @@ int bpf_bprintf_prepare(char *fmt, u32 f + return -EINVAL; + fmt_size = fmt_end - fmt; + +- if (bin_args) { ++ if (data->get_bin_args) { + if (num_args && try_get_fmt_tmp_buf(&tmp_buf)) + return -EBUSY; + + tmp_buf_end = tmp_buf + MAX_BPRINTF_BUF_LEN; +- *bin_args = (u32 *)tmp_buf; ++ data->bin_args = (u32 *)tmp_buf; + } + + for (i = 0; i < fmt_size; i++) { +@@ -1023,24 +1023,26 @@ out: + } + + BPF_CALL_5(bpf_snprintf, char *, str, u32, str_size, char *, fmt, +- const void *, data, u32, data_len) ++ const void *, args, u32, data_len) + { ++ struct bpf_bprintf_data data = { ++ .get_bin_args = true, ++ }; + int err, num_args; +- u32 *bin_args; + + if (data_len % 8 || data_len > MAX_BPRINTF_VARARGS * 8 || +- (data_len && !data)) ++ (data_len && !args)) + return -EINVAL; + num_args = data_len / 8; + + /* ARG_PTR_TO_CONST_STR guarantees that fmt is zero-terminated so we + * can safely give an unbounded size. + */ +- err = bpf_bprintf_prepare(fmt, UINT_MAX, data, &bin_args, num_args); ++ err = bpf_bprintf_prepare(fmt, UINT_MAX, args, num_args, &data); + if (err < 0) + return err; + +- err = bstr_printf(str, str_size, fmt, bin_args); ++ err = bstr_printf(str, str_size, fmt, data.bin_args); + + bpf_bprintf_cleanup(); + +--- a/kernel/bpf/verifier.c ++++ b/kernel/bpf/verifier.c +@@ -7448,6 +7448,7 @@ static int check_bpf_snprintf_call(struc + struct bpf_reg_state *fmt_reg = ®s[BPF_REG_3]; + struct bpf_reg_state *data_len_reg = ®s[BPF_REG_5]; + struct bpf_map *fmt_map = fmt_reg->map_ptr; ++ struct bpf_bprintf_data data = {}; + int err, fmt_map_off, num_args; + u64 fmt_addr; + char *fmt; +@@ -7472,7 +7473,7 @@ static int check_bpf_snprintf_call(struc + /* We are also guaranteed that fmt+fmt_map_off is NULL terminated, we + * can focus on validating the format specifiers. + */ +- err = bpf_bprintf_prepare(fmt, UINT_MAX, NULL, NULL, num_args); ++ err = bpf_bprintf_prepare(fmt, UINT_MAX, NULL, num_args, &data); + if (err < 0) + verbose(env, "Invalid format string\n"); + +--- a/kernel/trace/bpf_trace.c ++++ b/kernel/trace/bpf_trace.c +@@ -377,18 +377,20 @@ BPF_CALL_5(bpf_trace_printk, char *, fmt + u64, arg2, u64, arg3) + { + u64 args[MAX_TRACE_PRINTK_VARARGS] = { arg1, arg2, arg3 }; +- u32 *bin_args; ++ struct bpf_bprintf_data data = { ++ .get_bin_args = true, ++ }; + static char buf[BPF_TRACE_PRINTK_SIZE]; + unsigned long flags; + int ret; + +- ret = bpf_bprintf_prepare(fmt, fmt_size, args, &bin_args, +- MAX_TRACE_PRINTK_VARARGS); ++ ret = bpf_bprintf_prepare(fmt, fmt_size, args, ++ MAX_TRACE_PRINTK_VARARGS, &data); + if (ret < 0) + return ret; + + raw_spin_lock_irqsave(&trace_printk_lock, flags); +- ret = bstr_printf(buf, sizeof(buf), fmt, bin_args); ++ ret = bstr_printf(buf, sizeof(buf), fmt, data.bin_args); + + trace_bpf_trace_printk(buf); + raw_spin_unlock_irqrestore(&trace_printk_lock, flags); +@@ -426,25 +428,27 @@ const struct bpf_func_proto *bpf_get_tra + return &bpf_trace_printk_proto; + } + +-BPF_CALL_4(bpf_trace_vprintk, char *, fmt, u32, fmt_size, const void *, data, ++BPF_CALL_4(bpf_trace_vprintk, char *, fmt, u32, fmt_size, const void *, args, + u32, data_len) + { ++ struct bpf_bprintf_data data = { ++ .get_bin_args = true, ++ }; + static char buf[BPF_TRACE_PRINTK_SIZE]; + unsigned long flags; + int ret, num_args; +- u32 *bin_args; + + if (data_len & 7 || data_len > MAX_BPRINTF_VARARGS * 8 || +- (data_len && !data)) ++ (data_len && !args)) + return -EINVAL; + num_args = data_len / 8; + +- ret = bpf_bprintf_prepare(fmt, fmt_size, data, &bin_args, num_args); ++ ret = bpf_bprintf_prepare(fmt, fmt_size, args, num_args, &data); + if (ret < 0) + return ret; + + raw_spin_lock_irqsave(&trace_printk_lock, flags); +- ret = bstr_printf(buf, sizeof(buf), fmt, bin_args); ++ ret = bstr_printf(buf, sizeof(buf), fmt, data.bin_args); + + trace_bpf_trace_printk(buf); + raw_spin_unlock_irqrestore(&trace_printk_lock, flags); +@@ -471,21 +475,23 @@ const struct bpf_func_proto *bpf_get_tra + } + + BPF_CALL_5(bpf_seq_printf, struct seq_file *, m, char *, fmt, u32, fmt_size, +- const void *, data, u32, data_len) ++ const void *, args, u32, data_len) + { ++ struct bpf_bprintf_data data = { ++ .get_bin_args = true, ++ }; + int err, num_args; +- u32 *bin_args; + + if (data_len & 7 || data_len > MAX_BPRINTF_VARARGS * 8 || +- (data_len && !data)) ++ (data_len && !args)) + return -EINVAL; + num_args = data_len / 8; + +- err = bpf_bprintf_prepare(fmt, fmt_size, data, &bin_args, num_args); ++ err = bpf_bprintf_prepare(fmt, fmt_size, args, num_args, &data); + if (err < 0) + return err; + +- seq_bprintf(m, fmt, bin_args); ++ seq_bprintf(m, fmt, data.bin_args); + + bpf_bprintf_cleanup(); + diff --git a/queue-6.1/bpf-do-cleanup-in-bpf_bprintf_cleanup-only-when-needed.patch b/queue-6.1/bpf-do-cleanup-in-bpf_bprintf_cleanup-only-when-needed.patch new file mode 100644 index 00000000000..830076557eb --- /dev/null +++ b/queue-6.1/bpf-do-cleanup-in-bpf_bprintf_cleanup-only-when-needed.patch @@ -0,0 +1,121 @@ +From f19a4050455aad847fb93f18dc1fe502eb60f989 Mon Sep 17 00:00:00 2001 +From: Jiri Olsa +Date: Thu, 15 Dec 2022 22:44:29 +0100 +Subject: bpf: Do cleanup in bpf_bprintf_cleanup only when needed + +From: Jiri Olsa + +commit f19a4050455aad847fb93f18dc1fe502eb60f989 upstream. + +Currently we always cleanup/decrement bpf_bprintf_nest_level variable +in bpf_bprintf_cleanup if it's > 0. + +There's possible scenario where this could cause a problem, when +bpf_bprintf_prepare does not get bin_args buffer (because num_args is 0) +and following bpf_bprintf_cleanup call decrements bpf_bprintf_nest_level +variable, like: + + in task context: + bpf_bprintf_prepare(num_args != 0) increments 'bpf_bprintf_nest_level = 1' + -> first irq : + bpf_bprintf_prepare(num_args == 0) + bpf_bprintf_cleanup decrements 'bpf_bprintf_nest_level = 0' + -> second irq: + bpf_bprintf_prepare(num_args != 0) bpf_bprintf_nest_level = 1 + gets same buffer as task context above + +Adding check to bpf_bprintf_cleanup and doing the real cleanup only if we +got bin_args data in the first place. + +Signed-off-by: Jiri Olsa +Signed-off-by: Daniel Borkmann +Acked-by: Yonghong Song +Link: https://lore.kernel.org/bpf/20221215214430.1336195-3-jolsa@kernel.org +Signed-off-by: Thadeu Lima de Souza Cascardo +Signed-off-by: Greg Kroah-Hartman +--- + include/linux/bpf.h | 2 +- + kernel/bpf/helpers.c | 16 +++++++++------- + kernel/trace/bpf_trace.c | 6 +++--- + 3 files changed, 13 insertions(+), 11 deletions(-) + +--- a/include/linux/bpf.h ++++ b/include/linux/bpf.h +@@ -2747,7 +2747,7 @@ struct bpf_bprintf_data { + + int bpf_bprintf_prepare(char *fmt, u32 fmt_size, const u64 *raw_args, + u32 num_args, struct bpf_bprintf_data *data); +-void bpf_bprintf_cleanup(void); ++void bpf_bprintf_cleanup(struct bpf_bprintf_data *data); + + /* the implementation of the opaque uapi struct bpf_dynptr */ + struct bpf_dynptr_kern { +--- a/kernel/bpf/helpers.c ++++ b/kernel/bpf/helpers.c +@@ -781,12 +781,14 @@ static int try_get_fmt_tmp_buf(char **tm + return 0; + } + +-void bpf_bprintf_cleanup(void) ++void bpf_bprintf_cleanup(struct bpf_bprintf_data *data) + { +- if (this_cpu_read(bpf_bprintf_nest_level)) { +- this_cpu_dec(bpf_bprintf_nest_level); +- preempt_enable(); +- } ++ if (!data->bin_args) ++ return; ++ if (WARN_ON_ONCE(this_cpu_read(bpf_bprintf_nest_level) == 0)) ++ return; ++ this_cpu_dec(bpf_bprintf_nest_level); ++ preempt_enable(); + } + + /* +@@ -1018,7 +1020,7 @@ nocopy_fmt: + err = 0; + out: + if (err) +- bpf_bprintf_cleanup(); ++ bpf_bprintf_cleanup(data); + return err; + } + +@@ -1044,7 +1046,7 @@ BPF_CALL_5(bpf_snprintf, char *, str, u3 + + err = bstr_printf(str, str_size, fmt, data.bin_args); + +- bpf_bprintf_cleanup(); ++ bpf_bprintf_cleanup(&data); + + return err + 1; + } +--- a/kernel/trace/bpf_trace.c ++++ b/kernel/trace/bpf_trace.c +@@ -395,7 +395,7 @@ BPF_CALL_5(bpf_trace_printk, char *, fmt + trace_bpf_trace_printk(buf); + raw_spin_unlock_irqrestore(&trace_printk_lock, flags); + +- bpf_bprintf_cleanup(); ++ bpf_bprintf_cleanup(&data); + + return ret; + } +@@ -453,7 +453,7 @@ BPF_CALL_4(bpf_trace_vprintk, char *, fm + trace_bpf_trace_printk(buf); + raw_spin_unlock_irqrestore(&trace_printk_lock, flags); + +- bpf_bprintf_cleanup(); ++ bpf_bprintf_cleanup(&data); + + return ret; + } +@@ -493,7 +493,7 @@ BPF_CALL_5(bpf_seq_printf, struct seq_fi + + seq_bprintf(m, fmt, data.bin_args); + +- bpf_bprintf_cleanup(); ++ bpf_bprintf_cleanup(&data); + + return seq_has_overflowed(m) ? -EOVERFLOW : 0; + } diff --git a/queue-6.1/bpf-remove-trace_printk_lock.patch b/queue-6.1/bpf-remove-trace_printk_lock.patch new file mode 100644 index 00000000000..1b93606111a --- /dev/null +++ b/queue-6.1/bpf-remove-trace_printk_lock.patch @@ -0,0 +1,196 @@ +From e2bb9e01d589f7fa82573aedd2765ff9b277816a Mon Sep 17 00:00:00 2001 +From: Jiri Olsa +Date: Thu, 15 Dec 2022 22:44:30 +0100 +Subject: bpf: Remove trace_printk_lock + +From: Jiri Olsa + +commit e2bb9e01d589f7fa82573aedd2765ff9b277816a upstream. + +Both bpf_trace_printk and bpf_trace_vprintk helpers use static buffer guarded +with trace_printk_lock spin lock. + +The spin lock contention causes issues with bpf programs attached to +contention_begin tracepoint [1][2]. + +Andrii suggested we could get rid of the contention by using trylock, but we +could actually get rid of the spinlock completely by using percpu buffers the +same way as for bin_args in bpf_bprintf_prepare function. + +Adding new return 'buf' argument to struct bpf_bprintf_data and making +bpf_bprintf_prepare to return also the buffer for printk helpers. + + [1] https://lore.kernel.org/bpf/CACkBjsakT_yWxnSWr4r-0TpPvbKm9-OBmVUhJb7hV3hY8fdCkw@mail.gmail.com/ + [2] https://lore.kernel.org/bpf/CACkBjsaCsTovQHFfkqJKto6S4Z8d02ud1D7MPESrHa1cVNNTrw@mail.gmail.com/ + +Reported-by: Hao Sun +Suggested-by: Andrii Nakryiko +Signed-off-by: Jiri Olsa +Signed-off-by: Daniel Borkmann +Acked-by: Yonghong Song +Link: https://lore.kernel.org/bpf/20221215214430.1336195-4-jolsa@kernel.org +Signed-off-by: Thadeu Lima de Souza Cascardo +Signed-off-by: Greg Kroah-Hartman +--- + include/linux/bpf.h | 3 +++ + kernel/bpf/helpers.c | 31 +++++++++++++++++++------------ + kernel/trace/bpf_trace.c | 20 ++++++-------------- + 3 files changed, 28 insertions(+), 26 deletions(-) + +--- a/include/linux/bpf.h ++++ b/include/linux/bpf.h +@@ -2739,10 +2739,13 @@ struct btf_id_set; + bool btf_id_set_contains(const struct btf_id_set *set, u32 id); + + #define MAX_BPRINTF_VARARGS 12 ++#define MAX_BPRINTF_BUF 1024 + + struct bpf_bprintf_data { + u32 *bin_args; ++ char *buf; + bool get_bin_args; ++ bool get_buf; + }; + + int bpf_bprintf_prepare(char *fmt, u32 fmt_size, const u64 *raw_args, +--- a/kernel/bpf/helpers.c ++++ b/kernel/bpf/helpers.c +@@ -753,19 +753,20 @@ static int bpf_trace_copy_string(char *b + /* Per-cpu temp buffers used by printf-like helpers to store the bprintf binary + * arguments representation. + */ +-#define MAX_BPRINTF_BUF_LEN 512 ++#define MAX_BPRINTF_BIN_ARGS 512 + + /* Support executing three nested bprintf helper calls on a given CPU */ + #define MAX_BPRINTF_NEST_LEVEL 3 + struct bpf_bprintf_buffers { +- char tmp_bufs[MAX_BPRINTF_NEST_LEVEL][MAX_BPRINTF_BUF_LEN]; ++ char bin_args[MAX_BPRINTF_BIN_ARGS]; ++ char buf[MAX_BPRINTF_BUF]; + }; +-static DEFINE_PER_CPU(struct bpf_bprintf_buffers, bpf_bprintf_bufs); ++ ++static DEFINE_PER_CPU(struct bpf_bprintf_buffers[MAX_BPRINTF_NEST_LEVEL], bpf_bprintf_bufs); + static DEFINE_PER_CPU(int, bpf_bprintf_nest_level); + +-static int try_get_fmt_tmp_buf(char **tmp_buf) ++static int try_get_buffers(struct bpf_bprintf_buffers **bufs) + { +- struct bpf_bprintf_buffers *bufs; + int nest_level; + + preempt_disable(); +@@ -775,15 +776,14 @@ static int try_get_fmt_tmp_buf(char **tm + preempt_enable(); + return -EBUSY; + } +- bufs = this_cpu_ptr(&bpf_bprintf_bufs); +- *tmp_buf = bufs->tmp_bufs[nest_level - 1]; ++ *bufs = this_cpu_ptr(&bpf_bprintf_bufs[nest_level - 1]); + + return 0; + } + + void bpf_bprintf_cleanup(struct bpf_bprintf_data *data) + { +- if (!data->bin_args) ++ if (!data->bin_args && !data->buf) + return; + if (WARN_ON_ONCE(this_cpu_read(bpf_bprintf_nest_level) == 0)) + return; +@@ -808,7 +808,9 @@ void bpf_bprintf_cleanup(struct bpf_bpri + int bpf_bprintf_prepare(char *fmt, u32 fmt_size, const u64 *raw_args, + u32 num_args, struct bpf_bprintf_data *data) + { ++ bool get_buffers = (data->get_bin_args && num_args) || data->get_buf; + char *unsafe_ptr = NULL, *tmp_buf = NULL, *tmp_buf_end, *fmt_end; ++ struct bpf_bprintf_buffers *buffers = NULL; + size_t sizeof_cur_arg, sizeof_cur_ip; + int err, i, num_spec = 0; + u64 cur_arg; +@@ -819,14 +821,19 @@ int bpf_bprintf_prepare(char *fmt, u32 f + return -EINVAL; + fmt_size = fmt_end - fmt; + +- if (data->get_bin_args) { +- if (num_args && try_get_fmt_tmp_buf(&tmp_buf)) +- return -EBUSY; ++ if (get_buffers && try_get_buffers(&buffers)) ++ return -EBUSY; + +- tmp_buf_end = tmp_buf + MAX_BPRINTF_BUF_LEN; ++ if (data->get_bin_args) { ++ if (num_args) ++ tmp_buf = buffers->bin_args; ++ tmp_buf_end = tmp_buf + MAX_BPRINTF_BIN_ARGS; + data->bin_args = (u32 *)tmp_buf; + } + ++ if (data->get_buf) ++ data->buf = buffers->buf; ++ + for (i = 0; i < fmt_size; i++) { + if ((!isprint(fmt[i]) && !isspace(fmt[i])) || !isascii(fmt[i])) { + err = -EINVAL; +--- a/kernel/trace/bpf_trace.c ++++ b/kernel/trace/bpf_trace.c +@@ -368,8 +368,6 @@ static const struct bpf_func_proto *bpf_ + return &bpf_probe_write_user_proto; + } + +-static DEFINE_RAW_SPINLOCK(trace_printk_lock); +- + #define MAX_TRACE_PRINTK_VARARGS 3 + #define BPF_TRACE_PRINTK_SIZE 1024 + +@@ -379,9 +377,8 @@ BPF_CALL_5(bpf_trace_printk, char *, fmt + u64 args[MAX_TRACE_PRINTK_VARARGS] = { arg1, arg2, arg3 }; + struct bpf_bprintf_data data = { + .get_bin_args = true, ++ .get_buf = true, + }; +- static char buf[BPF_TRACE_PRINTK_SIZE]; +- unsigned long flags; + int ret; + + ret = bpf_bprintf_prepare(fmt, fmt_size, args, +@@ -389,11 +386,9 @@ BPF_CALL_5(bpf_trace_printk, char *, fmt + if (ret < 0) + return ret; + +- raw_spin_lock_irqsave(&trace_printk_lock, flags); +- ret = bstr_printf(buf, sizeof(buf), fmt, data.bin_args); ++ ret = bstr_printf(data.buf, MAX_BPRINTF_BUF, fmt, data.bin_args); + +- trace_bpf_trace_printk(buf); +- raw_spin_unlock_irqrestore(&trace_printk_lock, flags); ++ trace_bpf_trace_printk(data.buf); + + bpf_bprintf_cleanup(&data); + +@@ -433,9 +428,8 @@ BPF_CALL_4(bpf_trace_vprintk, char *, fm + { + struct bpf_bprintf_data data = { + .get_bin_args = true, ++ .get_buf = true, + }; +- static char buf[BPF_TRACE_PRINTK_SIZE]; +- unsigned long flags; + int ret, num_args; + + if (data_len & 7 || data_len > MAX_BPRINTF_VARARGS * 8 || +@@ -447,11 +441,9 @@ BPF_CALL_4(bpf_trace_vprintk, char *, fm + if (ret < 0) + return ret; + +- raw_spin_lock_irqsave(&trace_printk_lock, flags); +- ret = bstr_printf(buf, sizeof(buf), fmt, data.bin_args); ++ ret = bstr_printf(data.buf, MAX_BPRINTF_BUF, fmt, data.bin_args); + +- trace_bpf_trace_printk(buf); +- raw_spin_unlock_irqrestore(&trace_printk_lock, flags); ++ trace_bpf_trace_printk(data.buf); + + bpf_bprintf_cleanup(&data); + diff --git a/queue-6.1/net-prevent-mss-overflow-in-skb_segment.patch b/queue-6.1/net-prevent-mss-overflow-in-skb_segment.patch new file mode 100644 index 00000000000..80286939734 --- /dev/null +++ b/queue-6.1/net-prevent-mss-overflow-in-skb_segment.patch @@ -0,0 +1,112 @@ +From 23d05d563b7e7b0314e65c8e882bc27eac2da8e7 Mon Sep 17 00:00:00 2001 +From: Eric Dumazet +Date: Tue, 12 Dec 2023 16:46:21 +0000 +Subject: net: prevent mss overflow in skb_segment() + +From: Eric Dumazet + +commit 23d05d563b7e7b0314e65c8e882bc27eac2da8e7 upstream. + +Once again syzbot is able to crash the kernel in skb_segment() [1] + +GSO_BY_FRAGS is a forbidden value, but unfortunately the following +computation in skb_segment() can reach it quite easily : + + mss = mss * partial_segs; + +65535 = 3 * 5 * 17 * 257, so many initial values of mss can lead to +a bad final result. + +Make sure to limit segmentation so that the new mss value is smaller +than GSO_BY_FRAGS. + +[1] + +general protection fault, probably for non-canonical address 0xdffffc000000000e: 0000 [#1] PREEMPT SMP KASAN +KASAN: null-ptr-deref in range [0x0000000000000070-0x0000000000000077] +CPU: 1 PID: 5079 Comm: syz-executor993 Not tainted 6.7.0-rc4-syzkaller-00141-g1ae4cd3cbdd0 #0 +Hardware name: Google Google Compute Engine/Google Compute Engine, BIOS Google 11/10/2023 +RIP: 0010:skb_segment+0x181d/0x3f30 net/core/skbuff.c:4551 +Code: 83 e3 02 e9 fb ed ff ff e8 90 68 1c f9 48 8b 84 24 f8 00 00 00 48 8d 78 70 48 b8 00 00 00 00 00 fc ff df 48 89 fa 48 c1 ea 03 <0f> b6 04 02 84 c0 74 08 3c 03 0f 8e 8a 21 00 00 48 8b 84 24 f8 00 +RSP: 0018:ffffc900043473d0 EFLAGS: 00010202 +RAX: dffffc0000000000 RBX: 0000000000010046 RCX: ffffffff886b1597 +RDX: 000000000000000e RSI: ffffffff886b2520 RDI: 0000000000000070 +RBP: ffffc90004347578 R08: 0000000000000005 R09: 000000000000ffff +R10: 000000000000ffff R11: 0000000000000002 R12: ffff888063202ac0 +R13: 0000000000010000 R14: 000000000000ffff R15: 0000000000000046 +FS: 0000555556e7e380(0000) GS:ffff8880b9900000(0000) knlGS:0000000000000000 +CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 +CR2: 0000000020010000 CR3: 0000000027ee2000 CR4: 00000000003506f0 +DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 +DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400 +Call Trace: + +udp6_ufo_fragment+0xa0e/0xd00 net/ipv6/udp_offload.c:109 +ipv6_gso_segment+0x534/0x17e0 net/ipv6/ip6_offload.c:120 +skb_mac_gso_segment+0x290/0x610 net/core/gso.c:53 +__skb_gso_segment+0x339/0x710 net/core/gso.c:124 +skb_gso_segment include/net/gso.h:83 [inline] +validate_xmit_skb+0x36c/0xeb0 net/core/dev.c:3626 +__dev_queue_xmit+0x6f3/0x3d60 net/core/dev.c:4338 +dev_queue_xmit include/linux/netdevice.h:3134 [inline] +packet_xmit+0x257/0x380 net/packet/af_packet.c:276 +packet_snd net/packet/af_packet.c:3087 [inline] +packet_sendmsg+0x24c6/0x5220 net/packet/af_packet.c:3119 +sock_sendmsg_nosec net/socket.c:730 [inline] +__sock_sendmsg+0xd5/0x180 net/socket.c:745 +__sys_sendto+0x255/0x340 net/socket.c:2190 +__do_sys_sendto net/socket.c:2202 [inline] +__se_sys_sendto net/socket.c:2198 [inline] +__x64_sys_sendto+0xe0/0x1b0 net/socket.c:2198 +do_syscall_x64 arch/x86/entry/common.c:52 [inline] +do_syscall_64+0x40/0x110 arch/x86/entry/common.c:83 +entry_SYSCALL_64_after_hwframe+0x63/0x6b +RIP: 0033:0x7f8692032aa9 +Code: 28 00 00 00 75 05 48 83 c4 28 c3 e8 d1 19 00 00 90 48 89 f8 48 89 f7 48 89 d6 48 89 ca 4d 89 c2 4d 89 c8 4c 8b 4c 24 08 0f 05 <48> 3d 01 f0 ff ff 73 01 c3 48 c7 c1 b8 ff ff ff f7 d8 64 89 01 48 +RSP: 002b:00007fff8d685418 EFLAGS: 00000246 ORIG_RAX: 000000000000002c +RAX: ffffffffffffffda RBX: 0000000000000003 RCX: 00007f8692032aa9 +RDX: 0000000000010048 RSI: 00000000200000c0 RDI: 0000000000000003 +RBP: 00000000000f4240 R08: 0000000020000540 R09: 0000000000000014 +R10: 0000000000000000 R11: 0000000000000246 R12: 00007fff8d685480 +R13: 0000000000000001 R14: 00007fff8d685480 R15: 0000000000000003 + +Modules linked in: +---[ end trace 0000000000000000 ]--- +RIP: 0010:skb_segment+0x181d/0x3f30 net/core/skbuff.c:4551 +Code: 83 e3 02 e9 fb ed ff ff e8 90 68 1c f9 48 8b 84 24 f8 00 00 00 48 8d 78 70 48 b8 00 00 00 00 00 fc ff df 48 89 fa 48 c1 ea 03 <0f> b6 04 02 84 c0 74 08 3c 03 0f 8e 8a 21 00 00 48 8b 84 24 f8 00 +RSP: 0018:ffffc900043473d0 EFLAGS: 00010202 +RAX: dffffc0000000000 RBX: 0000000000010046 RCX: ffffffff886b1597 +RDX: 000000000000000e RSI: ffffffff886b2520 RDI: 0000000000000070 +RBP: ffffc90004347578 R08: 0000000000000005 R09: 000000000000ffff +R10: 000000000000ffff R11: 0000000000000002 R12: ffff888063202ac0 +R13: 0000000000010000 R14: 000000000000ffff R15: 0000000000000046 +FS: 0000555556e7e380(0000) GS:ffff8880b9900000(0000) knlGS:0000000000000000 +CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 +CR2: 0000000020010000 CR3: 0000000027ee2000 CR4: 00000000003506f0 +DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 +DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400 + +Fixes: 3953c46c3ac7 ("sk_buff: allow segmenting based on frag sizes") +Signed-off-by: Eric Dumazet +Cc: Marcelo Ricardo Leitner +Reviewed-by: Willem de Bruijn +Link: https://lore.kernel.org/r/20231212164621.4131800-1-edumazet@google.com +Signed-off-by: Jakub Kicinski +Signed-off-by: Greg Kroah-Hartman +--- + net/core/skbuff.c | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +--- a/net/core/skbuff.c ++++ b/net/core/skbuff.c +@@ -4213,8 +4213,9 @@ struct sk_buff *skb_segment(struct sk_bu + /* GSO partial only requires that we trim off any excess that + * doesn't fit into an MSS sized block, so take care of that + * now. ++ * Cap len to not accidentally hit GSO_BY_FRAGS. + */ +- partial_segs = len / mss; ++ partial_segs = min(len, GSO_BY_FRAGS - 1U) / mss; + if (partial_segs > 1) + mss *= partial_segs; + else diff --git a/queue-6.1/series b/queue-6.1/series index 83d677ef53b..6d7c8fcc33b 100644 --- a/queue-6.1/series +++ b/queue-6.1/series @@ -190,3 +190,7 @@ hrtimer-ignore-slack-time-for-rt-tasks-in-schedule_hrtimeout_range.patch rdma-irdma-ensure-iwarp-qp-queue-memory-is-os-paged-aligned.patch smb-client-fix-potential-oobs-in-smb2_parse_contexts.patch smb-client-fix-parsing-of-smb3.1.1-posix-create-context.patch +net-prevent-mss-overflow-in-skb_segment.patch +bpf-add-struct-for-bin_args-arg-in-bpf_bprintf_prepare.patch +bpf-do-cleanup-in-bpf_bprintf_cleanup-only-when-needed.patch +bpf-remove-trace_printk_lock.patch