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 (file)
index 0000000..9b76c26
--- /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 <jolsa@kernel.org>
+Date: Thu, 15 Dec 2022 22:44:28 +0100
+Subject: bpf: Add struct for bin_args arg in bpf_bprintf_prepare
+
+From: Jiri Olsa <jolsa@kernel.org>
+
+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 <jolsa@kernel.org>
+Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
+Acked-by: Yonghong Song <yhs@fb.com>
+Link: https://lore.kernel.org/bpf/20221215214430.1336195-2-jolsa@kernel.org
+Signed-off-by: Thadeu Lima de Souza Cascardo <cascardo@igalia.com>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+---
+ 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 = &regs[BPF_REG_3];
+       struct bpf_reg_state *data_len_reg = &regs[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 (file)
index 0000000..8300765
--- /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 <jolsa@kernel.org>
+Date: Thu, 15 Dec 2022 22:44:29 +0100
+Subject: bpf: Do cleanup in bpf_bprintf_cleanup only when needed
+
+From: Jiri Olsa <jolsa@kernel.org>
+
+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 <jolsa@kernel.org>
+Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
+Acked-by: Yonghong Song <yhs@fb.com>
+Link: https://lore.kernel.org/bpf/20221215214430.1336195-3-jolsa@kernel.org
+Signed-off-by: Thadeu Lima de Souza Cascardo <cascardo@igalia.com>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+---
+ 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 (file)
index 0000000..1b93606
--- /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 <jolsa@kernel.org>
+Date: Thu, 15 Dec 2022 22:44:30 +0100
+Subject: bpf: Remove trace_printk_lock
+
+From: Jiri Olsa <jolsa@kernel.org>
+
+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 <sunhao.th@gmail.com>
+Suggested-by: Andrii Nakryiko <andrii@kernel.org>
+Signed-off-by: Jiri Olsa <jolsa@kernel.org>
+Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
+Acked-by: Yonghong Song <yhs@fb.com>
+Link: https://lore.kernel.org/bpf/20221215214430.1336195-4-jolsa@kernel.org
+Signed-off-by: Thadeu Lima de Souza Cascardo <cascardo@igalia.com>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+---
+ 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 (file)
index 0000000..8028693
--- /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 <edumazet@google.com>
+Date: Tue, 12 Dec 2023 16:46:21 +0000
+Subject: net: prevent mss overflow in skb_segment()
+
+From: Eric Dumazet <edumazet@google.com>
+
+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:
+<TASK>
+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
+</TASK>
+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 <edumazet@google.com>
+Cc: Marcelo Ricardo Leitner <marcelo.leitner@gmail.com>
+Reviewed-by: Willem de Bruijn <willemb@google.com>
+Link: https://lore.kernel.org/r/20231212164621.4131800-1-edumazet@google.com
+Signed-off-by: Jakub Kicinski <kuba@kernel.org>
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+---
+ 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 83d677ef53bba9dbc085532e904c59b840085ceb..6d7c8fcc33b70662ad06fc840073af5695ba8be3 100644 (file)
--- 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