Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : // bpf-lirc.c - handles bpf
       3                 :            : //
       4                 :            : // Copyright (C) 2018 Sean Young <sean@mess.org>
       5                 :            : 
       6                 :            : #include <linux/bpf.h>
       7                 :            : #include <linux/filter.h>
       8                 :            : #include <linux/bpf_lirc.h>
       9                 :            : #include "rc-core-priv.h"
      10                 :            : 
      11                 :            : #define lirc_rcu_dereference(p)                                         \
      12                 :            :         rcu_dereference_protected(p, lockdep_is_held(&ir_raw_handler_lock))
      13                 :            : 
      14                 :            : /*
      15                 :            :  * BPF interface for raw IR
      16                 :            :  */
      17                 :            : const struct bpf_prog_ops lirc_mode2_prog_ops = {
      18                 :            : };
      19                 :            : 
      20                 :          0 : BPF_CALL_1(bpf_rc_repeat, u32*, sample)
      21                 :            : {
      22                 :            :         struct ir_raw_event_ctrl *ctrl;
      23                 :            : 
      24                 :            :         ctrl = container_of(sample, struct ir_raw_event_ctrl, bpf_sample);
      25                 :            : 
      26                 :          0 :         rc_repeat(ctrl->dev);
      27                 :            : 
      28                 :            :         return 0;
      29                 :            : }
      30                 :            : 
      31                 :            : static const struct bpf_func_proto rc_repeat_proto = {
      32                 :            :         .func      = bpf_rc_repeat,
      33                 :            :         .gpl_only  = true, /* rc_repeat is EXPORT_SYMBOL_GPL */
      34                 :            :         .ret_type  = RET_INTEGER,
      35                 :            :         .arg1_type = ARG_PTR_TO_CTX,
      36                 :            : };
      37                 :            : 
      38                 :            : /*
      39                 :            :  * Currently rc-core does not support 64-bit scancodes, but there are many
      40                 :            :  * known protocols with more than 32 bits. So, define the interface as u64
      41                 :            :  * as a future-proof.
      42                 :            :  */
      43                 :          0 : BPF_CALL_4(bpf_rc_keydown, u32*, sample, u32, protocol, u64, scancode,
      44                 :            :            u32, toggle)
      45                 :            : {
      46                 :            :         struct ir_raw_event_ctrl *ctrl;
      47                 :            : 
      48                 :            :         ctrl = container_of(sample, struct ir_raw_event_ctrl, bpf_sample);
      49                 :            : 
      50                 :          0 :         rc_keydown(ctrl->dev, protocol, scancode, toggle != 0);
      51                 :            : 
      52                 :            :         return 0;
      53                 :            : }
      54                 :            : 
      55                 :            : static const struct bpf_func_proto rc_keydown_proto = {
      56                 :            :         .func      = bpf_rc_keydown,
      57                 :            :         .gpl_only  = true, /* rc_keydown is EXPORT_SYMBOL_GPL */
      58                 :            :         .ret_type  = RET_INTEGER,
      59                 :            :         .arg1_type = ARG_PTR_TO_CTX,
      60                 :            :         .arg2_type = ARG_ANYTHING,
      61                 :            :         .arg3_type = ARG_ANYTHING,
      62                 :            :         .arg4_type = ARG_ANYTHING,
      63                 :            : };
      64                 :            : 
      65                 :          0 : BPF_CALL_3(bpf_rc_pointer_rel, u32*, sample, s32, rel_x, s32, rel_y)
      66                 :            : {
      67                 :            :         struct ir_raw_event_ctrl *ctrl;
      68                 :            : 
      69                 :            :         ctrl = container_of(sample, struct ir_raw_event_ctrl, bpf_sample);
      70                 :            : 
      71                 :          0 :         input_report_rel(ctrl->dev->input_dev, REL_X, rel_x);
      72                 :          0 :         input_report_rel(ctrl->dev->input_dev, REL_Y, rel_y);
      73                 :          0 :         input_sync(ctrl->dev->input_dev);
      74                 :            : 
      75                 :            :         return 0;
      76                 :            : }
      77                 :            : 
      78                 :            : static const struct bpf_func_proto rc_pointer_rel_proto = {
      79                 :            :         .func      = bpf_rc_pointer_rel,
      80                 :            :         .gpl_only  = true,
      81                 :            :         .ret_type  = RET_INTEGER,
      82                 :            :         .arg1_type = ARG_PTR_TO_CTX,
      83                 :            :         .arg2_type = ARG_ANYTHING,
      84                 :            :         .arg3_type = ARG_ANYTHING,
      85                 :            : };
      86                 :            : 
      87                 :            : static const struct bpf_func_proto *
      88                 :          0 : lirc_mode2_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)
      89                 :            : {
      90                 :          0 :         switch (func_id) {
      91                 :            :         case BPF_FUNC_rc_repeat:
      92                 :            :                 return &rc_repeat_proto;
      93                 :            :         case BPF_FUNC_rc_keydown:
      94                 :          0 :                 return &rc_keydown_proto;
      95                 :            :         case BPF_FUNC_rc_pointer_rel:
      96                 :          0 :                 return &rc_pointer_rel_proto;
      97                 :            :         case BPF_FUNC_map_lookup_elem:
      98                 :          0 :                 return &bpf_map_lookup_elem_proto;
      99                 :            :         case BPF_FUNC_map_update_elem:
     100                 :          0 :                 return &bpf_map_update_elem_proto;
     101                 :            :         case BPF_FUNC_map_delete_elem:
     102                 :          0 :                 return &bpf_map_delete_elem_proto;
     103                 :            :         case BPF_FUNC_map_push_elem:
     104                 :          0 :                 return &bpf_map_push_elem_proto;
     105                 :            :         case BPF_FUNC_map_pop_elem:
     106                 :          0 :                 return &bpf_map_pop_elem_proto;
     107                 :            :         case BPF_FUNC_map_peek_elem:
     108                 :          0 :                 return &bpf_map_peek_elem_proto;
     109                 :            :         case BPF_FUNC_ktime_get_ns:
     110                 :          0 :                 return &bpf_ktime_get_ns_proto;
     111                 :            :         case BPF_FUNC_tail_call:
     112                 :          0 :                 return &bpf_tail_call_proto;
     113                 :            :         case BPF_FUNC_get_prandom_u32:
     114                 :          0 :                 return &bpf_get_prandom_u32_proto;
     115                 :            :         case BPF_FUNC_trace_printk:
     116                 :          0 :                 if (capable(CAP_SYS_ADMIN))
     117                 :          0 :                         return bpf_get_trace_printk_proto();
     118                 :            :                 /* fall through */
     119                 :            :         default:
     120                 :            :                 return NULL;
     121                 :            :         }
     122                 :            : }
     123                 :            : 
     124                 :          0 : static bool lirc_mode2_is_valid_access(int off, int size,
     125                 :            :                                        enum bpf_access_type type,
     126                 :            :                                        const struct bpf_prog *prog,
     127                 :            :                                        struct bpf_insn_access_aux *info)
     128                 :            : {
     129                 :            :         /* We have one field of u32 */
     130                 :          0 :         return type == BPF_READ && off == 0 && size == sizeof(u32);
     131                 :            : }
     132                 :            : 
     133                 :            : const struct bpf_verifier_ops lirc_mode2_verifier_ops = {
     134                 :            :         .get_func_proto  = lirc_mode2_func_proto,
     135                 :            :         .is_valid_access = lirc_mode2_is_valid_access
     136                 :            : };
     137                 :            : 
     138                 :            : #define BPF_MAX_PROGS 64
     139                 :            : 
     140                 :          0 : static int lirc_bpf_attach(struct rc_dev *rcdev, struct bpf_prog *prog)
     141                 :            : {
     142                 :            :         struct bpf_prog_array *old_array;
     143                 :            :         struct bpf_prog_array *new_array;
     144                 :            :         struct ir_raw_event_ctrl *raw;
     145                 :            :         int ret;
     146                 :            : 
     147                 :          0 :         if (rcdev->driver_type != RC_DRIVER_IR_RAW)
     148                 :            :                 return -EINVAL;
     149                 :            : 
     150                 :          0 :         ret = mutex_lock_interruptible(&ir_raw_handler_lock);
     151                 :          0 :         if (ret)
     152                 :            :                 return ret;
     153                 :            : 
     154                 :          0 :         raw = rcdev->raw;
     155                 :          0 :         if (!raw) {
     156                 :            :                 ret = -ENODEV;
     157                 :            :                 goto unlock;
     158                 :            :         }
     159                 :            : 
     160                 :          0 :         old_array = lirc_rcu_dereference(raw->progs);
     161                 :          0 :         if (old_array && bpf_prog_array_length(old_array) >= BPF_MAX_PROGS) {
     162                 :            :                 ret = -E2BIG;
     163                 :            :                 goto unlock;
     164                 :            :         }
     165                 :            : 
     166                 :          0 :         ret = bpf_prog_array_copy(old_array, NULL, prog, &new_array);
     167                 :          0 :         if (ret < 0)
     168                 :            :                 goto unlock;
     169                 :            : 
     170                 :          0 :         rcu_assign_pointer(raw->progs, new_array);
     171                 :          0 :         bpf_prog_array_free(old_array);
     172                 :            : 
     173                 :            : unlock:
     174                 :          0 :         mutex_unlock(&ir_raw_handler_lock);
     175                 :          0 :         return ret;
     176                 :            : }
     177                 :            : 
     178                 :          0 : static int lirc_bpf_detach(struct rc_dev *rcdev, struct bpf_prog *prog)
     179                 :            : {
     180                 :            :         struct bpf_prog_array *old_array;
     181                 :            :         struct bpf_prog_array *new_array;
     182                 :            :         struct ir_raw_event_ctrl *raw;
     183                 :            :         int ret;
     184                 :            : 
     185                 :          0 :         if (rcdev->driver_type != RC_DRIVER_IR_RAW)
     186                 :            :                 return -EINVAL;
     187                 :            : 
     188                 :          0 :         ret = mutex_lock_interruptible(&ir_raw_handler_lock);
     189                 :          0 :         if (ret)
     190                 :            :                 return ret;
     191                 :            : 
     192                 :          0 :         raw = rcdev->raw;
     193                 :          0 :         if (!raw) {
     194                 :            :                 ret = -ENODEV;
     195                 :            :                 goto unlock;
     196                 :            :         }
     197                 :            : 
     198                 :          0 :         old_array = lirc_rcu_dereference(raw->progs);
     199                 :          0 :         ret = bpf_prog_array_copy(old_array, prog, NULL, &new_array);
     200                 :            :         /*
     201                 :            :          * Do not use bpf_prog_array_delete_safe() as we would end up
     202                 :            :          * with a dummy entry in the array, and the we would free the
     203                 :            :          * dummy in lirc_bpf_free()
     204                 :            :          */
     205                 :          0 :         if (ret)
     206                 :            :                 goto unlock;
     207                 :            : 
     208                 :          0 :         rcu_assign_pointer(raw->progs, new_array);
     209                 :          0 :         bpf_prog_array_free(old_array);
     210                 :          0 :         bpf_prog_put(prog);
     211                 :            : unlock:
     212                 :          0 :         mutex_unlock(&ir_raw_handler_lock);
     213                 :          0 :         return ret;
     214                 :            : }
     215                 :            : 
     216                 :          0 : void lirc_bpf_run(struct rc_dev *rcdev, u32 sample)
     217                 :            : {
     218                 :          0 :         struct ir_raw_event_ctrl *raw = rcdev->raw;
     219                 :            : 
     220                 :          0 :         raw->bpf_sample = sample;
     221                 :            : 
     222                 :          0 :         if (raw->progs)
     223                 :          0 :                 BPF_PROG_RUN_ARRAY(raw->progs, &raw->bpf_sample, BPF_PROG_RUN);
     224                 :          0 : }
     225                 :            : 
     226                 :            : /*
     227                 :            :  * This should be called once the rc thread has been stopped, so there can be
     228                 :            :  * no concurrent bpf execution.
     229                 :            :  *
     230                 :            :  * Should be called with the ir_raw_handler_lock held.
     231                 :            :  */
     232                 :          0 : void lirc_bpf_free(struct rc_dev *rcdev)
     233                 :            : {
     234                 :            :         struct bpf_prog_array_item *item;
     235                 :            :         struct bpf_prog_array *array;
     236                 :            : 
     237                 :          0 :         array = lirc_rcu_dereference(rcdev->raw->progs);
     238                 :          0 :         if (!array)
     239                 :          0 :                 return;
     240                 :            : 
     241                 :          0 :         for (item = array->items; item->prog; item++)
     242                 :          0 :                 bpf_prog_put(item->prog);
     243                 :            : 
     244                 :          0 :         bpf_prog_array_free(array);
     245                 :            : }
     246                 :            : 
     247                 :          0 : int lirc_prog_attach(const union bpf_attr *attr, struct bpf_prog *prog)
     248                 :            : {
     249                 :            :         struct rc_dev *rcdev;
     250                 :            :         int ret;
     251                 :            : 
     252                 :          0 :         if (attr->attach_flags)
     253                 :            :                 return -EINVAL;
     254                 :            : 
     255                 :          0 :         rcdev = rc_dev_get_from_fd(attr->target_fd);
     256                 :          0 :         if (IS_ERR(rcdev))
     257                 :          0 :                 return PTR_ERR(rcdev);
     258                 :            : 
     259                 :          0 :         ret = lirc_bpf_attach(rcdev, prog);
     260                 :            : 
     261                 :          0 :         put_device(&rcdev->dev);
     262                 :            : 
     263                 :          0 :         return ret;
     264                 :            : }
     265                 :            : 
     266                 :          0 : int lirc_prog_detach(const union bpf_attr *attr)
     267                 :            : {
     268                 :            :         struct bpf_prog *prog;
     269                 :            :         struct rc_dev *rcdev;
     270                 :            :         int ret;
     271                 :            : 
     272                 :          0 :         if (attr->attach_flags)
     273                 :            :                 return -EINVAL;
     274                 :            : 
     275                 :          0 :         prog = bpf_prog_get_type(attr->attach_bpf_fd,
     276                 :            :                                  BPF_PROG_TYPE_LIRC_MODE2);
     277                 :          0 :         if (IS_ERR(prog))
     278                 :          0 :                 return PTR_ERR(prog);
     279                 :            : 
     280                 :          0 :         rcdev = rc_dev_get_from_fd(attr->target_fd);
     281                 :          0 :         if (IS_ERR(rcdev)) {
     282                 :          0 :                 bpf_prog_put(prog);
     283                 :          0 :                 return PTR_ERR(rcdev);
     284                 :            :         }
     285                 :            : 
     286                 :          0 :         ret = lirc_bpf_detach(rcdev, prog);
     287                 :            : 
     288                 :          0 :         bpf_prog_put(prog);
     289                 :          0 :         put_device(&rcdev->dev);
     290                 :            : 
     291                 :          0 :         return ret;
     292                 :            : }
     293                 :            : 
     294                 :          0 : int lirc_prog_query(const union bpf_attr *attr, union bpf_attr __user *uattr)
     295                 :            : {
     296                 :          0 :         __u32 __user *prog_ids = u64_to_user_ptr(attr->query.prog_ids);
     297                 :            :         struct bpf_prog_array *progs;
     298                 :            :         struct rc_dev *rcdev;
     299                 :          0 :         u32 cnt, flags = 0;
     300                 :            :         int ret;
     301                 :            : 
     302                 :          0 :         if (attr->query.query_flags)
     303                 :            :                 return -EINVAL;
     304                 :            : 
     305                 :          0 :         rcdev = rc_dev_get_from_fd(attr->query.target_fd);
     306                 :          0 :         if (IS_ERR(rcdev))
     307                 :          0 :                 return PTR_ERR(rcdev);
     308                 :            : 
     309                 :          0 :         if (rcdev->driver_type != RC_DRIVER_IR_RAW) {
     310                 :            :                 ret = -EINVAL;
     311                 :            :                 goto put;
     312                 :            :         }
     313                 :            : 
     314                 :          0 :         ret = mutex_lock_interruptible(&ir_raw_handler_lock);
     315                 :          0 :         if (ret)
     316                 :            :                 goto put;
     317                 :            : 
     318                 :          0 :         progs = lirc_rcu_dereference(rcdev->raw->progs);
     319                 :          0 :         cnt = progs ? bpf_prog_array_length(progs) : 0;
     320                 :            : 
     321                 :          0 :         if (copy_to_user(&uattr->query.prog_cnt, &cnt, sizeof(cnt))) {
     322                 :            :                 ret = -EFAULT;
     323                 :            :                 goto unlock;
     324                 :            :         }
     325                 :            : 
     326                 :          0 :         if (copy_to_user(&uattr->query.attach_flags, &flags, sizeof(flags))) {
     327                 :            :                 ret = -EFAULT;
     328                 :            :                 goto unlock;
     329                 :            :         }
     330                 :            : 
     331                 :          0 :         if (attr->query.prog_cnt != 0 && prog_ids && cnt)
     332                 :          0 :                 ret = bpf_prog_array_copy_to_user(progs, prog_ids, cnt);
     333                 :            : 
     334                 :            : unlock:
     335                 :          0 :         mutex_unlock(&ir_raw_handler_lock);
     336                 :            : put:
     337                 :          0 :         put_device(&rcdev->dev);
     338                 :            : 
     339                 :          0 :         return ret;
     340                 :            : }