LCOV - code coverage report
Current view: top level - kernel - ptrace.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 37 566 6.5 %
Date: 2022-03-28 16:04:14 Functions: 3 32 9.4 %
Branches: 18 393 4.6 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /*
       3                 :            :  * linux/kernel/ptrace.c
       4                 :            :  *
       5                 :            :  * (C) Copyright 1999 Linus Torvalds
       6                 :            :  *
       7                 :            :  * Common interfaces for "ptrace()" which we do not want
       8                 :            :  * to continually duplicate across every architecture.
       9                 :            :  */
      10                 :            : 
      11                 :            : #include <linux/capability.h>
      12                 :            : #include <linux/export.h>
      13                 :            : #include <linux/sched.h>
      14                 :            : #include <linux/sched/mm.h>
      15                 :            : #include <linux/sched/coredump.h>
      16                 :            : #include <linux/sched/task.h>
      17                 :            : #include <linux/errno.h>
      18                 :            : #include <linux/mm.h>
      19                 :            : #include <linux/highmem.h>
      20                 :            : #include <linux/pagemap.h>
      21                 :            : #include <linux/ptrace.h>
      22                 :            : #include <linux/security.h>
      23                 :            : #include <linux/signal.h>
      24                 :            : #include <linux/uio.h>
      25                 :            : #include <linux/audit.h>
      26                 :            : #include <linux/pid_namespace.h>
      27                 :            : #include <linux/syscalls.h>
      28                 :            : #include <linux/uaccess.h>
      29                 :            : #include <linux/regset.h>
      30                 :            : #include <linux/hw_breakpoint.h>
      31                 :            : #include <linux/cn_proc.h>
      32                 :            : #include <linux/compat.h>
      33                 :            : #include <linux/sched/signal.h>
      34                 :            : 
      35                 :            : #include <asm/syscall.h>  /* for syscall_get_* */
      36                 :            : 
      37                 :            : /*
      38                 :            :  * Access another process' address space via ptrace.
      39                 :            :  * Source/target buffer must be kernel space,
      40                 :            :  * Do not walk the page table directly, use get_user_pages
      41                 :            :  */
      42                 :          0 : int ptrace_access_vm(struct task_struct *tsk, unsigned long addr,
      43                 :            :                      void *buf, int len, unsigned int gup_flags)
      44                 :            : {
      45                 :          0 :         struct mm_struct *mm;
      46                 :          0 :         int ret;
      47                 :            : 
      48                 :          0 :         mm = get_task_mm(tsk);
      49         [ #  # ]:          0 :         if (!mm)
      50                 :            :                 return 0;
      51                 :            : 
      52         [ #  # ]:          0 :         if (!tsk->ptrace ||
      53   [ #  #  #  # ]:          0 :             (current != tsk->parent) ||
      54         [ #  # ]:          0 :             ((get_dumpable(mm) != SUID_DUMP_USER) &&
      55                 :          0 :              !ptracer_capable(tsk, mm->user_ns))) {
      56                 :          0 :                 mmput(mm);
      57                 :          0 :                 return 0;
      58                 :            :         }
      59                 :            : 
      60                 :          0 :         ret = __access_remote_vm(tsk, mm, addr, buf, len, gup_flags);
      61                 :          0 :         mmput(mm);
      62                 :            : 
      63                 :          0 :         return ret;
      64                 :            : }
      65                 :            : 
      66                 :            : 
      67                 :          0 : void __ptrace_link(struct task_struct *child, struct task_struct *new_parent,
      68                 :            :                    const struct cred *ptracer_cred)
      69                 :            : {
      70         [ #  # ]:          0 :         BUG_ON(!list_empty(&child->ptrace_entry));
      71         [ #  # ]:          0 :         list_add(&child->ptrace_entry, &new_parent->ptraced);
      72                 :          0 :         child->parent = new_parent;
      73         [ #  # ]:          0 :         child->ptracer_cred = get_cred(ptracer_cred);
      74                 :          0 : }
      75                 :            : 
      76                 :            : /*
      77                 :            :  * ptrace a task: make the debugger its new parent and
      78                 :            :  * move it to the ptrace list.
      79                 :            :  *
      80                 :            :  * Must be called with the tasklist lock write-held.
      81                 :            :  */
      82                 :          0 : static void ptrace_link(struct task_struct *child, struct task_struct *new_parent)
      83                 :            : {
      84                 :          0 :         __ptrace_link(child, new_parent, current_cred());
      85                 :          0 : }
      86                 :            : 
      87                 :            : /**
      88                 :            :  * __ptrace_unlink - unlink ptracee and restore its execution state
      89                 :            :  * @child: ptracee to be unlinked
      90                 :            :  *
      91                 :            :  * Remove @child from the ptrace list, move it back to the original parent,
      92                 :            :  * and restore the execution state so that it conforms to the group stop
      93                 :            :  * state.
      94                 :            :  *
      95                 :            :  * Unlinking can happen via two paths - explicit PTRACE_DETACH or ptracer
      96                 :            :  * exiting.  For PTRACE_DETACH, unless the ptracee has been killed between
      97                 :            :  * ptrace_check_attach() and here, it's guaranteed to be in TASK_TRACED.
      98                 :            :  * If the ptracer is exiting, the ptracee can be in any state.
      99                 :            :  *
     100                 :            :  * After detach, the ptracee should be in a state which conforms to the
     101                 :            :  * group stop.  If the group is stopped or in the process of stopping, the
     102                 :            :  * ptracee should be put into TASK_STOPPED; otherwise, it should be woken
     103                 :            :  * up from TASK_TRACED.
     104                 :            :  *
     105                 :            :  * If the ptracee is in TASK_TRACED and needs to be moved to TASK_STOPPED,
     106                 :            :  * it goes through TRACED -> RUNNING -> STOPPED transition which is similar
     107                 :            :  * to but in the opposite direction of what happens while attaching to a
     108                 :            :  * stopped task.  However, in this direction, the intermediate RUNNING
     109                 :            :  * state is not hidden even from the current ptracer and if it immediately
     110                 :            :  * re-attaches and performs a WNOHANG wait(2), it may fail.
     111                 :            :  *
     112                 :            :  * CONTEXT:
     113                 :            :  * write_lock_irq(tasklist_lock)
     114                 :            :  */
     115                 :          0 : void __ptrace_unlink(struct task_struct *child)
     116                 :            : {
     117                 :          0 :         const struct cred *old_cred;
     118         [ #  # ]:          0 :         BUG_ON(!child->ptrace);
     119                 :            : 
     120                 :          0 :         clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
     121                 :            : #ifdef TIF_SYSCALL_EMU
     122                 :          0 :         clear_tsk_thread_flag(child, TIF_SYSCALL_EMU);
     123                 :            : #endif
     124                 :            : 
     125                 :          0 :         child->parent = child->real_parent;
     126                 :          0 :         list_del_init(&child->ptrace_entry);
     127                 :          0 :         old_cred = child->ptracer_cred;
     128                 :          0 :         child->ptracer_cred = NULL;
     129                 :          0 :         put_cred(old_cred);
     130                 :            : 
     131                 :          0 :         spin_lock(&child->sighand->siglock);
     132                 :          0 :         child->ptrace = 0;
     133                 :            :         /*
     134                 :            :          * Clear all pending traps and TRAPPING.  TRAPPING should be
     135                 :            :          * cleared regardless of JOBCTL_STOP_PENDING.  Do it explicitly.
     136                 :            :          */
     137                 :          0 :         task_clear_jobctl_pending(child, JOBCTL_TRAP_MASK);
     138                 :          0 :         task_clear_jobctl_trapping(child);
     139                 :            : 
     140                 :            :         /*
     141                 :            :          * Reinstate JOBCTL_STOP_PENDING if group stop is in effect and
     142                 :            :          * @child isn't dead.
     143                 :            :          */
     144         [ #  # ]:          0 :         if (!(child->flags & PF_EXITING) &&
     145         [ #  # ]:          0 :             (child->signal->flags & SIGNAL_STOP_STOPPED ||
     146                 :            :              child->signal->group_stop_count)) {
     147                 :          0 :                 child->jobctl |= JOBCTL_STOP_PENDING;
     148                 :            : 
     149                 :            :                 /*
     150                 :            :                  * This is only possible if this thread was cloned by the
     151                 :            :                  * traced task running in the stopped group, set the signal
     152                 :            :                  * for the future reports.
     153                 :            :                  * FIXME: we should change ptrace_init_task() to handle this
     154                 :            :                  * case.
     155                 :            :                  */
     156         [ #  # ]:          0 :                 if (!(child->jobctl & JOBCTL_STOP_SIGMASK))
     157                 :          0 :                         child->jobctl |= SIGSTOP;
     158                 :            :         }
     159                 :            : 
     160                 :            :         /*
     161                 :            :          * If transition to TASK_STOPPED is pending or in TASK_TRACED, kick
     162                 :            :          * @child in the butt.  Note that @resume should be used iff @child
     163                 :            :          * is in TASK_TRACED; otherwise, we might unduly disrupt
     164                 :            :          * TASK_KILLABLE sleeps.
     165                 :            :          */
     166   [ #  #  #  # ]:          0 :         if (child->jobctl & JOBCTL_STOP_PENDING || task_is_traced(child))
     167                 :          0 :                 ptrace_signal_wake_up(child, true);
     168                 :            : 
     169                 :          0 :         spin_unlock(&child->sighand->siglock);
     170                 :          0 : }
     171                 :            : 
     172                 :            : /* Ensure that nothing can wake it up, even SIGKILL */
     173                 :          0 : static bool ptrace_freeze_traced(struct task_struct *task)
     174                 :            : {
     175                 :          0 :         bool ret = false;
     176                 :            : 
     177                 :            :         /* Lockless, nobody but us can set this flag */
     178         [ #  # ]:          0 :         if (task->jobctl & JOBCTL_LISTENING)
     179                 :            :                 return ret;
     180                 :            : 
     181                 :          0 :         spin_lock_irq(&task->sighand->siglock);
     182   [ #  #  #  # ]:          0 :         if (task_is_traced(task) && !__fatal_signal_pending(task)) {
     183                 :          0 :                 task->state = __TASK_TRACED;
     184                 :          0 :                 ret = true;
     185                 :            :         }
     186                 :          0 :         spin_unlock_irq(&task->sighand->siglock);
     187                 :            : 
     188                 :          0 :         return ret;
     189                 :            : }
     190                 :            : 
     191                 :          0 : static void ptrace_unfreeze_traced(struct task_struct *task)
     192                 :            : {
     193         [ #  # ]:          0 :         if (task->state != __TASK_TRACED)
     194                 :            :                 return;
     195                 :            : 
     196   [ #  #  #  #  :          0 :         WARN_ON(!task->ptrace || task->parent != current);
                   #  # ]
     197                 :            : 
     198                 :            :         /*
     199                 :            :          * PTRACE_LISTEN can allow ptrace_trap_notify to wake us up remotely.
     200                 :            :          * Recheck state under the lock to close this race.
     201                 :            :          */
     202                 :          0 :         spin_lock_irq(&task->sighand->siglock);
     203         [ #  # ]:          0 :         if (task->state == __TASK_TRACED) {
     204         [ #  # ]:          0 :                 if (__fatal_signal_pending(task))
     205                 :          0 :                         wake_up_state(task, __TASK_TRACED);
     206                 :            :                 else
     207                 :          0 :                         task->state = TASK_TRACED;
     208                 :            :         }
     209                 :          0 :         spin_unlock_irq(&task->sighand->siglock);
     210                 :            : }
     211                 :            : 
     212                 :            : /**
     213                 :            :  * ptrace_check_attach - check whether ptracee is ready for ptrace operation
     214                 :            :  * @child: ptracee to check for
     215                 :            :  * @ignore_state: don't check whether @child is currently %TASK_TRACED
     216                 :            :  *
     217                 :            :  * Check whether @child is being ptraced by %current and ready for further
     218                 :            :  * ptrace operations.  If @ignore_state is %false, @child also should be in
     219                 :            :  * %TASK_TRACED state and on return the child is guaranteed to be traced
     220                 :            :  * and not executing.  If @ignore_state is %true, @child can be in any
     221                 :            :  * state.
     222                 :            :  *
     223                 :            :  * CONTEXT:
     224                 :            :  * Grabs and releases tasklist_lock and @child->sighand->siglock.
     225                 :            :  *
     226                 :            :  * RETURNS:
     227                 :            :  * 0 on success, -ESRCH if %child is not ready.
     228                 :            :  */
     229                 :          0 : static int ptrace_check_attach(struct task_struct *child, bool ignore_state)
     230                 :            : {
     231                 :          0 :         int ret = -ESRCH;
     232                 :            : 
     233                 :            :         /*
     234                 :            :          * We take the read lock around doing both checks to close a
     235                 :            :          * possible race where someone else was tracing our child and
     236                 :            :          * detached between these two checks.  After this locked check,
     237                 :            :          * we are sure that this is our traced child and that can only
     238                 :            :          * be changed by us so it's not changing right after this.
     239                 :            :          */
     240                 :          0 :         read_lock(&tasklist_lock);
     241   [ #  #  #  # ]:          0 :         if (child->ptrace && child->parent == current) {
     242         [ #  # ]:          0 :                 WARN_ON(child->state == __TASK_TRACED);
     243                 :            :                 /*
     244                 :            :                  * child->sighand can't be NULL, release_task()
     245                 :            :                  * does ptrace_unlink() before __exit_signal().
     246                 :            :                  */
     247   [ #  #  #  # ]:          0 :                 if (ignore_state || ptrace_freeze_traced(child))
     248                 :            :                         ret = 0;
     249                 :            :         }
     250                 :          0 :         read_unlock(&tasklist_lock);
     251                 :            : 
     252         [ #  # ]:          0 :         if (!ret && !ignore_state) {
     253         [ #  # ]:          0 :                 if (!wait_task_inactive(child, __TASK_TRACED)) {
     254                 :            :                         /*
     255                 :            :                          * This can only happen if may_ptrace_stop() fails and
     256                 :            :                          * ptrace_stop() changes ->state back to TASK_RUNNING,
     257                 :            :                          * so we should not worry about leaking __TASK_TRACED.
     258                 :            :                          */
     259         [ #  # ]:          0 :                         WARN_ON(child->state == __TASK_TRACED);
     260                 :            :                         ret = -ESRCH;
     261                 :            :                 }
     262                 :            :         }
     263                 :            : 
     264                 :          0 :         return ret;
     265                 :            : }
     266                 :            : 
     267                 :          1 : static bool ptrace_has_cap(const struct cred *cred, struct user_namespace *ns,
     268                 :            :                            unsigned int mode)
     269                 :            : {
     270                 :          1 :         int ret;
     271                 :            : 
     272         [ +  - ]:          1 :         if (mode & PTRACE_MODE_NOAUDIT)
     273                 :          1 :                 ret = security_capable(cred, ns, CAP_SYS_PTRACE, CAP_OPT_NOAUDIT);
     274                 :            :         else
     275                 :          0 :                 ret = security_capable(cred, ns, CAP_SYS_PTRACE, CAP_OPT_NONE);
     276                 :            : 
     277                 :          1 :         return ret == 0;
     278                 :            : }
     279                 :            : 
     280                 :            : /* Returns 0 on success, -errno on denial. */
     281                 :       4965 : static int __ptrace_may_access(struct task_struct *task, unsigned int mode)
     282                 :            : {
     283         [ -  + ]:       4965 :         const struct cred *cred = current_cred(), *tcred;
     284                 :       4965 :         struct mm_struct *mm;
     285                 :       4965 :         kuid_t caller_uid;
     286                 :       4965 :         kgid_t caller_gid;
     287                 :            : 
     288         [ -  + ]:       4965 :         if (!(mode & PTRACE_MODE_FSCREDS) == !(mode & PTRACE_MODE_REALCREDS)) {
     289                 :          0 :                 WARN(1, "denying ptrace access check without PTRACE_MODE_*CREDS\n");
     290                 :          0 :                 return -EPERM;
     291                 :            :         }
     292                 :            : 
     293                 :            :         /* May we inspect the given task?
     294                 :            :          * This check is used both for attaching with ptrace
     295                 :            :          * and for allowing access to sensitive information in /proc.
     296                 :            :          *
     297                 :            :          * ptrace_attach denies several cases that /proc allows
     298                 :            :          * because setting up the necessary parent/child relationship
     299                 :            :          * or halting the specified task is impossible.
     300                 :            :          */
     301                 :            : 
     302                 :            :         /* Don't let security modules deny introspection */
     303         [ +  + ]:       4965 :         if (same_thread_group(task, current))
     304                 :            :                 return 0;
     305                 :       1429 :         rcu_read_lock();
     306         [ +  - ]:       1429 :         if (mode & PTRACE_MODE_FSCREDS) {
     307                 :       1429 :                 caller_uid = cred->fsuid;
     308                 :       1429 :                 caller_gid = cred->fsgid;
     309                 :            :         } else {
     310                 :            :                 /*
     311                 :            :                  * Using the euid would make more sense here, but something
     312                 :            :                  * in userland might rely on the old behavior, and this
     313                 :            :                  * shouldn't be a security problem since
     314                 :            :                  * PTRACE_MODE_REALCREDS implies that the caller explicitly
     315                 :            :                  * used a syscall that requests access to another process
     316                 :            :                  * (and not a filesystem syscall to procfs).
     317                 :            :                  */
     318                 :          0 :                 caller_uid = cred->uid;
     319                 :          0 :                 caller_gid = cred->gid;
     320                 :            :         }
     321         [ +  - ]:       1429 :         tcred = __task_cred(task);
     322   [ +  -  +  - ]:       1429 :         if (uid_eq(caller_uid, tcred->euid) &&
     323         [ +  - ]:       1429 :             uid_eq(caller_uid, tcred->suid) &&
     324         [ +  - ]:       1429 :             uid_eq(caller_uid, tcred->uid)  &&
     325         [ +  - ]:       1429 :             gid_eq(caller_gid, tcred->egid) &&
     326         [ +  - ]:       1429 :             gid_eq(caller_gid, tcred->sgid) &&
     327                 :            :             gid_eq(caller_gid, tcred->gid))
     328                 :       1429 :                 goto ok;
     329         [ #  # ]:          0 :         if (ptrace_has_cap(cred, tcred->user_ns, mode))
     330                 :          0 :                 goto ok;
     331                 :          0 :         rcu_read_unlock();
     332                 :          0 :         return -EPERM;
     333                 :       1429 : ok:
     334                 :       1429 :         rcu_read_unlock();
     335                 :            :         /*
     336                 :            :          * If a task drops privileges and becomes nondumpable (through a syscall
     337                 :            :          * like setresuid()) while we are trying to access it, we must ensure
     338                 :            :          * that the dumpability is read after the credentials; otherwise,
     339                 :            :          * we may be able to attach to a task that we shouldn't be able to
     340                 :            :          * attach to (as if the task had dropped privileges without becoming
     341                 :            :          * nondumpable).
     342                 :            :          * Pairs with a write barrier in commit_creds().
     343                 :            :          */
     344                 :       1429 :         smp_rmb();
     345                 :       1429 :         mm = task->mm;
     346   [ +  +  +  + ]:       1429 :         if (mm &&
     347         [ +  - ]:          1 :             ((get_dumpable(mm) != SUID_DUMP_USER) &&
     348                 :          1 :              !ptrace_has_cap(cred, mm->user_ns, mode)))
     349                 :            :             return -EPERM;
     350                 :            : 
     351                 :       1429 :         return security_ptrace_access_check(task, mode);
     352                 :            : }
     353                 :            : 
     354                 :       4965 : bool ptrace_may_access(struct task_struct *task, unsigned int mode)
     355                 :            : {
     356                 :       4965 :         int err;
     357                 :       4965 :         task_lock(task);
     358                 :       4965 :         err = __ptrace_may_access(task, mode);
     359                 :       4965 :         task_unlock(task);
     360                 :       4965 :         return !err;
     361                 :            : }
     362                 :            : 
     363                 :          0 : static int ptrace_attach(struct task_struct *task, long request,
     364                 :            :                          unsigned long addr,
     365                 :            :                          unsigned long flags)
     366                 :            : {
     367                 :          0 :         bool seize = (request == PTRACE_SEIZE);
     368                 :          0 :         int retval;
     369                 :            : 
     370                 :          0 :         retval = -EIO;
     371         [ #  # ]:          0 :         if (seize) {
     372         [ #  # ]:          0 :                 if (addr != 0)
     373                 :          0 :                         goto out;
     374         [ #  # ]:          0 :                 if (flags & ~(unsigned long)PTRACE_O_MASK)
     375                 :          0 :                         goto out;
     376                 :          0 :                 flags = PT_PTRACED | PT_SEIZED | (flags << PT_OPT_FLAG_SHIFT);
     377                 :            :         } else {
     378                 :            :                 flags = PT_PTRACED;
     379                 :            :         }
     380                 :            : 
     381                 :          0 :         audit_ptrace(task);
     382                 :            : 
     383                 :          0 :         retval = -EPERM;
     384         [ #  # ]:          0 :         if (unlikely(task->flags & PF_KTHREAD))
     385                 :          0 :                 goto out;
     386         [ #  # ]:          0 :         if (same_thread_group(task, current))
     387                 :          0 :                 goto out;
     388                 :            : 
     389                 :            :         /*
     390                 :            :          * Protect exec's credential calculations against our interference;
     391                 :            :          * SUID, SGID and LSM creds get determined differently
     392                 :            :          * under ptrace.
     393                 :            :          */
     394                 :          0 :         retval = -ERESTARTNOINTR;
     395         [ #  # ]:          0 :         if (mutex_lock_interruptible(&task->signal->cred_guard_mutex))
     396                 :          0 :                 goto out;
     397                 :            : 
     398                 :          0 :         task_lock(task);
     399                 :          0 :         retval = __ptrace_may_access(task, PTRACE_MODE_ATTACH_REALCREDS);
     400                 :          0 :         task_unlock(task);
     401         [ #  # ]:          0 :         if (retval)
     402                 :          0 :                 goto unlock_creds;
     403                 :            : 
     404                 :          0 :         write_lock_irq(&tasklist_lock);
     405                 :          0 :         retval = -EPERM;
     406         [ #  # ]:          0 :         if (unlikely(task->exit_state))
     407                 :          0 :                 goto unlock_tasklist;
     408         [ #  # ]:          0 :         if (task->ptrace)
     409                 :          0 :                 goto unlock_tasklist;
     410                 :            : 
     411         [ #  # ]:          0 :         if (seize)
     412                 :          0 :                 flags |= PT_SEIZED;
     413                 :          0 :         task->ptrace = flags;
     414                 :            : 
     415                 :          0 :         ptrace_link(task, current);
     416                 :            : 
     417                 :            :         /* SEIZE doesn't trap tracee on attach */
     418         [ #  # ]:          0 :         if (!seize)
     419                 :          0 :                 send_sig_info(SIGSTOP, SEND_SIG_PRIV, task);
     420                 :            : 
     421                 :          0 :         spin_lock(&task->sighand->siglock);
     422                 :            : 
     423                 :            :         /*
     424                 :            :          * If the task is already STOPPED, set JOBCTL_TRAP_STOP and
     425                 :            :          * TRAPPING, and kick it so that it transits to TRACED.  TRAPPING
     426                 :            :          * will be cleared if the child completes the transition or any
     427                 :            :          * event which clears the group stop states happens.  We'll wait
     428                 :            :          * for the transition to complete before returning from this
     429                 :            :          * function.
     430                 :            :          *
     431                 :            :          * This hides STOPPED -> RUNNING -> TRACED transition from the
     432                 :            :          * attaching thread but a different thread in the same group can
     433                 :            :          * still observe the transient RUNNING state.  IOW, if another
     434                 :            :          * thread's WNOHANG wait(2) on the stopped tracee races against
     435                 :            :          * ATTACH, the wait(2) may fail due to the transient RUNNING.
     436                 :            :          *
     437                 :            :          * The following task_is_stopped() test is safe as both transitions
     438                 :            :          * in and out of STOPPED are protected by siglock.
     439                 :            :          */
     440   [ #  #  #  # ]:          0 :         if (task_is_stopped(task) &&
     441                 :          0 :             task_set_jobctl_pending(task, JOBCTL_TRAP_STOP | JOBCTL_TRAPPING))
     442                 :          0 :                 signal_wake_up_state(task, __TASK_STOPPED);
     443                 :            : 
     444                 :          0 :         spin_unlock(&task->sighand->siglock);
     445                 :            : 
     446                 :          0 :         retval = 0;
     447                 :          0 : unlock_tasklist:
     448                 :          0 :         write_unlock_irq(&tasklist_lock);
     449                 :          0 : unlock_creds:
     450                 :          0 :         mutex_unlock(&task->signal->cred_guard_mutex);
     451                 :            : out:
     452         [ #  # ]:          0 :         if (!retval) {
     453                 :            :                 /*
     454                 :            :                  * We do not bother to change retval or clear JOBCTL_TRAPPING
     455                 :            :                  * if wait_on_bit() was interrupted by SIGKILL. The tracer will
     456                 :            :                  * not return to user-mode, it will exit and clear this bit in
     457                 :            :                  * __ptrace_unlink() if it wasn't already cleared by the tracee;
     458                 :            :                  * and until then nobody can ptrace this task.
     459                 :            :                  */
     460                 :          0 :                 wait_on_bit(&task->jobctl, JOBCTL_TRAPPING_BIT, TASK_KILLABLE);
     461                 :          0 :                 proc_ptrace_connector(task, PTRACE_ATTACH);
     462                 :            :         }
     463                 :            : 
     464                 :          0 :         return retval;
     465                 :            : }
     466                 :            : 
     467                 :            : /**
     468                 :            :  * ptrace_traceme  --  helper for PTRACE_TRACEME
     469                 :            :  *
     470                 :            :  * Performs checks and sets PT_PTRACED.
     471                 :            :  * Should be used by all ptrace implementations for PTRACE_TRACEME.
     472                 :            :  */
     473                 :          0 : static int ptrace_traceme(void)
     474                 :            : {
     475                 :          0 :         int ret = -EPERM;
     476                 :            : 
     477                 :          0 :         write_lock_irq(&tasklist_lock);
     478                 :            :         /* Are we already being traced? */
     479         [ #  # ]:          0 :         if (!current->ptrace) {
     480                 :          0 :                 ret = security_ptrace_traceme(current->parent);
     481                 :            :                 /*
     482                 :            :                  * Check PF_EXITING to ensure ->real_parent has not passed
     483                 :            :                  * exit_ptrace(). Otherwise we don't report the error but
     484                 :            :                  * pretend ->real_parent untraces us right after return.
     485                 :            :                  */
     486   [ #  #  #  # ]:          0 :                 if (!ret && !(current->real_parent->flags & PF_EXITING)) {
     487                 :          0 :                         current->ptrace = PT_PTRACED;
     488                 :          0 :                         ptrace_link(current, current->real_parent);
     489                 :            :                 }
     490                 :            :         }
     491                 :          0 :         write_unlock_irq(&tasklist_lock);
     492                 :            : 
     493                 :          0 :         return ret;
     494                 :            : }
     495                 :            : 
     496                 :            : /*
     497                 :            :  * Called with irqs disabled, returns true if childs should reap themselves.
     498                 :            :  */
     499                 :          0 : static int ignoring_children(struct sighand_struct *sigh)
     500                 :            : {
     501                 :          0 :         int ret;
     502                 :          0 :         spin_lock(&sigh->siglock);
     503         [ #  # ]:          0 :         ret = (sigh->action[SIGCHLD-1].sa.sa_handler == SIG_IGN) ||
     504         [ #  # ]:          0 :               (sigh->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT);
     505                 :          0 :         spin_unlock(&sigh->siglock);
     506                 :          0 :         return ret;
     507                 :            : }
     508                 :            : 
     509                 :            : /*
     510                 :            :  * Called with tasklist_lock held for writing.
     511                 :            :  * Unlink a traced task, and clean it up if it was a traced zombie.
     512                 :            :  * Return true if it needs to be reaped with release_task().
     513                 :            :  * (We can't call release_task() here because we already hold tasklist_lock.)
     514                 :            :  *
     515                 :            :  * If it's a zombie, our attachedness prevented normal parent notification
     516                 :            :  * or self-reaping.  Do notification now if it would have happened earlier.
     517                 :            :  * If it should reap itself, return true.
     518                 :            :  *
     519                 :            :  * If it's our own child, there is no notification to do. But if our normal
     520                 :            :  * children self-reap, then this child was prevented by ptrace and we must
     521                 :            :  * reap it now, in that case we must also wake up sub-threads sleeping in
     522                 :            :  * do_wait().
     523                 :            :  */
     524                 :          0 : static bool __ptrace_detach(struct task_struct *tracer, struct task_struct *p)
     525                 :            : {
     526                 :          0 :         bool dead;
     527                 :            : 
     528                 :          0 :         __ptrace_unlink(p);
     529                 :            : 
     530         [ #  # ]:          0 :         if (p->exit_state != EXIT_ZOMBIE)
     531                 :            :                 return false;
     532                 :            : 
     533         [ #  # ]:          0 :         dead = !thread_group_leader(p);
     534                 :            : 
     535   [ #  #  #  # ]:          0 :         if (!dead && thread_group_empty(p)) {
     536         [ #  # ]:          0 :                 if (!same_thread_group(p->real_parent, tracer))
     537                 :          0 :                         dead = do_notify_parent(p, p->exit_signal);
     538         [ #  # ]:          0 :                 else if (ignoring_children(tracer->sighand)) {
     539                 :          0 :                         __wake_up_parent(p, tracer);
     540                 :          0 :                         dead = true;
     541                 :            :                 }
     542                 :            :         }
     543                 :            :         /* Mark it as in the process of being reaped. */
     544         [ #  # ]:          0 :         if (dead)
     545                 :          0 :                 p->exit_state = EXIT_DEAD;
     546                 :            :         return dead;
     547                 :            : }
     548                 :            : 
     549                 :          0 : static int ptrace_detach(struct task_struct *child, unsigned int data)
     550                 :            : {
     551         [ #  # ]:          0 :         if (!valid_signal(data))
     552                 :            :                 return -EIO;
     553                 :            : 
     554                 :            :         /* Architecture-specific hardware disable .. */
     555                 :          0 :         ptrace_disable(child);
     556                 :            : 
     557                 :          0 :         write_lock_irq(&tasklist_lock);
     558                 :            :         /*
     559                 :            :          * We rely on ptrace_freeze_traced(). It can't be killed and
     560                 :            :          * untraced by another thread, it can't be a zombie.
     561                 :            :          */
     562   [ #  #  #  #  :          0 :         WARN_ON(!child->ptrace || child->exit_state);
                   #  # ]
     563                 :            :         /*
     564                 :            :          * tasklist_lock avoids the race with wait_task_stopped(), see
     565                 :            :          * the comment in ptrace_resume().
     566                 :            :          */
     567                 :          0 :         child->exit_code = data;
     568                 :          0 :         __ptrace_detach(current, child);
     569                 :          0 :         write_unlock_irq(&tasklist_lock);
     570                 :            : 
     571                 :          0 :         proc_ptrace_connector(child, PTRACE_DETACH);
     572                 :            : 
     573                 :          0 :         return 0;
     574                 :            : }
     575                 :            : 
     576                 :            : /*
     577                 :            :  * Detach all tasks we were using ptrace on. Called with tasklist held
     578                 :            :  * for writing.
     579                 :            :  */
     580                 :          0 : void exit_ptrace(struct task_struct *tracer, struct list_head *dead)
     581                 :            : {
     582                 :          0 :         struct task_struct *p, *n;
     583                 :            : 
     584         [ #  # ]:          0 :         list_for_each_entry_safe(p, n, &tracer->ptraced, ptrace_entry) {
     585         [ #  # ]:          0 :                 if (unlikely(p->ptrace & PT_EXITKILL))
     586                 :          0 :                         send_sig_info(SIGKILL, SEND_SIG_PRIV, p);
     587                 :            : 
     588         [ #  # ]:          0 :                 if (__ptrace_detach(tracer, p))
     589                 :          0 :                         list_add(&p->ptrace_entry, dead);
     590                 :            :         }
     591                 :          0 : }
     592                 :            : 
     593                 :          0 : int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len)
     594                 :            : {
     595                 :          0 :         int copied = 0;
     596                 :            : 
     597         [ #  # ]:          0 :         while (len > 0) {
     598                 :          0 :                 char buf[128];
     599                 :          0 :                 int this_len, retval;
     600                 :            : 
     601                 :          0 :                 this_len = (len > sizeof(buf)) ? sizeof(buf) : len;
     602                 :          0 :                 retval = ptrace_access_vm(tsk, src, buf, this_len, FOLL_FORCE);
     603                 :            : 
     604         [ #  # ]:          0 :                 if (!retval) {
     605         [ #  # ]:          0 :                         if (copied)
     606                 :            :                                 break;
     607                 :          0 :                         return -EIO;
     608                 :            :                 }
     609   [ #  #  #  # ]:          0 :                 if (copy_to_user(dst, buf, retval))
     610                 :            :                         return -EFAULT;
     611                 :          0 :                 copied += retval;
     612                 :          0 :                 src += retval;
     613                 :          0 :                 dst += retval;
     614                 :          0 :                 len -= retval;
     615                 :            :         }
     616                 :            :         return copied;
     617                 :            : }
     618                 :            : 
     619                 :          0 : int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len)
     620                 :            : {
     621                 :          0 :         int copied = 0;
     622                 :            : 
     623         [ #  # ]:          0 :         while (len > 0) {
     624                 :          0 :                 char buf[128];
     625                 :          0 :                 int this_len, retval;
     626                 :            : 
     627                 :          0 :                 this_len = (len > sizeof(buf)) ? sizeof(buf) : len;
     628   [ #  #  #  # ]:          0 :                 if (copy_from_user(buf, src, this_len))
     629                 :          0 :                         return -EFAULT;
     630                 :          0 :                 retval = ptrace_access_vm(tsk, dst, buf, this_len,
     631                 :            :                                 FOLL_FORCE | FOLL_WRITE);
     632         [ #  # ]:          0 :                 if (!retval) {
     633         [ #  # ]:          0 :                         if (copied)
     634                 :            :                                 break;
     635                 :            :                         return -EIO;
     636                 :            :                 }
     637                 :          0 :                 copied += retval;
     638                 :          0 :                 src += retval;
     639                 :          0 :                 dst += retval;
     640                 :          0 :                 len -= retval;
     641                 :            :         }
     642                 :            :         return copied;
     643                 :            : }
     644                 :            : 
     645                 :          0 : static int ptrace_setoptions(struct task_struct *child, unsigned long data)
     646                 :            : {
     647                 :          0 :         unsigned flags;
     648                 :            : 
     649                 :          0 :         if (data & ~(unsigned long)PTRACE_O_MASK)
     650                 :            :                 return -EINVAL;
     651                 :            : 
     652         [ #  # ]:          0 :         if (unlikely(data & PTRACE_O_SUSPEND_SECCOMP)) {
     653                 :            :                 if (!IS_ENABLED(CONFIG_CHECKPOINT_RESTORE) ||
     654                 :            :                     !IS_ENABLED(CONFIG_SECCOMP))
     655                 :            :                         return -EINVAL;
     656                 :            : 
     657                 :            :                 if (!capable(CAP_SYS_ADMIN))
     658                 :            :                         return -EPERM;
     659                 :            : 
     660                 :            :                 if (seccomp_mode(&current->seccomp) != SECCOMP_MODE_DISABLED ||
     661                 :            :                     current->ptrace & PT_SUSPEND_SECCOMP)
     662                 :            :                         return -EPERM;
     663                 :            :         }
     664                 :            : 
     665                 :            :         /* Avoid intermediate state when all opts are cleared */
     666                 :          0 :         flags = child->ptrace;
     667                 :          0 :         flags &= ~(PTRACE_O_MASK << PT_OPT_FLAG_SHIFT);
     668                 :          0 :         flags |= (data << PT_OPT_FLAG_SHIFT);
     669                 :          0 :         child->ptrace = flags;
     670                 :            : 
     671                 :          0 :         return 0;
     672                 :            : }
     673                 :            : 
     674                 :          0 : static int ptrace_getsiginfo(struct task_struct *child, kernel_siginfo_t *info)
     675                 :            : {
     676                 :          0 :         unsigned long flags;
     677                 :          0 :         int error = -ESRCH;
     678                 :            : 
     679         [ #  # ]:          0 :         if (lock_task_sighand(child, &flags)) {
     680                 :          0 :                 error = -EINVAL;
     681         [ #  # ]:          0 :                 if (likely(child->last_siginfo != NULL)) {
     682                 :          0 :                         copy_siginfo(info, child->last_siginfo);
     683                 :          0 :                         error = 0;
     684                 :            :                 }
     685                 :          0 :                 unlock_task_sighand(child, &flags);
     686                 :            :         }
     687                 :          0 :         return error;
     688                 :            : }
     689                 :            : 
     690                 :          0 : static int ptrace_setsiginfo(struct task_struct *child, const kernel_siginfo_t *info)
     691                 :            : {
     692                 :          0 :         unsigned long flags;
     693                 :          0 :         int error = -ESRCH;
     694                 :            : 
     695         [ #  # ]:          0 :         if (lock_task_sighand(child, &flags)) {
     696                 :          0 :                 error = -EINVAL;
     697         [ #  # ]:          0 :                 if (likely(child->last_siginfo != NULL)) {
     698                 :          0 :                         copy_siginfo(child->last_siginfo, info);
     699                 :          0 :                         error = 0;
     700                 :            :                 }
     701                 :          0 :                 unlock_task_sighand(child, &flags);
     702                 :            :         }
     703                 :          0 :         return error;
     704                 :            : }
     705                 :            : 
     706                 :          0 : static int ptrace_peek_siginfo(struct task_struct *child,
     707                 :            :                                 unsigned long addr,
     708                 :            :                                 unsigned long data)
     709                 :            : {
     710                 :          0 :         struct ptrace_peeksiginfo_args arg;
     711                 :          0 :         struct sigpending *pending;
     712                 :          0 :         struct sigqueue *q;
     713                 :          0 :         int ret, i;
     714                 :            : 
     715                 :          0 :         ret = copy_from_user(&arg, (void __user *) addr,
     716                 :            :                                 sizeof(struct ptrace_peeksiginfo_args));
     717         [ #  # ]:          0 :         if (ret)
     718                 :            :                 return -EFAULT;
     719                 :            : 
     720         [ #  # ]:          0 :         if (arg.flags & ~PTRACE_PEEKSIGINFO_SHARED)
     721                 :            :                 return -EINVAL; /* unknown flags */
     722                 :            : 
     723         [ #  # ]:          0 :         if (arg.nr < 0)
     724                 :            :                 return -EINVAL;
     725                 :            : 
     726                 :            :         /* Ensure arg.off fits in an unsigned long */
     727                 :          0 :         if (arg.off > ULONG_MAX)
     728                 :            :                 return 0;
     729                 :            : 
     730         [ #  # ]:          0 :         if (arg.flags & PTRACE_PEEKSIGINFO_SHARED)
     731                 :          0 :                 pending = &child->signal->shared_pending;
     732                 :            :         else
     733                 :          0 :                 pending = &child->pending;
     734                 :            : 
     735         [ #  # ]:          0 :         for (i = 0; i < arg.nr; ) {
     736                 :          0 :                 kernel_siginfo_t info;
     737                 :          0 :                 unsigned long off = arg.off + i;
     738                 :          0 :                 bool found = false;
     739                 :            : 
     740                 :          0 :                 spin_lock_irq(&child->sighand->siglock);
     741         [ #  # ]:          0 :                 list_for_each_entry(q, &pending->list, list) {
     742         [ #  # ]:          0 :                         if (!off--) {
     743                 :          0 :                                 found = true;
     744                 :          0 :                                 copy_siginfo(&info, &q->info);
     745                 :            :                                 break;
     746                 :            :                         }
     747                 :            :                 }
     748                 :          0 :                 spin_unlock_irq(&child->sighand->siglock);
     749                 :            : 
     750         [ #  # ]:          0 :                 if (!found) /* beyond the end of the list */
     751                 :            :                         break;
     752                 :            : 
     753                 :            : #ifdef CONFIG_COMPAT
     754   [ #  #  #  # ]:          0 :                 if (unlikely(in_compat_syscall())) {
     755                 :          0 :                         compat_siginfo_t __user *uinfo = compat_ptr(data);
     756                 :            : 
     757         [ #  # ]:          0 :                         if (copy_siginfo_to_user32(uinfo, &info)) {
     758                 :            :                                 ret = -EFAULT;
     759                 :            :                                 break;
     760                 :            :                         }
     761                 :            : 
     762                 :            :                 } else
     763                 :            : #endif
     764                 :            :                 {
     765                 :          0 :                         siginfo_t __user *uinfo = (siginfo_t __user *) data;
     766                 :            : 
     767         [ #  # ]:          0 :                         if (copy_siginfo_to_user(uinfo, &info)) {
     768                 :            :                                 ret = -EFAULT;
     769                 :            :                                 break;
     770                 :            :                         }
     771                 :            :                 }
     772                 :            : 
     773                 :          0 :                 data += sizeof(siginfo_t);
     774                 :          0 :                 i++;
     775                 :            : 
     776         [ #  # ]:          0 :                 if (signal_pending(current))
     777                 :            :                         break;
     778                 :            : 
     779                 :          0 :                 cond_resched();
     780                 :            :         }
     781                 :            : 
     782         [ #  # ]:          0 :         if (i > 0)
     783                 :          0 :                 return i;
     784                 :            : 
     785                 :            :         return ret;
     786                 :            : }
     787                 :            : 
     788                 :            : #ifdef PTRACE_SINGLESTEP
     789                 :            : #define is_singlestep(request)          ((request) == PTRACE_SINGLESTEP)
     790                 :            : #else
     791                 :            : #define is_singlestep(request)          0
     792                 :            : #endif
     793                 :            : 
     794                 :            : #ifdef PTRACE_SINGLEBLOCK
     795                 :            : #define is_singleblock(request)         ((request) == PTRACE_SINGLEBLOCK)
     796                 :            : #else
     797                 :            : #define is_singleblock(request)         0
     798                 :            : #endif
     799                 :            : 
     800                 :            : #ifdef PTRACE_SYSEMU
     801                 :            : #define is_sysemu_singlestep(request)   ((request) == PTRACE_SYSEMU_SINGLESTEP)
     802                 :            : #else
     803                 :            : #define is_sysemu_singlestep(request)   0
     804                 :            : #endif
     805                 :            : 
     806                 :          0 : static int ptrace_resume(struct task_struct *child, long request,
     807                 :            :                          unsigned long data)
     808                 :            : {
     809                 :          0 :         bool need_siglock;
     810                 :            : 
     811         [ #  # ]:          0 :         if (!valid_signal(data))
     812                 :            :                 return -EIO;
     813                 :            : 
     814         [ #  # ]:          0 :         if (request == PTRACE_SYSCALL)
     815                 :          0 :                 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
     816                 :            :         else
     817                 :          0 :                 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
     818                 :            : 
     819                 :            : #ifdef TIF_SYSCALL_EMU
     820         [ #  # ]:          0 :         if (request == PTRACE_SYSEMU || request == PTRACE_SYSEMU_SINGLESTEP)
     821                 :          0 :                 set_tsk_thread_flag(child, TIF_SYSCALL_EMU);
     822                 :            :         else
     823                 :          0 :                 clear_tsk_thread_flag(child, TIF_SYSCALL_EMU);
     824                 :            : #endif
     825                 :            : 
     826         [ #  # ]:          0 :         if (is_singleblock(request)) {
     827                 :          0 :                 if (unlikely(!arch_has_block_step()))
     828                 :            :                         return -EIO;
     829                 :          0 :                 user_enable_block_step(child);
     830         [ #  # ]:          0 :         } else if (is_singlestep(request) || is_sysemu_singlestep(request)) {
     831                 :          0 :                 if (unlikely(!arch_has_single_step()))
     832                 :            :                         return -EIO;
     833                 :          0 :                 user_enable_single_step(child);
     834                 :            :         } else {
     835                 :          0 :                 user_disable_single_step(child);
     836                 :            :         }
     837                 :            : 
     838                 :            :         /*
     839                 :            :          * Change ->exit_code and ->state under siglock to avoid the race
     840                 :            :          * with wait_task_stopped() in between; a non-zero ->exit_code will
     841                 :            :          * wrongly look like another report from tracee.
     842                 :            :          *
     843                 :            :          * Note that we need siglock even if ->exit_code == data and/or this
     844                 :            :          * status was not reported yet, the new status must not be cleared by
     845                 :            :          * wait_task_stopped() after resume.
     846                 :            :          *
     847                 :            :          * If data == 0 we do not care if wait_task_stopped() reports the old
     848                 :            :          * status and clears the code too; this can't race with the tracee, it
     849                 :            :          * takes siglock after resume.
     850                 :            :          */
     851   [ #  #  #  # ]:          0 :         need_siglock = data && !thread_group_empty(current);
     852         [ #  # ]:          0 :         if (need_siglock)
     853                 :          0 :                 spin_lock_irq(&child->sighand->siglock);
     854                 :          0 :         child->exit_code = data;
     855                 :          0 :         wake_up_state(child, __TASK_TRACED);
     856         [ #  # ]:          0 :         if (need_siglock)
     857                 :          0 :                 spin_unlock_irq(&child->sighand->siglock);
     858                 :            : 
     859                 :            :         return 0;
     860                 :            : }
     861                 :            : 
     862                 :            : #ifdef CONFIG_HAVE_ARCH_TRACEHOOK
     863                 :            : 
     864                 :            : static const struct user_regset *
     865                 :            : find_regset(const struct user_regset_view *view, unsigned int type)
     866                 :            : {
     867                 :            :         const struct user_regset *regset;
     868                 :            :         int n;
     869                 :            : 
     870                 :            :         for (n = 0; n < view->n; ++n) {
     871                 :            :                 regset = view->regsets + n;
     872                 :            :                 if (regset->core_note_type == type)
     873                 :            :                         return regset;
     874                 :            :         }
     875                 :            : 
     876                 :            :         return NULL;
     877                 :            : }
     878                 :            : 
     879                 :            : static int ptrace_regset(struct task_struct *task, int req, unsigned int type,
     880                 :            :                          struct iovec *kiov)
     881                 :            : {
     882                 :            :         const struct user_regset_view *view = task_user_regset_view(task);
     883                 :            :         const struct user_regset *regset = find_regset(view, type);
     884                 :            :         int regset_no;
     885                 :            : 
     886                 :            :         if (!regset || (kiov->iov_len % regset->size) != 0)
     887                 :            :                 return -EINVAL;
     888                 :            : 
     889                 :            :         regset_no = regset - view->regsets;
     890                 :            :         kiov->iov_len = min(kiov->iov_len,
     891                 :            :                             (__kernel_size_t) (regset->n * regset->size));
     892                 :            : 
     893                 :            :         if (req == PTRACE_GETREGSET)
     894                 :            :                 return copy_regset_to_user(task, view, regset_no, 0,
     895                 :            :                                            kiov->iov_len, kiov->iov_base);
     896                 :            :         else
     897                 :            :                 return copy_regset_from_user(task, view, regset_no, 0,
     898                 :            :                                              kiov->iov_len, kiov->iov_base);
     899                 :            : }
     900                 :            : 
     901                 :            : /*
     902                 :            :  * This is declared in linux/regset.h and defined in machine-dependent
     903                 :            :  * code.  We put the export here, near the primary machine-neutral use,
     904                 :            :  * to ensure no machine forgets it.
     905                 :            :  */
     906                 :            : EXPORT_SYMBOL_GPL(task_user_regset_view);
     907                 :            : 
     908                 :            : static unsigned long
     909                 :          0 : ptrace_get_syscall_info_entry(struct task_struct *child, struct pt_regs *regs,
     910                 :            :                               struct ptrace_syscall_info *info)
     911                 :            : {
     912                 :          0 :         unsigned long args[ARRAY_SIZE(info->entry.args)];
     913                 :          0 :         int i;
     914                 :            : 
     915                 :          0 :         info->op = PTRACE_SYSCALL_INFO_ENTRY;
     916         [ #  # ]:          0 :         info->entry.nr = syscall_get_nr(child, regs);
     917         [ #  # ]:          0 :         syscall_get_arguments(child, regs, args);
     918         [ #  # ]:          0 :         for (i = 0; i < ARRAY_SIZE(args); i++)
     919                 :          0 :                 info->entry.args[i] = args[i];
     920                 :            : 
     921                 :            :         /* args is the last field in struct ptrace_syscall_info.entry */
     922                 :          0 :         return offsetofend(struct ptrace_syscall_info, entry.args);
     923                 :            : }
     924                 :            : 
     925                 :            : static unsigned long
     926                 :          0 : ptrace_get_syscall_info_seccomp(struct task_struct *child, struct pt_regs *regs,
     927                 :            :                                 struct ptrace_syscall_info *info)
     928                 :            : {
     929                 :            :         /*
     930                 :            :          * As struct ptrace_syscall_info.entry is currently a subset
     931                 :            :          * of struct ptrace_syscall_info.seccomp, it makes sense to
     932                 :            :          * initialize that subset using ptrace_get_syscall_info_entry().
     933                 :            :          * This can be reconsidered in the future if these structures
     934                 :            :          * diverge significantly enough.
     935                 :            :          */
     936                 :          0 :         ptrace_get_syscall_info_entry(child, regs, info);
     937                 :          0 :         info->op = PTRACE_SYSCALL_INFO_SECCOMP;
     938                 :          0 :         info->seccomp.ret_data = child->ptrace_message;
     939                 :            : 
     940                 :            :         /* ret_data is the last field in struct ptrace_syscall_info.seccomp */
     941                 :          0 :         return offsetofend(struct ptrace_syscall_info, seccomp.ret_data);
     942                 :            : }
     943                 :            : 
     944                 :            : static unsigned long
     945                 :          0 : ptrace_get_syscall_info_exit(struct task_struct *child, struct pt_regs *regs,
     946                 :            :                              struct ptrace_syscall_info *info)
     947                 :            : {
     948                 :          0 :         info->op = PTRACE_SYSCALL_INFO_EXIT;
     949                 :          0 :         info->exit.rval = syscall_get_error(child, regs);
     950                 :          0 :         info->exit.is_error = !!info->exit.rval;
     951         [ #  # ]:          0 :         if (!info->exit.is_error)
     952                 :          0 :                 info->exit.rval = syscall_get_return_value(child, regs);
     953                 :            : 
     954                 :            :         /* is_error is the last field in struct ptrace_syscall_info.exit */
     955                 :            :         return offsetofend(struct ptrace_syscall_info, exit.is_error);
     956                 :            : }
     957                 :            : 
     958                 :            : static int
     959                 :          0 : ptrace_get_syscall_info(struct task_struct *child, unsigned long user_size,
     960                 :            :                         void __user *datavp)
     961                 :            : {
     962         [ #  # ]:          0 :         struct pt_regs *regs = task_pt_regs(child);
     963         [ #  # ]:          0 :         struct ptrace_syscall_info info = {
     964                 :            :                 .op = PTRACE_SYSCALL_INFO_NONE,
     965                 :          0 :                 .arch = syscall_get_arch(child),
     966         [ #  # ]:          0 :                 .instruction_pointer = instruction_pointer(regs),
     967         [ #  # ]:          0 :                 .stack_pointer = user_stack_pointer(regs),
     968                 :            :         };
     969                 :          0 :         unsigned long actual_size = offsetof(struct ptrace_syscall_info, entry);
     970                 :          0 :         unsigned long write_size;
     971                 :            : 
     972                 :            :         /*
     973                 :            :          * This does not need lock_task_sighand() to access
     974                 :            :          * child->last_siginfo because ptrace_freeze_traced()
     975                 :            :          * called earlier by ptrace_check_attach() ensures that
     976                 :            :          * the tracee cannot go away and clear its last_siginfo.
     977                 :            :          */
     978   [ #  #  #  #  :          0 :         switch (child->last_siginfo ? child->last_siginfo->si_code : 0) {
                      # ]
     979                 :          0 :         case SIGTRAP | 0x80:
     980      [ #  #  # ]:          0 :                 switch (child->ptrace_message) {
     981                 :          0 :                 case PTRACE_EVENTMSG_SYSCALL_ENTRY:
     982                 :          0 :                         actual_size = ptrace_get_syscall_info_entry(child, regs,
     983                 :            :                                                                     &info);
     984                 :          0 :                         break;
     985                 :            :                 case PTRACE_EVENTMSG_SYSCALL_EXIT:
     986         [ #  # ]:          0 :                         actual_size = ptrace_get_syscall_info_exit(child, regs,
     987                 :            :                                                                    &info);
     988                 :            :                         break;
     989                 :            :                 }
     990                 :            :                 break;
     991                 :            :         case SIGTRAP | (PTRACE_EVENT_SECCOMP << 8):
     992                 :          0 :                 actual_size = ptrace_get_syscall_info_seccomp(child, regs,
     993                 :            :                                                               &info);
     994                 :          0 :                 break;
     995                 :            :         }
     996                 :            : 
     997                 :          0 :         write_size = min(actual_size, user_size);
     998   [ #  #  #  # ]:          0 :         return copy_to_user(datavp, &info, write_size) ? -EFAULT : actual_size;
     999                 :            : }
    1000                 :            : #endif /* CONFIG_HAVE_ARCH_TRACEHOOK */
    1001                 :            : 
    1002                 :          0 : int ptrace_request(struct task_struct *child, long request,
    1003                 :            :                    unsigned long addr, unsigned long data)
    1004                 :            : {
    1005                 :          0 :         bool seized = child->ptrace & PT_SEIZED;
    1006                 :          0 :         int ret = -EIO;
    1007                 :          0 :         kernel_siginfo_t siginfo, *si;
    1008                 :          0 :         void __user *datavp = (void __user *) data;
    1009                 :          0 :         unsigned long __user *datalp = datavp;
    1010                 :          0 :         unsigned long flags;
    1011                 :            : 
    1012   [ #  #  #  #  :          0 :         switch (request) {
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    1013                 :            :         case PTRACE_PEEKTEXT:
    1014                 :            :         case PTRACE_PEEKDATA:
    1015                 :          0 :                 return generic_ptrace_peekdata(child, addr, data);
    1016                 :          0 :         case PTRACE_POKETEXT:
    1017                 :            :         case PTRACE_POKEDATA:
    1018                 :          0 :                 return generic_ptrace_pokedata(child, addr, data);
    1019                 :            : 
    1020                 :            : #ifdef PTRACE_OLDSETOPTIONS
    1021                 :            :         case PTRACE_OLDSETOPTIONS:
    1022                 :            : #endif
    1023                 :            :         case PTRACE_SETOPTIONS:
    1024         [ #  # ]:          0 :                 ret = ptrace_setoptions(child, data);
    1025                 :            :                 break;
    1026                 :            :         case PTRACE_GETEVENTMSG:
    1027                 :          0 :                 ret = put_user(child->ptrace_message, datalp);
    1028                 :          0 :                 break;
    1029                 :            : 
    1030                 :          0 :         case PTRACE_PEEKSIGINFO:
    1031                 :          0 :                 ret = ptrace_peek_siginfo(child, addr, data);
    1032                 :          0 :                 break;
    1033                 :            : 
    1034                 :          0 :         case PTRACE_GETSIGINFO:
    1035                 :          0 :                 ret = ptrace_getsiginfo(child, &siginfo);
    1036         [ #  # ]:          0 :                 if (!ret)
    1037                 :          0 :                         ret = copy_siginfo_to_user(datavp, &siginfo);
    1038                 :            :                 break;
    1039                 :            : 
    1040                 :          0 :         case PTRACE_SETSIGINFO:
    1041                 :          0 :                 ret = copy_siginfo_from_user(&siginfo, datavp);
    1042         [ #  # ]:          0 :                 if (!ret)
    1043                 :          0 :                         ret = ptrace_setsiginfo(child, &siginfo);
    1044                 :            :                 break;
    1045                 :            : 
    1046                 :          0 :         case PTRACE_GETSIGMASK: {
    1047                 :          0 :                 sigset_t *mask;
    1048                 :            : 
    1049         [ #  # ]:          0 :                 if (addr != sizeof(sigset_t)) {
    1050                 :            :                         ret = -EINVAL;
    1051                 :            :                         break;
    1052                 :            :                 }
    1053                 :            : 
    1054         [ #  # ]:          0 :                 if (test_tsk_restore_sigmask(child))
    1055                 :          0 :                         mask = &child->saved_sigmask;
    1056                 :            :                 else
    1057                 :          0 :                         mask = &child->blocked;
    1058                 :            : 
    1059   [ #  #  #  # ]:          0 :                 if (copy_to_user(datavp, mask, sizeof(sigset_t)))
    1060                 :            :                         ret = -EFAULT;
    1061                 :            :                 else
    1062                 :          0 :                         ret = 0;
    1063                 :            : 
    1064                 :            :                 break;
    1065                 :            :         }
    1066                 :            : 
    1067                 :          0 :         case PTRACE_SETSIGMASK: {
    1068                 :          0 :                 sigset_t new_set;
    1069                 :            : 
    1070         [ #  # ]:          0 :                 if (addr != sizeof(sigset_t)) {
    1071                 :            :                         ret = -EINVAL;
    1072                 :            :                         break;
    1073                 :            :                 }
    1074                 :            : 
    1075         [ #  # ]:          0 :                 if (copy_from_user(&new_set, datavp, sizeof(sigset_t))) {
    1076                 :            :                         ret = -EFAULT;
    1077                 :            :                         break;
    1078                 :            :                 }
    1079                 :            : 
    1080                 :          0 :                 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
    1081                 :            : 
    1082                 :            :                 /*
    1083                 :            :                  * Every thread does recalc_sigpending() after resume, so
    1084                 :            :                  * retarget_shared_pending() and recalc_sigpending() are not
    1085                 :            :                  * called here.
    1086                 :            :                  */
    1087                 :          0 :                 spin_lock_irq(&child->sighand->siglock);
    1088                 :          0 :                 child->blocked = new_set;
    1089                 :          0 :                 spin_unlock_irq(&child->sighand->siglock);
    1090                 :            : 
    1091                 :          0 :                 clear_tsk_restore_sigmask(child);
    1092                 :            : 
    1093                 :          0 :                 ret = 0;
    1094                 :          0 :                 break;
    1095                 :            :         }
    1096                 :            : 
    1097                 :          0 :         case PTRACE_INTERRUPT:
    1098                 :            :                 /*
    1099                 :            :                  * Stop tracee without any side-effect on signal or job
    1100                 :            :                  * control.  At least one trap is guaranteed to happen
    1101                 :            :                  * after this request.  If @child is already trapped, the
    1102                 :            :                  * current trap is not disturbed and another trap will
    1103                 :            :                  * happen after the current trap is ended with PTRACE_CONT.
    1104                 :            :                  *
    1105                 :            :                  * The actual trap might not be PTRACE_EVENT_STOP trap but
    1106                 :            :                  * the pending condition is cleared regardless.
    1107                 :            :                  */
    1108   [ #  #  #  # ]:          0 :                 if (unlikely(!seized || !lock_task_sighand(child, &flags)))
    1109                 :            :                         break;
    1110                 :            : 
    1111                 :            :                 /*
    1112                 :            :                  * INTERRUPT doesn't disturb existing trap sans one
    1113                 :            :                  * exception.  If ptracer issued LISTEN for the current
    1114                 :            :                  * STOP, this INTERRUPT should clear LISTEN and re-trap
    1115                 :            :                  * tracee into STOP.
    1116                 :            :                  */
    1117         [ #  # ]:          0 :                 if (likely(task_set_jobctl_pending(child, JOBCTL_TRAP_STOP)))
    1118         [ #  # ]:          0 :                         ptrace_signal_wake_up(child, child->jobctl & JOBCTL_LISTENING);
    1119                 :            : 
    1120                 :          0 :                 unlock_task_sighand(child, &flags);
    1121                 :          0 :                 ret = 0;
    1122                 :          0 :                 break;
    1123                 :            : 
    1124                 :          0 :         case PTRACE_LISTEN:
    1125                 :            :                 /*
    1126                 :            :                  * Listen for events.  Tracee must be in STOP.  It's not
    1127                 :            :                  * resumed per-se but is not considered to be in TRACED by
    1128                 :            :                  * wait(2) or ptrace(2).  If an async event (e.g. group
    1129                 :            :                  * stop state change) happens, tracee will enter STOP trap
    1130                 :            :                  * again.  Alternatively, ptracer can issue INTERRUPT to
    1131                 :            :                  * finish listening and re-trap tracee into STOP.
    1132                 :            :                  */
    1133   [ #  #  #  # ]:          0 :                 if (unlikely(!seized || !lock_task_sighand(child, &flags)))
    1134                 :            :                         break;
    1135                 :            : 
    1136                 :          0 :                 si = child->last_siginfo;
    1137   [ #  #  #  # ]:          0 :                 if (likely(si && (si->si_code >> 8) == PTRACE_EVENT_STOP)) {
    1138                 :          0 :                         child->jobctl |= JOBCTL_LISTENING;
    1139                 :            :                         /*
    1140                 :            :                          * If NOTIFY is set, it means event happened between
    1141                 :            :                          * start of this trap and now.  Trigger re-trap.
    1142                 :            :                          */
    1143         [ #  # ]:          0 :                         if (child->jobctl & JOBCTL_TRAP_NOTIFY)
    1144                 :          0 :                                 ptrace_signal_wake_up(child, true);
    1145                 :            :                         ret = 0;
    1146                 :            :                 }
    1147                 :          0 :                 unlock_task_sighand(child, &flags);
    1148                 :            :                 break;
    1149                 :            : 
    1150                 :          0 :         case PTRACE_DETACH:      /* detach a process that was attached. */
    1151                 :          0 :                 ret = ptrace_detach(child, data);
    1152                 :          0 :                 break;
    1153                 :            : 
    1154                 :            : #ifdef CONFIG_BINFMT_ELF_FDPIC
    1155                 :            :         case PTRACE_GETFDPIC: {
    1156                 :            :                 struct mm_struct *mm = get_task_mm(child);
    1157                 :            :                 unsigned long tmp = 0;
    1158                 :            : 
    1159                 :            :                 ret = -ESRCH;
    1160                 :            :                 if (!mm)
    1161                 :            :                         break;
    1162                 :            : 
    1163                 :            :                 switch (addr) {
    1164                 :            :                 case PTRACE_GETFDPIC_EXEC:
    1165                 :            :                         tmp = mm->context.exec_fdpic_loadmap;
    1166                 :            :                         break;
    1167                 :            :                 case PTRACE_GETFDPIC_INTERP:
    1168                 :            :                         tmp = mm->context.interp_fdpic_loadmap;
    1169                 :            :                         break;
    1170                 :            :                 default:
    1171                 :            :                         break;
    1172                 :            :                 }
    1173                 :            :                 mmput(mm);
    1174                 :            : 
    1175                 :            :                 ret = put_user(tmp, datalp);
    1176                 :            :                 break;
    1177                 :            :         }
    1178                 :            : #endif
    1179                 :            : 
    1180                 :            : #ifdef PTRACE_SINGLESTEP
    1181                 :          0 :         case PTRACE_SINGLESTEP:
    1182                 :            : #endif
    1183                 :            : #ifdef PTRACE_SINGLEBLOCK
    1184                 :            :         case PTRACE_SINGLEBLOCK:
    1185                 :            : #endif
    1186                 :            : #ifdef PTRACE_SYSEMU
    1187                 :            :         case PTRACE_SYSEMU:
    1188                 :            :         case PTRACE_SYSEMU_SINGLESTEP:
    1189                 :            : #endif
    1190                 :            :         case PTRACE_SYSCALL:
    1191                 :            :         case PTRACE_CONT:
    1192                 :          0 :                 return ptrace_resume(child, request, data);
    1193                 :            : 
    1194                 :          0 :         case PTRACE_KILL:
    1195         [ #  # ]:          0 :                 if (child->exit_state)       /* already dead */
    1196                 :            :                         return 0;
    1197                 :          0 :                 return ptrace_resume(child, request, SIGKILL);
    1198                 :            : 
    1199                 :            : #ifdef CONFIG_HAVE_ARCH_TRACEHOOK
    1200                 :          0 :         case PTRACE_GETREGSET:
    1201                 :            :         case PTRACE_SETREGSET: {
    1202                 :          0 :                 struct iovec kiov;
    1203                 :          0 :                 struct iovec __user *uiov = datavp;
    1204                 :            : 
    1205         [ #  # ]:          0 :                 if (!access_ok(uiov, sizeof(*uiov)))
    1206                 :          0 :                         return -EFAULT;
    1207                 :            : 
    1208         [ #  # ]:          0 :                 if (__get_user(kiov.iov_base, &uiov->iov_base) ||
    1209         [ #  # ]:          0 :                     __get_user(kiov.iov_len, &uiov->iov_len))
    1210                 :          0 :                         return -EFAULT;
    1211                 :            : 
    1212                 :          0 :                 ret = ptrace_regset(child, request, addr, &kiov);
    1213         [ #  # ]:          0 :                 if (!ret)
    1214         [ #  # ]:          0 :                         ret = __put_user(kiov.iov_len, &uiov->iov_len);
    1215                 :          0 :                 break;
    1216                 :            :         }
    1217                 :            : 
    1218                 :          0 :         case PTRACE_GET_SYSCALL_INFO:
    1219                 :          0 :                 ret = ptrace_get_syscall_info(child, addr, datavp);
    1220                 :          0 :                 break;
    1221                 :            : #endif
    1222                 :            : 
    1223                 :            :         case PTRACE_SECCOMP_GET_FILTER:
    1224                 :          0 :                 ret = seccomp_get_filter(child, addr, datavp);
    1225                 :          0 :                 break;
    1226                 :            : 
    1227                 :            :         case PTRACE_SECCOMP_GET_METADATA:
    1228                 :          0 :                 ret = seccomp_get_metadata(child, addr, datavp);
    1229                 :          0 :                 break;
    1230                 :            : 
    1231                 :            :         default:
    1232                 :            :                 break;
    1233                 :            :         }
    1234                 :            : 
    1235                 :          0 :         return ret;
    1236                 :            : }
    1237                 :            : 
    1238                 :            : #ifndef arch_ptrace_attach
    1239                 :            : #define arch_ptrace_attach(child)       do { } while (0)
    1240                 :            : #endif
    1241                 :            : 
    1242                 :          0 : SYSCALL_DEFINE4(ptrace, long, request, long, pid, unsigned long, addr,
    1243                 :            :                 unsigned long, data)
    1244                 :            : {
    1245                 :          0 :         struct task_struct *child;
    1246                 :          0 :         long ret;
    1247                 :            : 
    1248         [ #  # ]:          0 :         if (request == PTRACE_TRACEME) {
    1249                 :          0 :                 ret = ptrace_traceme();
    1250                 :          0 :                 if (!ret)
    1251                 :          0 :                         arch_ptrace_attach(current);
    1252                 :          0 :                 goto out;
    1253                 :            :         }
    1254                 :            : 
    1255                 :          0 :         child = find_get_task_by_vpid(pid);
    1256         [ #  # ]:          0 :         if (!child) {
    1257                 :          0 :                 ret = -ESRCH;
    1258                 :          0 :                 goto out;
    1259                 :            :         }
    1260                 :            : 
    1261         [ #  # ]:          0 :         if (request == PTRACE_ATTACH || request == PTRACE_SEIZE) {
    1262                 :          0 :                 ret = ptrace_attach(child, request, addr, data);
    1263                 :            :                 /*
    1264                 :            :                  * Some architectures need to do book-keeping after
    1265                 :            :                  * a ptrace attach.
    1266                 :            :                  */
    1267                 :          0 :                 if (!ret)
    1268                 :          0 :                         arch_ptrace_attach(child);
    1269                 :          0 :                 goto out_put_task_struct;
    1270                 :            :         }
    1271                 :            : 
    1272                 :          0 :         ret = ptrace_check_attach(child, request == PTRACE_KILL ||
    1273                 :          0 :                                   request == PTRACE_INTERRUPT);
    1274         [ #  # ]:          0 :         if (ret < 0)
    1275                 :          0 :                 goto out_put_task_struct;
    1276                 :            : 
    1277                 :          0 :         ret = arch_ptrace(child, request, addr, data);
    1278         [ #  # ]:          0 :         if (ret || request != PTRACE_DETACH)
    1279                 :          0 :                 ptrace_unfreeze_traced(child);
    1280                 :            : 
    1281                 :          0 :  out_put_task_struct:
    1282                 :          0 :         put_task_struct(child);
    1283                 :          0 :  out:
    1284                 :          0 :         return ret;
    1285                 :            : }
    1286                 :            : 
    1287                 :          0 : int generic_ptrace_peekdata(struct task_struct *tsk, unsigned long addr,
    1288                 :            :                             unsigned long data)
    1289                 :            : {
    1290                 :          0 :         unsigned long tmp;
    1291                 :          0 :         int copied;
    1292                 :            : 
    1293                 :          0 :         copied = ptrace_access_vm(tsk, addr, &tmp, sizeof(tmp), FOLL_FORCE);
    1294   [ #  #  #  # ]:          0 :         if (copied != sizeof(tmp))
    1295                 :            :                 return -EIO;
    1296                 :          0 :         return put_user(tmp, (unsigned long __user *)data);
    1297                 :            : }
    1298                 :            : 
    1299                 :          0 : int generic_ptrace_pokedata(struct task_struct *tsk, unsigned long addr,
    1300                 :            :                             unsigned long data)
    1301                 :            : {
    1302                 :          0 :         int copied;
    1303                 :            : 
    1304                 :          0 :         copied = ptrace_access_vm(tsk, addr, &data, sizeof(data),
    1305                 :            :                         FOLL_FORCE | FOLL_WRITE);
    1306   [ #  #  #  # ]:          0 :         return (copied == sizeof(data)) ? 0 : -EIO;
    1307                 :            : }
    1308                 :            : 
    1309                 :            : #if defined CONFIG_COMPAT
    1310                 :            : 
    1311                 :          0 : int compat_ptrace_request(struct task_struct *child, compat_long_t request,
    1312                 :            :                           compat_ulong_t addr, compat_ulong_t data)
    1313                 :            : {
    1314   [ #  #  #  #  :          0 :         compat_ulong_t __user *datap = compat_ptr(data);
                #  #  # ]
    1315                 :          0 :         compat_ulong_t word;
    1316                 :          0 :         kernel_siginfo_t siginfo;
    1317                 :          0 :         int ret;
    1318                 :            : 
    1319   [ #  #  #  #  :          0 :         switch (request) {
                #  #  # ]
    1320                 :          0 :         case PTRACE_PEEKTEXT:
    1321                 :            :         case PTRACE_PEEKDATA:
    1322                 :          0 :                 ret = ptrace_access_vm(child, addr, &word, sizeof(word),
    1323                 :            :                                 FOLL_FORCE);
    1324         [ #  # ]:          0 :                 if (ret != sizeof(word))
    1325                 :            :                         ret = -EIO;
    1326                 :            :                 else
    1327                 :          0 :                         ret = put_user(word, datap);
    1328                 :            :                 break;
    1329                 :            : 
    1330                 :          0 :         case PTRACE_POKETEXT:
    1331                 :            :         case PTRACE_POKEDATA:
    1332                 :          0 :                 ret = ptrace_access_vm(child, addr, &data, sizeof(data),
    1333                 :            :                                 FOLL_FORCE | FOLL_WRITE);
    1334         [ #  # ]:          0 :                 ret = (ret != sizeof(data) ? -EIO : 0);
    1335                 :            :                 break;
    1336                 :            : 
    1337                 :            :         case PTRACE_GETEVENTMSG:
    1338                 :          0 :                 ret = put_user((compat_ulong_t) child->ptrace_message, datap);
    1339                 :          0 :                 break;
    1340                 :            : 
    1341                 :          0 :         case PTRACE_GETSIGINFO:
    1342                 :          0 :                 ret = ptrace_getsiginfo(child, &siginfo);
    1343         [ #  # ]:          0 :                 if (!ret)
    1344                 :          0 :                         ret = copy_siginfo_to_user32(
    1345                 :            :                                 (struct compat_siginfo __user *) datap,
    1346                 :            :                                 &siginfo);
    1347                 :            :                 break;
    1348                 :            : 
    1349                 :          0 :         case PTRACE_SETSIGINFO:
    1350                 :          0 :                 ret = copy_siginfo_from_user32(
    1351                 :            :                         &siginfo, (struct compat_siginfo __user *) datap);
    1352         [ #  # ]:          0 :                 if (!ret)
    1353                 :          0 :                         ret = ptrace_setsiginfo(child, &siginfo);
    1354                 :            :                 break;
    1355                 :            : #ifdef CONFIG_HAVE_ARCH_TRACEHOOK
    1356                 :          0 :         case PTRACE_GETREGSET:
    1357                 :            :         case PTRACE_SETREGSET:
    1358                 :            :         {
    1359                 :          0 :                 struct iovec kiov;
    1360                 :          0 :                 struct compat_iovec __user *uiov =
    1361                 :            :                         (struct compat_iovec __user *) datap;
    1362                 :          0 :                 compat_uptr_t ptr;
    1363                 :          0 :                 compat_size_t len;
    1364                 :            : 
    1365         [ #  # ]:          0 :                 if (!access_ok(uiov, sizeof(*uiov)))
    1366                 :          0 :                         return -EFAULT;
    1367                 :            : 
    1368         [ #  # ]:          0 :                 if (__get_user(ptr, &uiov->iov_base) ||
    1369         [ #  # ]:          0 :                     __get_user(len, &uiov->iov_len))
    1370                 :          0 :                         return -EFAULT;
    1371                 :            : 
    1372                 :          0 :                 kiov.iov_base = compat_ptr(ptr);
    1373                 :          0 :                 kiov.iov_len = len;
    1374                 :            : 
    1375                 :          0 :                 ret = ptrace_regset(child, request, addr, &kiov);
    1376         [ #  # ]:          0 :                 if (!ret)
    1377         [ #  # ]:          0 :                         ret = __put_user(kiov.iov_len, &uiov->iov_len);
    1378                 :          0 :                 break;
    1379                 :            :         }
    1380                 :            : #endif
    1381                 :            : 
    1382                 :          0 :         default:
    1383                 :          0 :                 ret = ptrace_request(child, request, addr, data);
    1384                 :            :         }
    1385                 :            : 
    1386                 :            :         return ret;
    1387                 :            : }
    1388                 :            : 
    1389                 :          0 : COMPAT_SYSCALL_DEFINE4(ptrace, compat_long_t, request, compat_long_t, pid,
    1390                 :            :                        compat_long_t, addr, compat_long_t, data)
    1391                 :            : {
    1392                 :          0 :         struct task_struct *child;
    1393                 :          0 :         long ret;
    1394                 :            : 
    1395         [ #  # ]:          0 :         if (request == PTRACE_TRACEME) {
    1396                 :          0 :                 ret = ptrace_traceme();
    1397                 :          0 :                 goto out;
    1398                 :            :         }
    1399                 :            : 
    1400                 :          0 :         child = find_get_task_by_vpid(pid);
    1401         [ #  # ]:          0 :         if (!child) {
    1402                 :          0 :                 ret = -ESRCH;
    1403                 :          0 :                 goto out;
    1404                 :            :         }
    1405                 :            : 
    1406         [ #  # ]:          0 :         if (request == PTRACE_ATTACH || request == PTRACE_SEIZE) {
    1407                 :          0 :                 ret = ptrace_attach(child, request, addr, data);
    1408                 :            :                 /*
    1409                 :            :                  * Some architectures need to do book-keeping after
    1410                 :            :                  * a ptrace attach.
    1411                 :            :                  */
    1412                 :          0 :                 if (!ret)
    1413                 :          0 :                         arch_ptrace_attach(child);
    1414                 :          0 :                 goto out_put_task_struct;
    1415                 :            :         }
    1416                 :            : 
    1417                 :          0 :         ret = ptrace_check_attach(child, request == PTRACE_KILL ||
    1418                 :          0 :                                   request == PTRACE_INTERRUPT);
    1419         [ #  # ]:          0 :         if (!ret) {
    1420                 :          0 :                 ret = compat_arch_ptrace(child, request, addr, data);
    1421         [ #  # ]:          0 :                 if (ret || request != PTRACE_DETACH)
    1422                 :          0 :                         ptrace_unfreeze_traced(child);
    1423                 :            :         }
    1424                 :            : 
    1425                 :          0 :  out_put_task_struct:
    1426                 :          0 :         put_task_struct(child);
    1427                 :          0 :  out:
    1428                 :          0 :         return ret;
    1429                 :            : }
    1430                 :            : #endif  /* CONFIG_COMPAT */

Generated by: LCOV version 1.14