Line data    Source code

       1             : // SPDX-License-Identifier: GPL-2.0-only
       2             : #include <linux/export.h>
       3             : #include <linux/slab.h>
       4             : #include <linux/regset.h>
       5             : 
       6           0 : static int __regset_get(struct task_struct *target,
       7             :                         const struct user_regset *regset,
       8             :                         unsigned int size,
       9             :                         void **data)
      10             : {
      11           0 :         void *p = *data, *to_free = NULL;
      12           0 :         int res;
      13             : 
      14           0 :         if (!regset->regset_get)
      15             :                 return -EOPNOTSUPP;
      16           0 :         if (size > regset->n * regset->size)
      17             :                 size = regset->n * regset->size;
      18           0 :         if (!p) {
      19           0 :                 to_free = p = kzalloc(size, GFP_KERNEL);
      20           0 :                 if (!p)
      21             :                         return -ENOMEM;
      22             :         }
      23           0 :         res = regset->regset_get(target, regset,
      24           0 :                            (struct membuf){.p = p, .left = size});
      25           0 :         if (res < 0) {
      26           0 :                 kfree(to_free);
      27           0 :                 return res;
      28             :         }
      29           0 :         *data = p;
      30           0 :         return size - res;
      31             : }
      32             : 
      33           0 : int regset_get(struct task_struct *target,
      34             :                const struct user_regset *regset,
      35             :                unsigned int size,
      36             :                void *data)
      37             : {
      38           0 :         return __regset_get(target, regset, size, &data);
      39             : }
      40             : EXPORT_SYMBOL(regset_get);
      41             : 
      42           0 : int regset_get_alloc(struct task_struct *target,
      43             :                      const struct user_regset *regset,
      44             :                      unsigned int size,
      45             :                      void **data)
      46             : {
      47           0 :         *data = NULL;
      48           0 :         return __regset_get(target, regset, size, data);
      49             : }
      50             : EXPORT_SYMBOL(regset_get_alloc);
      51             : 
      52             : /**
      53             :  * copy_regset_to_user - fetch a thread's user_regset data into user memory
      54             :  * @target:     thread to be examined
      55             :  * @view:       &struct user_regset_view describing user thread machine state
      56             :  * @setno:      index in @view->regsets
      57             :  * @offset:     offset into the regset data, in bytes
      58             :  * @size:       amount of data to copy, in bytes
      59             :  * @data:       user-mode pointer to copy into
      60             :  */
      61           0 : int copy_regset_to_user(struct task_struct *target,
      62             :                         const struct user_regset_view *view,
      63             :                         unsigned int setno,
      64             :                         unsigned int offset, unsigned int size,
      65             :                         void __user *data)
      66             : {
      67           0 :         const struct user_regset *regset = &view->regsets[setno];
      68           0 :         void *buf;
      69           0 :         int ret;
      70             : 
      71           0 :         ret = regset_get_alloc(target, regset, size, &buf);
      72           0 :         if (ret > 0)
      73           0 :                 ret = copy_to_user(data, buf, ret) ? -EFAULT : 0;
      74           0 :         kfree(buf);
      75           0 :         return ret;
      76             : }