1 // SPDX-License-Identifier: GPL-2.0
2 // bpf-lirc.c - handles bpf
4 // Copyright (C) 2018 Sean Young <sean@mess.org>
7 #include <linux/filter.h>
8 #include <linux/bpf_lirc.h>
9 #include "rc-core-priv.h"
12 * BPF interface for raw IR
14 const struct bpf_prog_ops lirc_mode2_prog_ops
= {
17 BPF_CALL_1(bpf_rc_repeat
, u32
*, sample
)
19 struct ir_raw_event_ctrl
*ctrl
;
21 ctrl
= container_of(sample
, struct ir_raw_event_ctrl
, bpf_sample
);
28 static const struct bpf_func_proto rc_repeat_proto
= {
29 .func
= bpf_rc_repeat
,
30 .gpl_only
= true, /* rc_repeat is EXPORT_SYMBOL_GPL */
31 .ret_type
= RET_INTEGER
,
32 .arg1_type
= ARG_PTR_TO_CTX
,
36 * Currently rc-core does not support 64-bit scancodes, but there are many
37 * known protocols with more than 32 bits. So, define the interface as u64
40 BPF_CALL_4(bpf_rc_keydown
, u32
*, sample
, u32
, protocol
, u64
, scancode
,
43 struct ir_raw_event_ctrl
*ctrl
;
45 ctrl
= container_of(sample
, struct ir_raw_event_ctrl
, bpf_sample
);
47 rc_keydown(ctrl
->dev
, protocol
, scancode
, toggle
!= 0);
52 static const struct bpf_func_proto rc_keydown_proto
= {
53 .func
= bpf_rc_keydown
,
54 .gpl_only
= true, /* rc_keydown is EXPORT_SYMBOL_GPL */
55 .ret_type
= RET_INTEGER
,
56 .arg1_type
= ARG_PTR_TO_CTX
,
57 .arg2_type
= ARG_ANYTHING
,
58 .arg3_type
= ARG_ANYTHING
,
59 .arg4_type
= ARG_ANYTHING
,
62 static const struct bpf_func_proto
*
63 lirc_mode2_func_proto(enum bpf_func_id func_id
, const struct bpf_prog
*prog
)
66 case BPF_FUNC_rc_repeat
:
67 return &rc_repeat_proto
;
68 case BPF_FUNC_rc_keydown
:
69 return &rc_keydown_proto
;
70 case BPF_FUNC_map_lookup_elem
:
71 return &bpf_map_lookup_elem_proto
;
72 case BPF_FUNC_map_update_elem
:
73 return &bpf_map_update_elem_proto
;
74 case BPF_FUNC_map_delete_elem
:
75 return &bpf_map_delete_elem_proto
;
76 case BPF_FUNC_ktime_get_ns
:
77 return &bpf_ktime_get_ns_proto
;
78 case BPF_FUNC_tail_call
:
79 return &bpf_tail_call_proto
;
80 case BPF_FUNC_get_prandom_u32
:
81 return &bpf_get_prandom_u32_proto
;
82 case BPF_FUNC_trace_printk
:
83 if (capable(CAP_SYS_ADMIN
))
84 return bpf_get_trace_printk_proto();
91 static bool lirc_mode2_is_valid_access(int off
, int size
,
92 enum bpf_access_type type
,
93 const struct bpf_prog
*prog
,
94 struct bpf_insn_access_aux
*info
)
96 /* We have one field of u32 */
97 return type
== BPF_READ
&& off
== 0 && size
== sizeof(u32
);
100 const struct bpf_verifier_ops lirc_mode2_verifier_ops
= {
101 .get_func_proto
= lirc_mode2_func_proto
,
102 .is_valid_access
= lirc_mode2_is_valid_access
105 #define BPF_MAX_PROGS 64
107 static int lirc_bpf_attach(struct rc_dev
*rcdev
, struct bpf_prog
*prog
)
109 struct bpf_prog_array __rcu
*old_array
;
110 struct bpf_prog_array
*new_array
;
111 struct ir_raw_event_ctrl
*raw
;
114 if (rcdev
->driver_type
!= RC_DRIVER_IR_RAW
)
117 ret
= mutex_lock_interruptible(&ir_raw_handler_lock
);
127 if (raw
->progs
&& bpf_prog_array_length(raw
->progs
) >= BPF_MAX_PROGS
) {
132 old_array
= raw
->progs
;
133 ret
= bpf_prog_array_copy(old_array
, NULL
, prog
, &new_array
);
137 rcu_assign_pointer(raw
->progs
, new_array
);
138 bpf_prog_array_free(old_array
);
141 mutex_unlock(&ir_raw_handler_lock
);
145 static int lirc_bpf_detach(struct rc_dev
*rcdev
, struct bpf_prog
*prog
)
147 struct bpf_prog_array __rcu
*old_array
;
148 struct bpf_prog_array
*new_array
;
149 struct ir_raw_event_ctrl
*raw
;
152 if (rcdev
->driver_type
!= RC_DRIVER_IR_RAW
)
155 ret
= mutex_lock_interruptible(&ir_raw_handler_lock
);
165 old_array
= raw
->progs
;
166 ret
= bpf_prog_array_copy(old_array
, prog
, NULL
, &new_array
);
168 * Do not use bpf_prog_array_delete_safe() as we would end up
169 * with a dummy entry in the array, and the we would free the
170 * dummy in lirc_bpf_free()
175 rcu_assign_pointer(raw
->progs
, new_array
);
176 bpf_prog_array_free(old_array
);
179 mutex_unlock(&ir_raw_handler_lock
);
183 void lirc_bpf_run(struct rc_dev
*rcdev
, u32 sample
)
185 struct ir_raw_event_ctrl
*raw
= rcdev
->raw
;
187 raw
->bpf_sample
= sample
;
190 BPF_PROG_RUN_ARRAY(raw
->progs
, &raw
->bpf_sample
, BPF_PROG_RUN
);
194 * This should be called once the rc thread has been stopped, so there can be
195 * no concurrent bpf execution.
197 void lirc_bpf_free(struct rc_dev
*rcdev
)
199 struct bpf_prog_array_item
*item
;
201 if (!rcdev
->raw
->progs
)
204 item
= rcu_dereference(rcdev
->raw
->progs
)->items
;
206 bpf_prog_put(item
->prog
);
210 bpf_prog_array_free(rcdev
->raw
->progs
);
213 int lirc_prog_attach(const union bpf_attr
*attr
, struct bpf_prog
*prog
)
215 struct rc_dev
*rcdev
;
218 if (attr
->attach_flags
)
221 rcdev
= rc_dev_get_from_fd(attr
->target_fd
);
223 return PTR_ERR(rcdev
);
225 ret
= lirc_bpf_attach(rcdev
, prog
);
227 put_device(&rcdev
->dev
);
232 int lirc_prog_detach(const union bpf_attr
*attr
)
234 struct bpf_prog
*prog
;
235 struct rc_dev
*rcdev
;
238 if (attr
->attach_flags
)
241 prog
= bpf_prog_get_type(attr
->attach_bpf_fd
,
242 BPF_PROG_TYPE_LIRC_MODE2
);
244 return PTR_ERR(prog
);
246 rcdev
= rc_dev_get_from_fd(attr
->target_fd
);
249 return PTR_ERR(rcdev
);
252 ret
= lirc_bpf_detach(rcdev
, prog
);
255 put_device(&rcdev
->dev
);
260 int lirc_prog_query(const union bpf_attr
*attr
, union bpf_attr __user
*uattr
)
262 __u32 __user
*prog_ids
= u64_to_user_ptr(attr
->query
.prog_ids
);
263 struct bpf_prog_array __rcu
*progs
;
264 struct rc_dev
*rcdev
;
268 if (attr
->query
.query_flags
)
271 rcdev
= rc_dev_get_from_fd(attr
->query
.target_fd
);
273 return PTR_ERR(rcdev
);
275 if (rcdev
->driver_type
!= RC_DRIVER_IR_RAW
) {
280 ret
= mutex_lock_interruptible(&ir_raw_handler_lock
);
284 progs
= rcdev
->raw
->progs
;
285 cnt
= progs
? bpf_prog_array_length(progs
) : 0;
287 if (copy_to_user(&uattr
->query
.prog_cnt
, &cnt
, sizeof(cnt
))) {
292 if (copy_to_user(&uattr
->query
.attach_flags
, &flags
, sizeof(flags
))) {
297 if (attr
->query
.prog_cnt
!= 0 && prog_ids
&& cnt
)
298 ret
= bpf_prog_array_copy_to_user(progs
, prog_ids
, cnt
);
301 mutex_unlock(&ir_raw_handler_lock
);
303 put_device(&rcdev
->dev
);