Merge branch 'bpf-ir-decoder'

Sean Young says:

====================
The kernel IR decoders (drivers/media/rc/ir-*-decoder.c) support the most
widely used IR protocols, but there are many protocols which are not
supported[1]. For example, the lirc-remotes[2] repo has over 2700 remotes,
many of which are not supported by rc-core. There is a "long tail" of
unsupported IR protocols, for which lircd is need to decode the IR .

IR encoding is done in such a way that some simple circuit can decode it;
therefore, bpf is ideal.

In order to support all these protocols, here we have bpf based IR decoding.
The idea is that user-space can define a decoder in bpf, attach it to
the rc device through the lirc chardev.

Separate work is underway to extend ir-keytable to have an extensive library
of bpf-based decoders, and a much expanded library of rc keymaps.

Another future application would be to compile IRP[3] to a IR BPF program, and
so support virtually every remote without having to write a decoder for each.
It might also be possible to support non-button devices such as analog
directional pads or air conditioning remote controls and decode the target
temperature in bpf, and pass that to an input device.

[1] http://www.hifi-remote.com/wiki/index.php?title=DecodeIR
[2] https://sourceforge.net/p/lirc-remotes/code/ci/master/tree/remotes/
[3] http://www.hifi-remote.com/wiki/index.php?title=IRP_Notation

Changes since v4:
 - Renamed rc_dev_bpf_{attach,detach,query} to lirc_bpf_{attach,detach,query}
 - Fixed error path in lirc_bpf_query
 - Rebased on bpf-next

Changes since v3:
 - Implemented review comments from Quentin Monnet and Y Song (thanks!)
 - More helpful and better formatted bpf helper documentation
 - Changed back to bpf_prog_array rather than open-coded implementation
 - scancodes can be 64 bit
 - bpf gets passed values in microseconds, not nanoseconds.
   microseconds is more than than enough (IR receivers support carriers upto
   70kHz, at which point a single period is already 14 microseconds). Also,
   this makes it much more consistent with lirc mode2.
 - Since it looks much more like lirc mode2, rename the program type to
   BPF_PROG_TYPE_LIRC_MODE2.
 - Rebased on bpf-next

Changes since v2:
 - Fixed locking issues
 - Improved self-test to cover more cases
 - Rebased on bpf-next again

Changes since v1:
 - Code review comments from Y Song <ys114321@gmail.com> and
   Randy Dunlap <rdunlap@infradead.org>
 - Re-wrote sample bpf to be selftest
 - Renamed RAWIR_DECODER -> RAWIR_EVENT (Kconfig, context, bpf prog type)
 - Rebase on bpf-next
 - Introduced bpf_rawir_event context structure with simpler access checking
====================

Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>

3 files changed, 18 insertions, 2 deletions

diff --git a/kernel/bpf/core.c b/kernel/bpf/core.c
index b574dddc05b8..527587de8a67 100644
--- a/kernel/bpf/core.c
+++ b/kernel/bpf/core.c
@@ -1616,6 +1616,7 @@ int bpf_prog_array_copy(struct bpf_prog_array __rcu *old_array,
         int new_prog_cnt, carry_prog_cnt = 0;
         struct bpf_prog **existing_prog;
         struct bpf_prog_array *array;
+        bool found_exclude = false;
         int new_prog_idx = 0;
 
         /* Figure out how many existing progs we need to carry over to
@@ -1624,14 +1625,20 @@ int bpf_prog_array_copy(struct bpf_prog_array __rcu *old_array,
         if (old_array) {
                 existing_prog = old_array->progs;
                 for (; *existing_prog; existing_prog++) {
-                        if (*existing_prog != exclude_prog &&
-                            *existing_prog != &dummy_bpf_prog.prog)
+                        if (*existing_prog == exclude_prog) {
+                                found_exclude = true;
+                                continue;
+                        }
+                        if (*existing_prog != &dummy_bpf_prog.prog)
                                 carry_prog_cnt++;
                         if (*existing_prog == include_prog)
                                 return -EEXIST;
                 }
         }
 
+        if (exclude_prog && !found_exclude)
+                return -ENOENT;
+
         /* How many progs (not NULL) will be in the new array? */
         new_prog_cnt = carry_prog_cnt;
         if (include_prog)
diff --git a/kernel/bpf/syscall.c b/kernel/bpf/syscall.c
index e254526d6744..7365d79ae00d 100644
--- a/kernel/bpf/syscall.c
+++ b/kernel/bpf/syscall.c
@@ -11,6 +11,7 @@
  */
 #include <linux/bpf.h>
 #include <linux/bpf_trace.h>
+#include <linux/bpf_lirc.h>
 #include <linux/btf.h>
 #include <linux/syscalls.h>
 #include <linux/slab.h>
@@ -1582,6 +1583,8 @@ static int bpf_prog_attach(const union bpf_attr *attr)
         case BPF_SK_SKB_STREAM_PARSER:
         case BPF_SK_SKB_STREAM_VERDICT:
                 return sockmap_get_from_fd(attr, BPF_PROG_TYPE_SK_SKB, true);
+        case BPF_LIRC_MODE2:
+                return lirc_prog_attach(attr);
         default:
                 return -EINVAL;
         }
@@ -1654,6 +1657,8 @@ static int bpf_prog_detach(const union bpf_attr *attr)
         case BPF_SK_SKB_STREAM_PARSER:
         case BPF_SK_SKB_STREAM_VERDICT:
                 return sockmap_get_from_fd(attr, BPF_PROG_TYPE_SK_SKB, false);
+        case BPF_LIRC_MODE2:
+                return lirc_prog_detach(attr);
         default:
                 return -EINVAL;
         }
@@ -1703,6 +1708,8 @@ static int bpf_prog_query(const union bpf_attr *attr,
         case BPF_CGROUP_SOCK_OPS:
         case BPF_CGROUP_DEVICE:
                 break;
+        case BPF_LIRC_MODE2:
+                return lirc_prog_query(attr, uattr);
         default:
                 return -EINVAL;
         }
diff --git a/kernel/trace/bpf_trace.c b/kernel/trace/bpf_trace.c
index 81fdf2fc94ac..af1486d9a0ed 100644
--- a/kernel/trace/bpf_trace.c
+++ b/kernel/trace/bpf_trace.c
@@ -1006,6 +1006,8 @@ void perf_event_detach_bpf_prog(struct perf_event *event)
 
         old_array = event->tp_event->prog_array;
         ret = bpf_prog_array_copy(old_array, event->prog, NULL, &new_array);
+        if (ret == -ENOENT)
+                goto unlock;
         if (ret < 0) {
                 bpf_prog_array_delete_safe(old_array, event->prog);
         } else {