LCOV - code coverage report
Current view: top level - kernel/events - uprobes.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 51 1035 4.9 %
Date: 2022-03-28 13:20:08 Functions: 12 74 16.2 %
Branches: 16 660 2.4 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0+
       2                 :            : /*
       3                 :            :  * User-space Probes (UProbes)
       4                 :            :  *
       5                 :            :  * Copyright (C) IBM Corporation, 2008-2012
       6                 :            :  * Authors:
       7                 :            :  *      Srikar Dronamraju
       8                 :            :  *      Jim Keniston
       9                 :            :  * Copyright (C) 2011-2012 Red Hat, Inc., Peter Zijlstra
      10                 :            :  */
      11                 :            : 
      12                 :            : #include <linux/kernel.h>
      13                 :            : #include <linux/highmem.h>
      14                 :            : #include <linux/pagemap.h>        /* read_mapping_page */
      15                 :            : #include <linux/slab.h>
      16                 :            : #include <linux/sched.h>
      17                 :            : #include <linux/sched/mm.h>
      18                 :            : #include <linux/sched/coredump.h>
      19                 :            : #include <linux/export.h>
      20                 :            : #include <linux/rmap.h>           /* anon_vma_prepare */
      21                 :            : #include <linux/mmu_notifier.h>   /* set_pte_at_notify */
      22                 :            : #include <linux/swap.h>           /* try_to_free_swap */
      23                 :            : #include <linux/ptrace.h> /* user_enable_single_step */
      24                 :            : #include <linux/kdebug.h> /* notifier mechanism */
      25                 :            : #include "../../mm/internal.h"        /* munlock_vma_page */
      26                 :            : #include <linux/percpu-rwsem.h>
      27                 :            : #include <linux/task_work.h>
      28                 :            : #include <linux/shmem_fs.h>
      29                 :            : #include <linux/khugepaged.h>
      30                 :            : 
      31                 :            : #include <linux/uprobes.h>
      32                 :            : 
      33                 :            : #define UINSNS_PER_PAGE                 (PAGE_SIZE/UPROBE_XOL_SLOT_BYTES)
      34                 :            : #define MAX_UPROBE_XOL_SLOTS            UINSNS_PER_PAGE
      35                 :            : 
      36                 :            : static struct rb_root uprobes_tree = RB_ROOT;
      37                 :            : /*
      38                 :            :  * allows us to skip the uprobe_mmap if there are no uprobe events active
      39                 :            :  * at this time.  Probably a fine grained per inode count is better?
      40                 :            :  */
      41                 :            : #define no_uprobe_events()      RB_EMPTY_ROOT(&uprobes_tree)
      42                 :            : 
      43                 :            : static DEFINE_SPINLOCK(uprobes_treelock);       /* serialize rbtree access */
      44                 :            : 
      45                 :            : #define UPROBES_HASH_SZ 13
      46                 :            : /* serialize uprobe->pending_list */
      47                 :            : static struct mutex uprobes_mmap_mutex[UPROBES_HASH_SZ];
      48                 :            : #define uprobes_mmap_hash(v)    (&uprobes_mmap_mutex[((unsigned long)(v)) % UPROBES_HASH_SZ])
      49                 :            : 
      50                 :            : DEFINE_STATIC_PERCPU_RWSEM(dup_mmap_sem);
      51                 :            : 
      52                 :            : /* Have a copy of original instruction */
      53                 :            : #define UPROBE_COPY_INSN        0
      54                 :            : 
      55                 :            : struct uprobe {
      56                 :            :         struct rb_node          rb_node;        /* node in the rb tree */
      57                 :            :         refcount_t              ref;
      58                 :            :         struct rw_semaphore     register_rwsem;
      59                 :            :         struct rw_semaphore     consumer_rwsem;
      60                 :            :         struct list_head        pending_list;
      61                 :            :         struct uprobe_consumer  *consumers;
      62                 :            :         struct inode            *inode;         /* Also hold a ref to inode */
      63                 :            :         loff_t                  offset;
      64                 :            :         loff_t                  ref_ctr_offset;
      65                 :            :         unsigned long           flags;
      66                 :            : 
      67                 :            :         /*
      68                 :            :          * The generic code assumes that it has two members of unknown type
      69                 :            :          * owned by the arch-specific code:
      70                 :            :          *
      71                 :            :          *      insn -  copy_insn() saves the original instruction here for
      72                 :            :          *              arch_uprobe_analyze_insn().
      73                 :            :          *
      74                 :            :          *      ixol -  potentially modified instruction to execute out of
      75                 :            :          *              line, copied to xol_area by xol_get_insn_slot().
      76                 :            :          */
      77                 :            :         struct arch_uprobe      arch;
      78                 :            : };
      79                 :            : 
      80                 :            : struct delayed_uprobe {
      81                 :            :         struct list_head list;
      82                 :            :         struct uprobe *uprobe;
      83                 :            :         struct mm_struct *mm;
      84                 :            : };
      85                 :            : 
      86                 :            : static DEFINE_MUTEX(delayed_uprobe_lock);
      87                 :            : static LIST_HEAD(delayed_uprobe_list);
      88                 :            : 
      89                 :            : /*
      90                 :            :  * Execute out of line area: anonymous executable mapping installed
      91                 :            :  * by the probed task to execute the copy of the original instruction
      92                 :            :  * mangled by set_swbp().
      93                 :            :  *
      94                 :            :  * On a breakpoint hit, thread contests for a slot.  It frees the
      95                 :            :  * slot after singlestep. Currently a fixed number of slots are
      96                 :            :  * allocated.
      97                 :            :  */
      98                 :            : struct xol_area {
      99                 :            :         wait_queue_head_t               wq;             /* if all slots are busy */
     100                 :            :         atomic_t                        slot_count;     /* number of in-use slots */
     101                 :            :         unsigned long                   *bitmap;        /* 0 = free slot */
     102                 :            : 
     103                 :            :         struct vm_special_mapping       xol_mapping;
     104                 :            :         struct page                     *pages[2];
     105                 :            :         /*
     106                 :            :          * We keep the vma's vm_start rather than a pointer to the vma
     107                 :            :          * itself.  The probed process or a naughty kernel module could make
     108                 :            :          * the vma go away, and we must handle that reasonably gracefully.
     109                 :            :          */
     110                 :            :         unsigned long                   vaddr;          /* Page(s) of instruction slots */
     111                 :            : };
     112                 :            : 
     113                 :            : /*
     114                 :            :  * valid_vma: Verify if the specified vma is an executable vma
     115                 :            :  * Relax restrictions while unregistering: vm_flags might have
     116                 :            :  * changed after breakpoint was inserted.
     117                 :            :  *      - is_register: indicates if we are in register context.
     118                 :            :  *      - Return 1 if the specified virtual address is in an
     119                 :            :  *        executable vma.
     120                 :            :  */
     121                 :          0 : static bool valid_vma(struct vm_area_struct *vma, bool is_register)
     122                 :            : {
     123                 :          0 :         vm_flags_t flags = VM_HUGETLB | VM_MAYEXEC | VM_MAYSHARE;
     124                 :            : 
     125         [ #  # ]:          0 :         if (is_register)
     126                 :          0 :                 flags |= VM_WRITE;
     127                 :            : 
     128   [ #  #  #  #  :          0 :         return vma->vm_file && (vma->vm_flags & flags) == VM_MAYEXEC;
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                      # ]
     129                 :            : }
     130                 :            : 
     131                 :          0 : static unsigned long offset_to_vaddr(struct vm_area_struct *vma, loff_t offset)
     132                 :            : {
     133                 :          0 :         return vma->vm_start + offset - ((loff_t)vma->vm_pgoff << PAGE_SHIFT);
     134                 :            : }
     135                 :            : 
     136                 :          0 : static loff_t vaddr_to_offset(struct vm_area_struct *vma, unsigned long vaddr)
     137                 :            : {
     138                 :          0 :         return ((loff_t)vma->vm_pgoff << PAGE_SHIFT) + (vaddr - vma->vm_start);
     139                 :            : }
     140                 :            : 
     141                 :            : /**
     142                 :            :  * __replace_page - replace page in vma by new page.
     143                 :            :  * based on replace_page in mm/ksm.c
     144                 :            :  *
     145                 :            :  * @vma:      vma that holds the pte pointing to page
     146                 :            :  * @addr:     address the old @page is mapped at
     147                 :            :  * @old_page: the page we are replacing by new_page
     148                 :            :  * @new_page: the modified page we replace page by
     149                 :            :  *
     150                 :            :  * If @new_page is NULL, only unmap @old_page.
     151                 :            :  *
     152                 :            :  * Returns 0 on success, negative error code otherwise.
     153                 :            :  */
     154                 :          0 : static int __replace_page(struct vm_area_struct *vma, unsigned long addr,
     155                 :            :                                 struct page *old_page, struct page *new_page)
     156                 :            : {
     157                 :          0 :         struct mm_struct *mm = vma->vm_mm;
     158         [ #  # ]:          0 :         struct page_vma_mapped_walk pvmw = {
     159                 :            :                 .page = compound_head(old_page),
     160                 :            :                 .vma = vma,
     161                 :            :                 .address = addr,
     162                 :            :         };
     163                 :          0 :         int err;
     164                 :          0 :         struct mmu_notifier_range range;
     165                 :          0 :         struct mem_cgroup *memcg;
     166                 :            : 
     167                 :          0 :         mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, vma, mm, addr,
     168                 :            :                                 addr + PAGE_SIZE);
     169                 :            : 
     170                 :          0 :         if (new_page) {
     171                 :            :                 err = mem_cgroup_try_charge(new_page, vma->vm_mm, GFP_KERNEL,
     172                 :            :                                             &memcg, false);
     173                 :            :                 if (err)
     174                 :            :                         return err;
     175                 :            :         }
     176                 :            : 
     177                 :            :         /* For try_to_free_swap() and munlock_vma_page() below */
     178                 :          0 :         lock_page(old_page);
     179                 :            : 
     180                 :          0 :         mmu_notifier_invalidate_range_start(&range);
     181                 :          0 :         err = -EAGAIN;
     182         [ #  # ]:          0 :         if (!page_vma_mapped_walk(&pvmw)) {
     183                 :          0 :                 if (new_page)
     184                 :            :                         mem_cgroup_cancel_charge(new_page, memcg, false);
     185                 :          0 :                 goto unlock;
     186                 :            :         }
     187                 :          0 :         VM_BUG_ON_PAGE(addr != pvmw.address, old_page);
     188                 :            : 
     189         [ #  # ]:          0 :         if (new_page) {
     190         [ #  # ]:          0 :                 get_page(new_page);
     191                 :          0 :                 page_add_new_anon_rmap(new_page, vma, addr, false);
     192                 :          0 :                 mem_cgroup_commit_charge(new_page, memcg, false, false);
     193                 :          0 :                 lru_cache_add_active_or_unevictable(new_page, vma);
     194                 :            :         } else
     195                 :            :                 /* no new page, just dec_mm_counter for old_page */
     196                 :          0 :                 dec_mm_counter(mm, MM_ANONPAGES);
     197                 :            : 
     198   [ #  #  #  # ]:          0 :         if (!PageAnon(old_page)) {
     199                 :          0 :                 dec_mm_counter(mm, mm_counter_file(old_page));
     200                 :          0 :                 inc_mm_counter(mm, MM_ANONPAGES);
     201                 :            :         }
     202                 :            : 
     203                 :          0 :         flush_cache_page(vma, addr, pte_pfn(*pvmw.pte));
     204         [ #  # ]:          0 :         ptep_clear_flush_notify(vma, addr, pvmw.pte);
     205         [ #  # ]:          0 :         if (new_page)
     206   [ #  #  #  # ]:          0 :                 set_pte_at_notify(mm, addr, pvmw.pte,
     207                 :            :                                   mk_pte(new_page, vma->vm_page_prot));
     208                 :            : 
     209                 :          0 :         page_remove_rmap(old_page, false);
     210         [ #  # ]:          0 :         if (!page_mapped(old_page))
     211                 :          0 :                 try_to_free_swap(old_page);
     212         [ #  # ]:          0 :         page_vma_mapped_walk_done(&pvmw);
     213                 :            : 
     214         [ #  # ]:          0 :         if (vma->vm_flags & VM_LOCKED)
     215                 :          0 :                 munlock_vma_page(old_page);
     216                 :          0 :         put_page(old_page);
     217                 :            : 
     218                 :          0 :         err = 0;
     219                 :          0 :  unlock:
     220                 :          0 :         mmu_notifier_invalidate_range_end(&range);
     221                 :          0 :         unlock_page(old_page);
     222                 :          0 :         return err;
     223                 :            : }
     224                 :            : 
     225                 :            : /**
     226                 :            :  * is_swbp_insn - check if instruction is breakpoint instruction.
     227                 :            :  * @insn: instruction to be checked.
     228                 :            :  * Default implementation of is_swbp_insn
     229                 :            :  * Returns true if @insn is a breakpoint instruction.
     230                 :            :  */
     231                 :          0 : bool __weak is_swbp_insn(uprobe_opcode_t *insn)
     232                 :            : {
     233                 :          0 :         return *insn == UPROBE_SWBP_INSN;
     234                 :            : }
     235                 :            : 
     236                 :            : /**
     237                 :            :  * is_trap_insn - check if instruction is breakpoint instruction.
     238                 :            :  * @insn: instruction to be checked.
     239                 :            :  * Default implementation of is_trap_insn
     240                 :            :  * Returns true if @insn is a breakpoint instruction.
     241                 :            :  *
     242                 :            :  * This function is needed for the case where an architecture has multiple
     243                 :            :  * trap instructions (like powerpc).
     244                 :            :  */
     245                 :          0 : bool __weak is_trap_insn(uprobe_opcode_t *insn)
     246                 :            : {
     247                 :          0 :         return is_swbp_insn(insn);
     248                 :            : }
     249                 :            : 
     250                 :          0 : static void copy_from_page(struct page *page, unsigned long vaddr, void *dst, int len)
     251                 :            : {
     252                 :          0 :         void *kaddr = kmap_atomic(page);
     253                 :          0 :         memcpy(dst, kaddr + (vaddr & ~PAGE_MASK), len);
     254                 :          0 :         kunmap_atomic(kaddr);
     255                 :          0 : }
     256                 :            : 
     257                 :          0 : static void copy_to_page(struct page *page, unsigned long vaddr, const void *src, int len)
     258                 :            : {
     259                 :          0 :         void *kaddr = kmap_atomic(page);
     260                 :          0 :         memcpy(kaddr + (vaddr & ~PAGE_MASK), src, len);
     261                 :          0 :         kunmap_atomic(kaddr);
     262                 :          0 : }
     263                 :            : 
     264                 :          0 : static int verify_opcode(struct page *page, unsigned long vaddr, uprobe_opcode_t *new_opcode)
     265                 :            : {
     266                 :          0 :         uprobe_opcode_t old_opcode;
     267                 :          0 :         bool is_swbp;
     268                 :            : 
     269                 :            :         /*
     270                 :            :          * Note: We only check if the old_opcode is UPROBE_SWBP_INSN here.
     271                 :            :          * We do not check if it is any other 'trap variant' which could
     272                 :            :          * be conditional trap instruction such as the one powerpc supports.
     273                 :            :          *
     274                 :            :          * The logic is that we do not care if the underlying instruction
     275                 :            :          * is a trap variant; uprobes always wins over any other (gdb)
     276                 :            :          * breakpoint.
     277                 :            :          */
     278                 :          0 :         copy_from_page(page, vaddr, &old_opcode, UPROBE_SWBP_INSN_SIZE);
     279                 :          0 :         is_swbp = is_swbp_insn(&old_opcode);
     280                 :            : 
     281         [ #  # ]:          0 :         if (is_swbp_insn(new_opcode)) {
     282         [ #  # ]:          0 :                 if (is_swbp)            /* register: already installed? */
     283                 :          0 :                         return 0;
     284                 :            :         } else {
     285         [ #  # ]:          0 :                 if (!is_swbp)           /* unregister: was it changed by us? */
     286                 :          0 :                         return 0;
     287                 :            :         }
     288                 :            : 
     289                 :            :         return 1;
     290                 :            : }
     291                 :            : 
     292                 :            : static struct delayed_uprobe *
     293                 :          0 : delayed_uprobe_check(struct uprobe *uprobe, struct mm_struct *mm)
     294                 :            : {
     295                 :          0 :         struct delayed_uprobe *du;
     296                 :            : 
     297         [ #  # ]:          0 :         list_for_each_entry(du, &delayed_uprobe_list, list)
     298   [ #  #  #  # ]:          0 :                 if (du->uprobe == uprobe && du->mm == mm)
     299                 :            :                         return du;
     300                 :            :         return NULL;
     301                 :            : }
     302                 :            : 
     303                 :          0 : static int delayed_uprobe_add(struct uprobe *uprobe, struct mm_struct *mm)
     304                 :            : {
     305                 :          0 :         struct delayed_uprobe *du;
     306                 :            : 
     307         [ #  # ]:          0 :         if (delayed_uprobe_check(uprobe, mm))
     308                 :            :                 return 0;
     309                 :            : 
     310                 :          0 :         du  = kzalloc(sizeof(*du), GFP_KERNEL);
     311         [ #  # ]:          0 :         if (!du)
     312                 :            :                 return -ENOMEM;
     313                 :            : 
     314                 :          0 :         du->uprobe = uprobe;
     315                 :          0 :         du->mm = mm;
     316                 :          0 :         list_add(&du->list, &delayed_uprobe_list);
     317                 :          0 :         return 0;
     318                 :            : }
     319                 :            : 
     320                 :          0 : static void delayed_uprobe_delete(struct delayed_uprobe *du)
     321                 :            : {
     322   [ #  #  #  # ]:          0 :         if (WARN_ON(!du))
     323                 :            :                 return;
     324                 :          0 :         list_del(&du->list);
     325                 :          0 :         kfree(du);
     326                 :            : }
     327                 :            : 
     328                 :      44820 : static void delayed_uprobe_remove(struct uprobe *uprobe, struct mm_struct *mm)
     329                 :            : {
     330                 :      44820 :         struct list_head *pos, *q;
     331                 :      44820 :         struct delayed_uprobe *du;
     332                 :            : 
     333         [ +  - ]:      44820 :         if (!uprobe && !mm)
     334                 :            :                 return;
     335                 :            : 
     336         [ -  + ]:      44820 :         list_for_each_safe(pos, q, &delayed_uprobe_list) {
     337                 :          0 :                 du = list_entry(pos, struct delayed_uprobe, list);
     338                 :            : 
     339   [ #  #  #  # ]:          0 :                 if (uprobe && du->uprobe != uprobe)
     340                 :          0 :                         continue;
     341   [ #  #  #  # ]:          0 :                 if (mm && du->mm != mm)
     342                 :          0 :                         continue;
     343                 :            : 
     344                 :          0 :                 delayed_uprobe_delete(du);
     345                 :            :         }
     346                 :            : }
     347                 :            : 
     348                 :            : static bool valid_ref_ctr_vma(struct uprobe *uprobe,
     349                 :            :                               struct vm_area_struct *vma)
     350                 :            : {
     351                 :            :         unsigned long vaddr = offset_to_vaddr(vma, uprobe->ref_ctr_offset);
     352                 :            : 
     353                 :            :         return uprobe->ref_ctr_offset &&
     354                 :            :                 vma->vm_file &&
     355                 :            :                 file_inode(vma->vm_file) == uprobe->inode &&
     356                 :            :                 (vma->vm_flags & (VM_WRITE|VM_SHARED)) == VM_WRITE &&
     357                 :            :                 vma->vm_start <= vaddr &&
     358                 :            :                 vma->vm_end > vaddr;
     359                 :            : }
     360                 :            : 
     361                 :            : static struct vm_area_struct *
     362                 :          0 : find_ref_ctr_vma(struct uprobe *uprobe, struct mm_struct *mm)
     363                 :            : {
     364                 :          0 :         struct vm_area_struct *tmp;
     365                 :            : 
     366         [ #  # ]:          0 :         for (tmp = mm->mmap; tmp; tmp = tmp->vm_next)
     367         [ #  # ]:          0 :                 if (valid_ref_ctr_vma(uprobe, tmp))
     368                 :          0 :                         return tmp;
     369                 :            : 
     370                 :            :         return NULL;
     371                 :            : }
     372                 :            : 
     373                 :            : static int
     374                 :          0 : __update_ref_ctr(struct mm_struct *mm, unsigned long vaddr, short d)
     375                 :            : {
     376                 :          0 :         void *kaddr;
     377                 :          0 :         struct page *page;
     378                 :          0 :         struct vm_area_struct *vma;
     379                 :          0 :         int ret;
     380                 :          0 :         short *ptr;
     381                 :            : 
     382         [ #  # ]:          0 :         if (!vaddr || !d)
     383                 :            :                 return -EINVAL;
     384                 :            : 
     385                 :          0 :         ret = get_user_pages_remote(NULL, mm, vaddr, 1,
     386                 :            :                         FOLL_WRITE, &page, &vma, NULL);
     387         [ #  # ]:          0 :         if (unlikely(ret <= 0)) {
     388                 :            :                 /*
     389                 :            :                  * We are asking for 1 page. If get_user_pages_remote() fails,
     390                 :            :                  * it may return 0, in that case we have to return error.
     391                 :            :                  */
     392         [ #  # ]:          0 :                 return ret == 0 ? -EBUSY : ret;
     393                 :            :         }
     394                 :            : 
     395                 :          0 :         kaddr = kmap_atomic(page);
     396                 :          0 :         ptr = kaddr + (vaddr & ~PAGE_MASK);
     397                 :            : 
     398         [ #  # ]:          0 :         if (unlikely(*ptr + d < 0)) {
     399                 :          0 :                 pr_warn("ref_ctr going negative. vaddr: 0x%lx, "
     400                 :            :                         "curr val: %d, delta: %d\n", vaddr, *ptr, d);
     401                 :          0 :                 ret = -EINVAL;
     402                 :          0 :                 goto out;
     403                 :            :         }
     404                 :            : 
     405                 :          0 :         *ptr += d;
     406                 :          0 :         ret = 0;
     407                 :          0 : out:
     408                 :          0 :         kunmap_atomic(kaddr);
     409                 :          0 :         put_page(page);
     410                 :          0 :         return ret;
     411                 :            : }
     412                 :            : 
     413                 :          0 : static void update_ref_ctr_warn(struct uprobe *uprobe,
     414                 :            :                                 struct mm_struct *mm, short d)
     415                 :            : {
     416         [ #  # ]:          0 :         pr_warn("ref_ctr %s failed for inode: 0x%lx offset: "
     417                 :            :                 "0x%llx ref_ctr_offset: 0x%llx of mm: 0x%pK\n",
     418                 :            :                 d > 0 ? "increment" : "decrement", uprobe->inode->i_ino,
     419                 :            :                 (unsigned long long) uprobe->offset,
     420                 :            :                 (unsigned long long) uprobe->ref_ctr_offset, mm);
     421                 :          0 : }
     422                 :            : 
     423                 :          0 : static int update_ref_ctr(struct uprobe *uprobe, struct mm_struct *mm,
     424                 :            :                           short d)
     425                 :            : {
     426                 :          0 :         struct vm_area_struct *rc_vma;
     427                 :          0 :         unsigned long rc_vaddr;
     428                 :          0 :         int ret = 0;
     429                 :            : 
     430                 :          0 :         rc_vma = find_ref_ctr_vma(uprobe, mm);
     431                 :            : 
     432         [ #  # ]:          0 :         if (rc_vma) {
     433                 :          0 :                 rc_vaddr = offset_to_vaddr(rc_vma, uprobe->ref_ctr_offset);
     434                 :          0 :                 ret = __update_ref_ctr(mm, rc_vaddr, d);
     435         [ #  # ]:          0 :                 if (ret)
     436                 :          0 :                         update_ref_ctr_warn(uprobe, mm, d);
     437                 :            : 
     438         [ #  # ]:          0 :                 if (d > 0)
     439                 :            :                         return ret;
     440                 :            :         }
     441                 :            : 
     442                 :          0 :         mutex_lock(&delayed_uprobe_lock);
     443         [ #  # ]:          0 :         if (d > 0)
     444                 :          0 :                 ret = delayed_uprobe_add(uprobe, mm);
     445                 :            :         else
     446                 :          0 :                 delayed_uprobe_remove(uprobe, mm);
     447                 :          0 :         mutex_unlock(&delayed_uprobe_lock);
     448                 :            : 
     449                 :          0 :         return ret;
     450                 :            : }
     451                 :            : 
     452                 :            : /*
     453                 :            :  * NOTE:
     454                 :            :  * Expect the breakpoint instruction to be the smallest size instruction for
     455                 :            :  * the architecture. If an arch has variable length instruction and the
     456                 :            :  * breakpoint instruction is not of the smallest length instruction
     457                 :            :  * supported by that architecture then we need to modify is_trap_at_addr and
     458                 :            :  * uprobe_write_opcode accordingly. This would never be a problem for archs
     459                 :            :  * that have fixed length instructions.
     460                 :            :  *
     461                 :            :  * uprobe_write_opcode - write the opcode at a given virtual address.
     462                 :            :  * @mm: the probed process address space.
     463                 :            :  * @vaddr: the virtual address to store the opcode.
     464                 :            :  * @opcode: opcode to be written at @vaddr.
     465                 :            :  *
     466                 :            :  * Called with mm->mmap_sem held for write.
     467                 :            :  * Return 0 (success) or a negative errno.
     468                 :            :  */
     469                 :          0 : int uprobe_write_opcode(struct arch_uprobe *auprobe, struct mm_struct *mm,
     470                 :            :                         unsigned long vaddr, uprobe_opcode_t opcode)
     471                 :            : {
     472                 :          0 :         struct uprobe *uprobe;
     473                 :          0 :         struct page *old_page, *new_page;
     474                 :          0 :         struct vm_area_struct *vma;
     475                 :          0 :         int ret, is_register, ref_ctr_updated = 0;
     476                 :          0 :         bool orig_page_huge = false;
     477                 :          0 :         unsigned int gup_flags = FOLL_FORCE;
     478                 :            : 
     479                 :          0 :         is_register = is_swbp_insn(&opcode);
     480                 :          0 :         uprobe = container_of(auprobe, struct uprobe, arch);
     481                 :            : 
     482                 :          0 : retry:
     483         [ #  # ]:          0 :         if (is_register)
     484                 :          0 :                 gup_flags |= FOLL_SPLIT_PMD;
     485                 :            :         /* Read the page with vaddr into memory */
     486                 :          0 :         ret = get_user_pages_remote(NULL, mm, vaddr, 1, gup_flags,
     487                 :            :                                     &old_page, &vma, NULL);
     488         [ #  # ]:          0 :         if (ret <= 0)
     489                 :          0 :                 return ret;
     490                 :            : 
     491                 :          0 :         ret = verify_opcode(old_page, vaddr, &opcode);
     492         [ #  # ]:          0 :         if (ret <= 0)
     493                 :          0 :                 goto put_old;
     494                 :            : 
     495   [ #  #  #  #  :          0 :         if (WARN(!is_register && PageCompound(old_page),
                   #  # ]
     496                 :            :                  "uprobe unregister should never work on compound page\n")) {
     497                 :          0 :                 ret = -EINVAL;
     498                 :          0 :                 goto put_old;
     499                 :            :         }
     500                 :            : 
     501                 :            :         /* We are going to replace instruction, update ref_ctr. */
     502   [ #  #  #  # ]:          0 :         if (!ref_ctr_updated && uprobe->ref_ctr_offset) {
     503         [ #  # ]:          0 :                 ret = update_ref_ctr(uprobe, mm, is_register ? 1 : -1);
     504         [ #  # ]:          0 :                 if (ret)
     505                 :          0 :                         goto put_old;
     506                 :            : 
     507                 :            :                 ref_ctr_updated = 1;
     508                 :            :         }
     509                 :            : 
     510                 :          0 :         ret = 0;
     511   [ #  #  #  #  :          0 :         if (!is_register && !PageAnon(old_page))
                   #  # ]
     512                 :          0 :                 goto put_old;
     513                 :            : 
     514         [ #  # ]:          0 :         ret = anon_vma_prepare(vma);
     515         [ #  # ]:          0 :         if (ret)
     516                 :          0 :                 goto put_old;
     517                 :            : 
     518                 :          0 :         ret = -ENOMEM;
     519                 :          0 :         new_page = alloc_page_vma(GFP_HIGHUSER_MOVABLE, vma, vaddr);
     520         [ #  # ]:          0 :         if (!new_page)
     521                 :          0 :                 goto put_old;
     522                 :            : 
     523                 :          0 :         __SetPageUptodate(new_page);
     524                 :          0 :         copy_highpage(new_page, old_page);
     525                 :          0 :         copy_to_page(new_page, vaddr, &opcode, UPROBE_SWBP_INSN_SIZE);
     526                 :            : 
     527         [ #  # ]:          0 :         if (!is_register) {
     528                 :          0 :                 struct page *orig_page;
     529                 :          0 :                 pgoff_t index;
     530                 :            : 
     531                 :          0 :                 VM_BUG_ON_PAGE(!PageAnon(old_page), old_page);
     532                 :            : 
     533                 :          0 :                 index = vaddr_to_offset(vma, vaddr & PAGE_MASK) >> PAGE_SHIFT;
     534                 :          0 :                 orig_page = find_get_page(vma->vm_file->f_inode->i_mapping,
     535                 :            :                                           index);
     536                 :            : 
     537         [ #  # ]:          0 :                 if (orig_page) {
     538   [ #  #  #  # ]:          0 :                         if (PageUptodate(orig_page) &&
     539                 :            :                             pages_identical(new_page, orig_page)) {
     540                 :            :                                 /* let go new_page */
     541                 :          0 :                                 put_page(new_page);
     542                 :          0 :                                 new_page = NULL;
     543                 :            : 
     544                 :          0 :                                 if (PageCompound(orig_page))
     545                 :            :                                         orig_page_huge = true;
     546                 :            :                         }
     547                 :          0 :                         put_page(orig_page);
     548                 :            :                 }
     549                 :            :         }
     550                 :            : 
     551                 :          0 :         ret = __replace_page(vma, vaddr, old_page, new_page);
     552         [ #  # ]:          0 :         if (new_page)
     553                 :          0 :                 put_page(new_page);
     554                 :          0 : put_old:
     555                 :          0 :         put_page(old_page);
     556                 :            : 
     557         [ #  # ]:          0 :         if (unlikely(ret == -EAGAIN))
     558                 :          0 :                 goto retry;
     559                 :            : 
     560                 :            :         /* Revert back reference counter if instruction update failed. */
     561   [ #  #  #  # ]:          0 :         if (ret && is_register && ref_ctr_updated)
     562                 :          0 :                 update_ref_ctr(uprobe, mm, -1);
     563                 :            : 
     564                 :            :         /* try collapse pmd for compound page */
     565                 :          0 :         if (!ret && orig_page_huge)
     566                 :            :                 collapse_pte_mapped_thp(mm, vaddr);
     567                 :            : 
     568                 :          0 :         return ret;
     569                 :            : }
     570                 :            : 
     571                 :            : /**
     572                 :            :  * set_swbp - store breakpoint at a given address.
     573                 :            :  * @auprobe: arch specific probepoint information.
     574                 :            :  * @mm: the probed process address space.
     575                 :            :  * @vaddr: the virtual address to insert the opcode.
     576                 :            :  *
     577                 :            :  * For mm @mm, store the breakpoint instruction at @vaddr.
     578                 :            :  * Return 0 (success) or a negative errno.
     579                 :            :  */
     580                 :          0 : int __weak set_swbp(struct arch_uprobe *auprobe, struct mm_struct *mm, unsigned long vaddr)
     581                 :            : {
     582                 :          0 :         return uprobe_write_opcode(auprobe, mm, vaddr, UPROBE_SWBP_INSN);
     583                 :            : }
     584                 :            : 
     585                 :            : /**
     586                 :            :  * set_orig_insn - Restore the original instruction.
     587                 :            :  * @mm: the probed process address space.
     588                 :            :  * @auprobe: arch specific probepoint information.
     589                 :            :  * @vaddr: the virtual address to insert the opcode.
     590                 :            :  *
     591                 :            :  * For mm @mm, restore the original opcode (opcode) at @vaddr.
     592                 :            :  * Return 0 (success) or a negative errno.
     593                 :            :  */
     594                 :            : int __weak
     595                 :          0 : set_orig_insn(struct arch_uprobe *auprobe, struct mm_struct *mm, unsigned long vaddr)
     596                 :            : {
     597                 :          0 :         return uprobe_write_opcode(auprobe, mm, vaddr,
     598                 :          0 :                         *(uprobe_opcode_t *)&auprobe->insn);
     599                 :            : }
     600                 :            : 
     601                 :          0 : static struct uprobe *get_uprobe(struct uprobe *uprobe)
     602                 :            : {
     603                 :          0 :         refcount_inc(&uprobe->ref);
     604                 :          0 :         return uprobe;
     605                 :            : }
     606                 :            : 
     607                 :          0 : static void put_uprobe(struct uprobe *uprobe)
     608                 :            : {
     609         [ #  # ]:          0 :         if (refcount_dec_and_test(&uprobe->ref)) {
     610                 :            :                 /*
     611                 :            :                  * If application munmap(exec_vma) before uprobe_unregister()
     612                 :            :                  * gets called, we don't get a chance to remove uprobe from
     613                 :            :                  * delayed_uprobe_list from remove_breakpoint(). Do it here.
     614                 :            :                  */
     615                 :          0 :                 mutex_lock(&delayed_uprobe_lock);
     616                 :          0 :                 delayed_uprobe_remove(uprobe, NULL);
     617                 :          0 :                 mutex_unlock(&delayed_uprobe_lock);
     618                 :          0 :                 kfree(uprobe);
     619                 :            :         }
     620                 :          0 : }
     621                 :            : 
     622                 :          0 : static int match_uprobe(struct uprobe *l, struct uprobe *r)
     623                 :            : {
     624                 :          0 :         if (l->inode < r->inode)
     625                 :            :                 return -1;
     626                 :            : 
     627   [ #  #  #  # ]:          0 :         if (l->inode > r->inode)
     628                 :            :                 return 1;
     629                 :            : 
     630   [ #  #  #  # ]:          0 :         if (l->offset < r->offset)
     631                 :            :                 return -1;
     632                 :            : 
     633   [ #  #  #  # ]:          0 :         if (l->offset > r->offset)
     634                 :            :                 return 1;
     635                 :            : 
     636                 :            :         return 0;
     637                 :            : }
     638                 :            : 
     639                 :          0 : static struct uprobe *__find_uprobe(struct inode *inode, loff_t offset)
     640                 :            : {
     641                 :          0 :         struct uprobe u = { .inode = inode, .offset = offset };
     642                 :          0 :         struct rb_node *n = uprobes_tree.rb_node;
     643                 :          0 :         struct uprobe *uprobe;
     644                 :          0 :         int match;
     645                 :            : 
     646         [ #  # ]:          0 :         while (n) {
     647                 :          0 :                 uprobe = rb_entry(n, struct uprobe, rb_node);
     648         [ #  # ]:          0 :                 match = match_uprobe(&u, uprobe);
     649                 :          0 :                 if (!match)
     650                 :          0 :                         return get_uprobe(uprobe);
     651                 :            : 
     652         [ #  # ]:          0 :                 if (match < 0)
     653                 :          0 :                         n = n->rb_left;
     654                 :            :                 else
     655                 :          0 :                         n = n->rb_right;
     656                 :            :         }
     657                 :            :         return NULL;
     658                 :            : }
     659                 :            : 
     660                 :            : /*
     661                 :            :  * Find a uprobe corresponding to a given inode:offset
     662                 :            :  * Acquires uprobes_treelock
     663                 :            :  */
     664                 :          0 : static struct uprobe *find_uprobe(struct inode *inode, loff_t offset)
     665                 :            : {
     666                 :          0 :         struct uprobe *uprobe;
     667                 :            : 
     668                 :          0 :         spin_lock(&uprobes_treelock);
     669                 :          0 :         uprobe = __find_uprobe(inode, offset);
     670                 :          0 :         spin_unlock(&uprobes_treelock);
     671                 :            : 
     672                 :          0 :         return uprobe;
     673                 :            : }
     674                 :            : 
     675                 :          0 : static struct uprobe *__insert_uprobe(struct uprobe *uprobe)
     676                 :            : {
     677                 :          0 :         struct rb_node **p = &uprobes_tree.rb_node;
     678                 :          0 :         struct rb_node *parent = NULL;
     679                 :          0 :         struct uprobe *u;
     680                 :          0 :         int match;
     681                 :            : 
     682         [ #  # ]:          0 :         while (*p) {
     683                 :          0 :                 parent = *p;
     684                 :          0 :                 u = rb_entry(parent, struct uprobe, rb_node);
     685         [ #  # ]:          0 :                 match = match_uprobe(uprobe, u);
     686                 :          0 :                 if (!match)
     687                 :          0 :                         return get_uprobe(u);
     688                 :            : 
     689         [ #  # ]:          0 :                 if (match < 0)
     690                 :          0 :                         p = &parent->rb_left;
     691                 :            :                 else
     692                 :          0 :                         p = &parent->rb_right;
     693                 :            : 
     694                 :            :         }
     695                 :            : 
     696                 :          0 :         u = NULL;
     697                 :          0 :         rb_link_node(&uprobe->rb_node, parent, p);
     698                 :          0 :         rb_insert_color(&uprobe->rb_node, &uprobes_tree);
     699                 :            :         /* get access + creation ref */
     700                 :          0 :         refcount_set(&uprobe->ref, 2);
     701                 :            : 
     702                 :          0 :         return u;
     703                 :            : }
     704                 :            : 
     705                 :            : /*
     706                 :            :  * Acquire uprobes_treelock.
     707                 :            :  * Matching uprobe already exists in rbtree;
     708                 :            :  *      increment (access refcount) and return the matching uprobe.
     709                 :            :  *
     710                 :            :  * No matching uprobe; insert the uprobe in rb_tree;
     711                 :            :  *      get a double refcount (access + creation) and return NULL.
     712                 :            :  */
     713                 :          0 : static struct uprobe *insert_uprobe(struct uprobe *uprobe)
     714                 :            : {
     715                 :          0 :         struct uprobe *u;
     716                 :            : 
     717                 :          0 :         spin_lock(&uprobes_treelock);
     718                 :          0 :         u = __insert_uprobe(uprobe);
     719                 :          0 :         spin_unlock(&uprobes_treelock);
     720                 :            : 
     721                 :          0 :         return u;
     722                 :            : }
     723                 :            : 
     724                 :            : static void
     725                 :            : ref_ctr_mismatch_warn(struct uprobe *cur_uprobe, struct uprobe *uprobe)
     726                 :            : {
     727                 :            :         pr_warn("ref_ctr_offset mismatch. inode: 0x%lx offset: 0x%llx "
     728                 :            :                 "ref_ctr_offset(old): 0x%llx ref_ctr_offset(new): 0x%llx\n",
     729                 :            :                 uprobe->inode->i_ino, (unsigned long long) uprobe->offset,
     730                 :            :                 (unsigned long long) cur_uprobe->ref_ctr_offset,
     731                 :            :                 (unsigned long long) uprobe->ref_ctr_offset);
     732                 :            : }
     733                 :            : 
     734                 :          0 : static struct uprobe *alloc_uprobe(struct inode *inode, loff_t offset,
     735                 :            :                                    loff_t ref_ctr_offset)
     736                 :            : {
     737                 :          0 :         struct uprobe *uprobe, *cur_uprobe;
     738                 :            : 
     739                 :          0 :         uprobe = kzalloc(sizeof(struct uprobe), GFP_KERNEL);
     740         [ #  # ]:          0 :         if (!uprobe)
     741                 :            :                 return NULL;
     742                 :            : 
     743                 :          0 :         uprobe->inode = inode;
     744                 :          0 :         uprobe->offset = offset;
     745                 :          0 :         uprobe->ref_ctr_offset = ref_ctr_offset;
     746                 :          0 :         init_rwsem(&uprobe->register_rwsem);
     747                 :          0 :         init_rwsem(&uprobe->consumer_rwsem);
     748                 :            : 
     749                 :            :         /* add to uprobes_tree, sorted on inode:offset */
     750                 :          0 :         cur_uprobe = insert_uprobe(uprobe);
     751                 :            :         /* a uprobe exists for this inode:offset combination */
     752         [ #  # ]:          0 :         if (cur_uprobe) {
     753         [ #  # ]:          0 :                 if (cur_uprobe->ref_ctr_offset != uprobe->ref_ctr_offset) {
     754                 :          0 :                         ref_ctr_mismatch_warn(cur_uprobe, uprobe);
     755                 :          0 :                         put_uprobe(cur_uprobe);
     756                 :          0 :                         kfree(uprobe);
     757                 :          0 :                         return ERR_PTR(-EINVAL);
     758                 :            :                 }
     759                 :          0 :                 kfree(uprobe);
     760                 :          0 :                 uprobe = cur_uprobe;
     761                 :            :         }
     762                 :            : 
     763                 :            :         return uprobe;
     764                 :            : }
     765                 :            : 
     766                 :          0 : static void consumer_add(struct uprobe *uprobe, struct uprobe_consumer *uc)
     767                 :            : {
     768                 :          0 :         down_write(&uprobe->consumer_rwsem);
     769                 :          0 :         uc->next = uprobe->consumers;
     770                 :          0 :         uprobe->consumers = uc;
     771                 :          0 :         up_write(&uprobe->consumer_rwsem);
     772                 :            : }
     773                 :            : 
     774                 :            : /*
     775                 :            :  * For uprobe @uprobe, delete the consumer @uc.
     776                 :            :  * Return true if the @uc is deleted successfully
     777                 :            :  * or return false.
     778                 :            :  */
     779                 :          0 : static bool consumer_del(struct uprobe *uprobe, struct uprobe_consumer *uc)
     780                 :            : {
     781                 :          0 :         struct uprobe_consumer **con;
     782                 :          0 :         bool ret = false;
     783                 :            : 
     784                 :          0 :         down_write(&uprobe->consumer_rwsem);
     785         [ #  # ]:          0 :         for (con = &uprobe->consumers; *con; con = &(*con)->next) {
     786         [ #  # ]:          0 :                 if (*con == uc) {
     787                 :          0 :                         *con = uc->next;
     788                 :          0 :                         ret = true;
     789                 :          0 :                         break;
     790                 :            :                 }
     791                 :            :         }
     792                 :          0 :         up_write(&uprobe->consumer_rwsem);
     793                 :            : 
     794                 :          0 :         return ret;
     795                 :            : }
     796                 :            : 
     797                 :          0 : static int __copy_insn(struct address_space *mapping, struct file *filp,
     798                 :            :                         void *insn, int nbytes, loff_t offset)
     799                 :            : {
     800                 :          0 :         struct page *page;
     801                 :            :         /*
     802                 :            :          * Ensure that the page that has the original instruction is populated
     803                 :            :          * and in page-cache. If ->readpage == NULL it must be shmem_mapping(),
     804                 :            :          * see uprobe_register().
     805                 :            :          */
     806         [ #  # ]:          0 :         if (mapping->a_ops->readpage)
     807                 :          0 :                 page = read_mapping_page(mapping, offset >> PAGE_SHIFT, filp);
     808                 :            :         else
     809                 :          0 :                 page = shmem_read_mapping_page(mapping, offset >> PAGE_SHIFT);
     810         [ #  # ]:          0 :         if (IS_ERR(page))
     811                 :          0 :                 return PTR_ERR(page);
     812                 :            : 
     813                 :          0 :         copy_from_page(page, offset, insn, nbytes);
     814                 :          0 :         put_page(page);
     815                 :            : 
     816                 :          0 :         return 0;
     817                 :            : }
     818                 :            : 
     819                 :          0 : static int copy_insn(struct uprobe *uprobe, struct file *filp)
     820                 :            : {
     821                 :          0 :         struct address_space *mapping = uprobe->inode->i_mapping;
     822                 :          0 :         loff_t offs = uprobe->offset;
     823                 :          0 :         void *insn = &uprobe->arch.insn;
     824                 :          0 :         int size = sizeof(uprobe->arch.insn);
     825                 :          0 :         int len, err = -EIO;
     826                 :            : 
     827                 :            :         /* Copy only available bytes, -EIO if nothing was read */
     828                 :          0 :         do {
     829         [ #  # ]:          0 :                 if (offs >= i_size_read(uprobe->inode))
     830                 :            :                         break;
     831                 :            : 
     832                 :          0 :                 len = min_t(int, size, PAGE_SIZE - (offs & ~PAGE_MASK));
     833                 :          0 :                 err = __copy_insn(mapping, filp, insn, len, offs);
     834         [ #  # ]:          0 :                 if (err)
     835                 :            :                         break;
     836                 :            : 
     837                 :          0 :                 insn += len;
     838                 :          0 :                 offs += len;
     839                 :          0 :                 size -= len;
     840         [ #  # ]:          0 :         } while (size);
     841                 :            : 
     842                 :          0 :         return err;
     843                 :            : }
     844                 :            : 
     845                 :          0 : static int prepare_uprobe(struct uprobe *uprobe, struct file *file,
     846                 :            :                                 struct mm_struct *mm, unsigned long vaddr)
     847                 :            : {
     848                 :          0 :         int ret = 0;
     849                 :            : 
     850         [ #  # ]:          0 :         if (test_bit(UPROBE_COPY_INSN, &uprobe->flags))
     851                 :            :                 return ret;
     852                 :            : 
     853                 :            :         /* TODO: move this into _register, until then we abuse this sem. */
     854                 :          0 :         down_write(&uprobe->consumer_rwsem);
     855         [ #  # ]:          0 :         if (test_bit(UPROBE_COPY_INSN, &uprobe->flags))
     856                 :          0 :                 goto out;
     857                 :            : 
     858                 :          0 :         ret = copy_insn(uprobe, file);
     859         [ #  # ]:          0 :         if (ret)
     860                 :          0 :                 goto out;
     861                 :            : 
     862                 :          0 :         ret = -ENOTSUPP;
     863         [ #  # ]:          0 :         if (is_trap_insn((uprobe_opcode_t *)&uprobe->arch.insn))
     864                 :          0 :                 goto out;
     865                 :            : 
     866                 :          0 :         ret = arch_uprobe_analyze_insn(&uprobe->arch, mm, vaddr);
     867         [ #  # ]:          0 :         if (ret)
     868                 :          0 :                 goto out;
     869                 :            : 
     870                 :            :         /* uprobe_write_opcode() assumes we don't cross page boundary */
     871                 :          0 :         BUG_ON((uprobe->offset & ~PAGE_MASK) +
     872                 :            :                         UPROBE_SWBP_INSN_SIZE > PAGE_SIZE);
     873                 :            : 
     874                 :          0 :         smp_wmb(); /* pairs with the smp_rmb() in handle_swbp() */
     875                 :          0 :         set_bit(UPROBE_COPY_INSN, &uprobe->flags);
     876                 :            : 
     877                 :          0 :  out:
     878                 :          0 :         up_write(&uprobe->consumer_rwsem);
     879                 :            : 
     880                 :          0 :         return ret;
     881                 :            : }
     882                 :            : 
     883                 :          0 : static inline bool consumer_filter(struct uprobe_consumer *uc,
     884                 :            :                                    enum uprobe_filter_ctx ctx, struct mm_struct *mm)
     885                 :            : {
     886   [ #  #  #  # ]:          0 :         return !uc->filter || uc->filter(uc, ctx, mm);
     887                 :            : }
     888                 :            : 
     889                 :          0 : static bool filter_chain(struct uprobe *uprobe,
     890                 :            :                          enum uprobe_filter_ctx ctx, struct mm_struct *mm)
     891                 :            : {
     892                 :          0 :         struct uprobe_consumer *uc;
     893                 :          0 :         bool ret = false;
     894                 :            : 
     895                 :          0 :         down_read(&uprobe->consumer_rwsem);
     896         [ #  # ]:          0 :         for (uc = uprobe->consumers; uc; uc = uc->next) {
     897         [ #  # ]:          0 :                 ret = consumer_filter(uc, ctx, mm);
     898         [ #  # ]:          0 :                 if (ret)
     899                 :            :                         break;
     900                 :            :         }
     901                 :          0 :         up_read(&uprobe->consumer_rwsem);
     902                 :            : 
     903                 :          0 :         return ret;
     904                 :            : }
     905                 :            : 
     906                 :            : static int
     907                 :            : install_breakpoint(struct uprobe *uprobe, struct mm_struct *mm,
     908                 :            :                         struct vm_area_struct *vma, unsigned long vaddr)
     909                 :            : {
     910                 :            :         bool first_uprobe;
     911                 :            :         int ret;
     912                 :            : 
     913                 :            :         ret = prepare_uprobe(uprobe, vma->vm_file, mm, vaddr);
     914                 :            :         if (ret)
     915                 :            :                 return ret;
     916                 :            : 
     917                 :            :         /*
     918                 :            :          * set MMF_HAS_UPROBES in advance for uprobe_pre_sstep_notifier(),
     919                 :            :          * the task can hit this breakpoint right after __replace_page().
     920                 :            :          */
     921                 :            :         first_uprobe = !test_bit(MMF_HAS_UPROBES, &mm->flags);
     922                 :            :         if (first_uprobe)
     923                 :            :                 set_bit(MMF_HAS_UPROBES, &mm->flags);
     924                 :            : 
     925                 :            :         ret = set_swbp(&uprobe->arch, mm, vaddr);
     926                 :            :         if (!ret)
     927                 :            :                 clear_bit(MMF_RECALC_UPROBES, &mm->flags);
     928                 :            :         else if (first_uprobe)
     929                 :            :                 clear_bit(MMF_HAS_UPROBES, &mm->flags);
     930                 :            : 
     931                 :            :         return ret;
     932                 :            : }
     933                 :            : 
     934                 :            : static int
     935                 :          0 : remove_breakpoint(struct uprobe *uprobe, struct mm_struct *mm, unsigned long vaddr)
     936                 :            : {
     937                 :          0 :         set_bit(MMF_RECALC_UPROBES, &mm->flags);
     938                 :          0 :         return set_orig_insn(&uprobe->arch, mm, vaddr);
     939                 :            : }
     940                 :            : 
     941                 :          0 : static inline bool uprobe_is_active(struct uprobe *uprobe)
     942                 :            : {
     943                 :          0 :         return !RB_EMPTY_NODE(&uprobe->rb_node);
     944                 :            : }
     945                 :            : /*
     946                 :            :  * There could be threads that have already hit the breakpoint. They
     947                 :            :  * will recheck the current insn and restart if find_uprobe() fails.
     948                 :            :  * See find_active_uprobe().
     949                 :            :  */
     950                 :          0 : static void delete_uprobe(struct uprobe *uprobe)
     951                 :            : {
     952   [ #  #  #  # ]:          0 :         if (WARN_ON(!uprobe_is_active(uprobe)))
     953                 :            :                 return;
     954                 :            : 
     955                 :          0 :         spin_lock(&uprobes_treelock);
     956                 :          0 :         rb_erase(&uprobe->rb_node, &uprobes_tree);
     957                 :          0 :         spin_unlock(&uprobes_treelock);
     958                 :          0 :         RB_CLEAR_NODE(&uprobe->rb_node); /* for uprobe_is_active() */
     959                 :          0 :         put_uprobe(uprobe);
     960                 :            : }
     961                 :            : 
     962                 :            : struct map_info {
     963                 :            :         struct map_info *next;
     964                 :            :         struct mm_struct *mm;
     965                 :            :         unsigned long vaddr;
     966                 :            : };
     967                 :            : 
     968                 :          0 : static inline struct map_info *free_map_info(struct map_info *info)
     969                 :            : {
     970                 :          0 :         struct map_info *next = info->next;
     971                 :          0 :         kfree(info);
     972                 :          0 :         return next;
     973                 :            : }
     974                 :            : 
     975                 :            : static struct map_info *
     976                 :          0 : build_map_info(struct address_space *mapping, loff_t offset, bool is_register)
     977                 :            : {
     978                 :          0 :         unsigned long pgoff = offset >> PAGE_SHIFT;
     979                 :          0 :         struct vm_area_struct *vma;
     980                 :          0 :         struct map_info *curr = NULL;
     981                 :          0 :         struct map_info *prev = NULL;
     982                 :          0 :         struct map_info *info;
     983                 :          0 :         int more = 0;
     984                 :            : 
     985                 :          0 :  again:
     986                 :          0 :         i_mmap_lock_read(mapping);
     987         [ #  # ]:          0 :         vma_interval_tree_foreach(vma, &mapping->i_mmap, pgoff, pgoff) {
     988   [ #  #  #  # ]:          0 :                 if (!valid_vma(vma, is_register))
     989                 :          0 :                         continue;
     990                 :            : 
     991         [ #  # ]:          0 :                 if (!prev && !more) {
     992                 :            :                         /*
     993                 :            :                          * Needs GFP_NOWAIT to avoid i_mmap_rwsem recursion through
     994                 :            :                          * reclaim. This is optimistic, no harm done if it fails.
     995                 :            :                          */
     996                 :          0 :                         prev = kmalloc(sizeof(struct map_info),
     997                 :            :                                         GFP_NOWAIT | __GFP_NOMEMALLOC | __GFP_NOWARN);
     998         [ #  # ]:          0 :                         if (prev)
     999                 :          0 :                                 prev->next = NULL;
    1000                 :            :                 }
    1001         [ #  # ]:          0 :                 if (!prev) {
    1002                 :          0 :                         more++;
    1003                 :          0 :                         continue;
    1004                 :            :                 }
    1005                 :            : 
    1006         [ #  # ]:          0 :                 if (!mmget_not_zero(vma->vm_mm))
    1007                 :          0 :                         continue;
    1008                 :            : 
    1009                 :          0 :                 info = prev;
    1010                 :          0 :                 prev = prev->next;
    1011                 :          0 :                 info->next = curr;
    1012                 :          0 :                 curr = info;
    1013                 :            : 
    1014                 :          0 :                 info->mm = vma->vm_mm;
    1015                 :          0 :                 info->vaddr = offset_to_vaddr(vma, offset);
    1016                 :            :         }
    1017                 :          0 :         i_mmap_unlock_read(mapping);
    1018                 :            : 
    1019         [ #  # ]:          0 :         if (!more)
    1020                 :          0 :                 goto out;
    1021                 :            : 
    1022                 :            :         prev = curr;
    1023         [ #  # ]:          0 :         while (curr) {
    1024                 :          0 :                 mmput(curr->mm);
    1025                 :          0 :                 curr = curr->next;
    1026                 :            :         }
    1027                 :            : 
    1028                 :          0 :         do {
    1029                 :          0 :                 info = kmalloc(sizeof(struct map_info), GFP_KERNEL);
    1030         [ #  # ]:          0 :                 if (!info) {
    1031                 :          0 :                         curr = ERR_PTR(-ENOMEM);
    1032                 :          0 :                         goto out;
    1033                 :            :                 }
    1034                 :          0 :                 info->next = prev;
    1035                 :          0 :                 prev = info;
    1036         [ #  # ]:          0 :         } while (--more);
    1037                 :            : 
    1038                 :          0 :         goto again;
    1039                 :          0 :  out:
    1040         [ #  # ]:          0 :         while (prev)
    1041                 :          0 :                 prev = free_map_info(prev);
    1042                 :          0 :         return curr;
    1043                 :            : }
    1044                 :            : 
    1045                 :            : static int
    1046                 :          0 : register_for_each_vma(struct uprobe *uprobe, struct uprobe_consumer *new)
    1047                 :            : {
    1048                 :          0 :         bool is_register = !!new;
    1049                 :          0 :         struct map_info *info;
    1050                 :          0 :         int err = 0;
    1051                 :            : 
    1052                 :          0 :         percpu_down_write(&dup_mmap_sem);
    1053                 :          0 :         info = build_map_info(uprobe->inode->i_mapping,
    1054                 :            :                                         uprobe->offset, is_register);
    1055         [ #  # ]:          0 :         if (IS_ERR(info)) {
    1056                 :          0 :                 err = PTR_ERR(info);
    1057                 :          0 :                 goto out;
    1058                 :            :         }
    1059                 :            : 
    1060         [ #  # ]:          0 :         while (info) {
    1061                 :          0 :                 struct mm_struct *mm = info->mm;
    1062                 :          0 :                 struct vm_area_struct *vma;
    1063                 :            : 
    1064         [ #  # ]:          0 :                 if (err && is_register)
    1065                 :          0 :                         goto free;
    1066                 :            : 
    1067                 :          0 :                 down_write(&mm->mmap_sem);
    1068                 :          0 :                 vma = find_vma(mm, info->vaddr);
    1069   [ #  #  #  #  :          0 :                 if (!vma || !valid_vma(vma, is_register) ||
                   #  # ]
    1070         [ #  # ]:          0 :                     file_inode(vma->vm_file) != uprobe->inode)
    1071                 :          0 :                         goto unlock;
    1072                 :            : 
    1073         [ #  # ]:          0 :                 if (vma->vm_start > info->vaddr ||
    1074         [ #  # ]:          0 :                     vaddr_to_offset(vma, info->vaddr) != uprobe->offset)
    1075                 :          0 :                         goto unlock;
    1076                 :            : 
    1077         [ #  # ]:          0 :                 if (is_register) {
    1078                 :            :                         /* consult only the "caller", new consumer. */
    1079   [ #  #  #  # ]:          0 :                         if (consumer_filter(new,
    1080                 :            :                                         UPROBE_FILTER_REGISTER, mm))
    1081                 :          0 :                                 err = install_breakpoint(uprobe, mm, vma, info->vaddr);
    1082         [ #  # ]:          0 :                 } else if (test_bit(MMF_HAS_UPROBES, &mm->flags)) {
    1083         [ #  # ]:          0 :                         if (!filter_chain(uprobe,
    1084                 :            :                                         UPROBE_FILTER_UNREGISTER, mm))
    1085                 :          0 :                                 err |= remove_breakpoint(uprobe, mm, info->vaddr);
    1086                 :            :                 }
    1087                 :            : 
    1088                 :          0 :  unlock:
    1089                 :          0 :                 up_write(&mm->mmap_sem);
    1090                 :          0 :  free:
    1091                 :          0 :                 mmput(mm);
    1092                 :          0 :                 info = free_map_info(info);
    1093                 :            :         }
    1094                 :          0 :  out:
    1095                 :          0 :         percpu_up_write(&dup_mmap_sem);
    1096                 :          0 :         return err;
    1097                 :            : }
    1098                 :            : 
    1099                 :            : static void
    1100                 :          0 : __uprobe_unregister(struct uprobe *uprobe, struct uprobe_consumer *uc)
    1101                 :            : {
    1102                 :          0 :         int err;
    1103                 :            : 
    1104   [ #  #  #  # ]:          0 :         if (WARN_ON(!consumer_del(uprobe, uc)))
    1105                 :            :                 return;
    1106                 :            : 
    1107                 :          0 :         err = register_for_each_vma(uprobe, NULL);
    1108                 :            :         /* TODO : cant unregister? schedule a worker thread */
    1109   [ #  #  #  # ]:          0 :         if (!uprobe->consumers && !err)
    1110                 :          0 :                 delete_uprobe(uprobe);
    1111                 :            : }
    1112                 :            : 
    1113                 :            : /*
    1114                 :            :  * uprobe_unregister - unregister an already registered probe.
    1115                 :            :  * @inode: the file in which the probe has to be removed.
    1116                 :            :  * @offset: offset from the start of the file.
    1117                 :            :  * @uc: identify which probe if multiple probes are colocated.
    1118                 :            :  */
    1119                 :          0 : void uprobe_unregister(struct inode *inode, loff_t offset, struct uprobe_consumer *uc)
    1120                 :            : {
    1121                 :          0 :         struct uprobe *uprobe;
    1122                 :            : 
    1123                 :          0 :         uprobe = find_uprobe(inode, offset);
    1124   [ #  #  #  # ]:          0 :         if (WARN_ON(!uprobe))
    1125                 :            :                 return;
    1126                 :            : 
    1127                 :          0 :         down_write(&uprobe->register_rwsem);
    1128                 :          0 :         __uprobe_unregister(uprobe, uc);
    1129                 :          0 :         up_write(&uprobe->register_rwsem);
    1130                 :          0 :         put_uprobe(uprobe);
    1131                 :            : }
    1132                 :            : EXPORT_SYMBOL_GPL(uprobe_unregister);
    1133                 :            : 
    1134                 :            : /*
    1135                 :            :  * __uprobe_register - register a probe
    1136                 :            :  * @inode: the file in which the probe has to be placed.
    1137                 :            :  * @offset: offset from the start of the file.
    1138                 :            :  * @uc: information on howto handle the probe..
    1139                 :            :  *
    1140                 :            :  * Apart from the access refcount, __uprobe_register() takes a creation
    1141                 :            :  * refcount (thro alloc_uprobe) if and only if this @uprobe is getting
    1142                 :            :  * inserted into the rbtree (i.e first consumer for a @inode:@offset
    1143                 :            :  * tuple).  Creation refcount stops uprobe_unregister from freeing the
    1144                 :            :  * @uprobe even before the register operation is complete. Creation
    1145                 :            :  * refcount is released when the last @uc for the @uprobe
    1146                 :            :  * unregisters. Caller of __uprobe_register() is required to keep @inode
    1147                 :            :  * (and the containing mount) referenced.
    1148                 :            :  *
    1149                 :            :  * Return errno if it cannot successully install probes
    1150                 :            :  * else return 0 (success)
    1151                 :            :  */
    1152                 :          0 : static int __uprobe_register(struct inode *inode, loff_t offset,
    1153                 :            :                              loff_t ref_ctr_offset, struct uprobe_consumer *uc)
    1154                 :            : {
    1155                 :          0 :         struct uprobe *uprobe;
    1156                 :          0 :         int ret;
    1157                 :            : 
    1158                 :            :         /* Uprobe must have at least one set consumer */
    1159   [ #  #  #  # ]:          0 :         if (!uc->handler && !uc->ret_handler)
    1160                 :            :                 return -EINVAL;
    1161                 :            : 
    1162                 :            :         /* copy_insn() uses read_mapping_page() or shmem_read_mapping_page() */
    1163   [ #  #  #  # ]:          0 :         if (!inode->i_mapping->a_ops->readpage && !shmem_mapping(inode->i_mapping))
    1164                 :            :                 return -EIO;
    1165                 :            :         /* Racy, just to catch the obvious mistakes */
    1166         [ #  # ]:          0 :         if (offset > i_size_read(inode))
    1167                 :            :                 return -EINVAL;
    1168                 :            : 
    1169                 :          0 :  retry:
    1170                 :          0 :         uprobe = alloc_uprobe(inode, offset, ref_ctr_offset);
    1171         [ #  # ]:          0 :         if (!uprobe)
    1172                 :            :                 return -ENOMEM;
    1173         [ #  # ]:          0 :         if (IS_ERR(uprobe))
    1174                 :          0 :                 return PTR_ERR(uprobe);
    1175                 :            : 
    1176                 :            :         /*
    1177                 :            :          * We can race with uprobe_unregister()->delete_uprobe().
    1178                 :            :          * Check uprobe_is_active() and retry if it is false.
    1179                 :            :          */
    1180                 :          0 :         down_write(&uprobe->register_rwsem);
    1181                 :          0 :         ret = -EAGAIN;
    1182         [ #  # ]:          0 :         if (likely(uprobe_is_active(uprobe))) {
    1183                 :          0 :                 consumer_add(uprobe, uc);
    1184                 :          0 :                 ret = register_for_each_vma(uprobe, uc);
    1185         [ #  # ]:          0 :                 if (ret)
    1186                 :          0 :                         __uprobe_unregister(uprobe, uc);
    1187                 :            :         }
    1188                 :          0 :         up_write(&uprobe->register_rwsem);
    1189                 :          0 :         put_uprobe(uprobe);
    1190                 :            : 
    1191         [ #  # ]:          0 :         if (unlikely(ret == -EAGAIN))
    1192                 :          0 :                 goto retry;
    1193                 :            :         return ret;
    1194                 :            : }
    1195                 :            : 
    1196                 :          0 : int uprobe_register(struct inode *inode, loff_t offset,
    1197                 :            :                     struct uprobe_consumer *uc)
    1198                 :            : {
    1199                 :          0 :         return __uprobe_register(inode, offset, 0, uc);
    1200                 :            : }
    1201                 :            : EXPORT_SYMBOL_GPL(uprobe_register);
    1202                 :            : 
    1203                 :          0 : int uprobe_register_refctr(struct inode *inode, loff_t offset,
    1204                 :            :                            loff_t ref_ctr_offset, struct uprobe_consumer *uc)
    1205                 :            : {
    1206                 :          0 :         return __uprobe_register(inode, offset, ref_ctr_offset, uc);
    1207                 :            : }
    1208                 :            : EXPORT_SYMBOL_GPL(uprobe_register_refctr);
    1209                 :            : 
    1210                 :            : /*
    1211                 :            :  * uprobe_apply - unregister an already registered probe.
    1212                 :            :  * @inode: the file in which the probe has to be removed.
    1213                 :            :  * @offset: offset from the start of the file.
    1214                 :            :  * @uc: consumer which wants to add more or remove some breakpoints
    1215                 :            :  * @add: add or remove the breakpoints
    1216                 :            :  */
    1217                 :          0 : int uprobe_apply(struct inode *inode, loff_t offset,
    1218                 :            :                         struct uprobe_consumer *uc, bool add)
    1219                 :            : {
    1220                 :          0 :         struct uprobe *uprobe;
    1221                 :          0 :         struct uprobe_consumer *con;
    1222                 :          0 :         int ret = -ENOENT;
    1223                 :            : 
    1224                 :          0 :         uprobe = find_uprobe(inode, offset);
    1225   [ #  #  #  # ]:          0 :         if (WARN_ON(!uprobe))
    1226                 :            :                 return ret;
    1227                 :            : 
    1228                 :          0 :         down_write(&uprobe->register_rwsem);
    1229         [ #  # ]:          0 :         for (con = uprobe->consumers; con && con != uc ; con = con->next)
    1230                 :          0 :                 ;
    1231         [ #  # ]:          0 :         if (con)
    1232         [ #  # ]:          0 :                 ret = register_for_each_vma(uprobe, add ? uc : NULL);
    1233                 :          0 :         up_write(&uprobe->register_rwsem);
    1234                 :          0 :         put_uprobe(uprobe);
    1235                 :            : 
    1236                 :          0 :         return ret;
    1237                 :            : }
    1238                 :            : 
    1239                 :          0 : static int unapply_uprobe(struct uprobe *uprobe, struct mm_struct *mm)
    1240                 :            : {
    1241                 :          0 :         struct vm_area_struct *vma;
    1242                 :          0 :         int err = 0;
    1243                 :            : 
    1244                 :          0 :         down_read(&mm->mmap_sem);
    1245         [ #  # ]:          0 :         for (vma = mm->mmap; vma; vma = vma->vm_next) {
    1246                 :          0 :                 unsigned long vaddr;
    1247                 :          0 :                 loff_t offset;
    1248                 :            : 
    1249   [ #  #  #  #  :          0 :                 if (!valid_vma(vma, false) ||
                   #  # ]
    1250         [ #  # ]:          0 :                     file_inode(vma->vm_file) != uprobe->inode)
    1251                 :          0 :                         continue;
    1252                 :            : 
    1253                 :          0 :                 offset = (loff_t)vma->vm_pgoff << PAGE_SHIFT;
    1254         [ #  # ]:          0 :                 if (uprobe->offset <  offset ||
    1255         [ #  # ]:          0 :                     uprobe->offset >= offset + vma->vm_end - vma->vm_start)
    1256                 :          0 :                         continue;
    1257                 :            : 
    1258                 :          0 :                 vaddr = offset_to_vaddr(vma, uprobe->offset);
    1259                 :          0 :                 err |= remove_breakpoint(uprobe, mm, vaddr);
    1260                 :            :         }
    1261                 :          0 :         up_read(&mm->mmap_sem);
    1262                 :            : 
    1263                 :          0 :         return err;
    1264                 :            : }
    1265                 :            : 
    1266                 :            : static struct rb_node *
    1267                 :          0 : find_node_in_range(struct inode *inode, loff_t min, loff_t max)
    1268                 :            : {
    1269                 :          0 :         struct rb_node *n = uprobes_tree.rb_node;
    1270                 :            : 
    1271   [ #  #  #  # ]:          0 :         while (n) {
    1272                 :          0 :                 struct uprobe *u = rb_entry(n, struct uprobe, rb_node);
    1273                 :            : 
    1274   [ #  #  #  # ]:          0 :                 if (inode < u->inode) {
    1275                 :          0 :                         n = n->rb_left;
    1276   [ #  #  #  # ]:          0 :                 } else if (inode > u->inode) {
    1277                 :          0 :                         n = n->rb_right;
    1278                 :            :                 } else {
    1279   [ #  #  #  # ]:          0 :                         if (max < u->offset)
    1280                 :          0 :                                 n = n->rb_left;
    1281   [ #  #  #  # ]:          0 :                         else if (min > u->offset)
    1282                 :          0 :                                 n = n->rb_right;
    1283                 :            :                         else
    1284                 :            :                                 break;
    1285                 :            :                 }
    1286                 :            :         }
    1287                 :            : 
    1288                 :          0 :         return n;
    1289                 :            : }
    1290                 :            : 
    1291                 :            : /*
    1292                 :            :  * For a given range in vma, build a list of probes that need to be inserted.
    1293                 :            :  */
    1294                 :          0 : static void build_probe_list(struct inode *inode,
    1295                 :            :                                 struct vm_area_struct *vma,
    1296                 :            :                                 unsigned long start, unsigned long end,
    1297                 :            :                                 struct list_head *head)
    1298                 :            : {
    1299                 :          0 :         loff_t min, max;
    1300                 :          0 :         struct rb_node *n, *t;
    1301                 :          0 :         struct uprobe *u;
    1302                 :            : 
    1303                 :          0 :         INIT_LIST_HEAD(head);
    1304                 :          0 :         min = vaddr_to_offset(vma, start);
    1305                 :          0 :         max = min + (end - start) - 1;
    1306                 :            : 
    1307                 :          0 :         spin_lock(&uprobes_treelock);
    1308                 :          0 :         n = find_node_in_range(inode, min, max);
    1309         [ #  # ]:          0 :         if (n) {
    1310         [ #  # ]:          0 :                 for (t = n; t; t = rb_prev(t)) {
    1311                 :          0 :                         u = rb_entry(t, struct uprobe, rb_node);
    1312   [ #  #  #  # ]:          0 :                         if (u->inode != inode || u->offset < min)
    1313                 :            :                                 break;
    1314                 :          0 :                         list_add(&u->pending_list, head);
    1315                 :          0 :                         get_uprobe(u);
    1316                 :            :                 }
    1317         [ #  # ]:          0 :                 for (t = n; (t = rb_next(t)); ) {
    1318                 :          0 :                         u = rb_entry(t, struct uprobe, rb_node);
    1319   [ #  #  #  # ]:          0 :                         if (u->inode != inode || u->offset > max)
    1320                 :            :                                 break;
    1321                 :          0 :                         list_add(&u->pending_list, head);
    1322                 :          0 :                         get_uprobe(u);
    1323                 :            :                 }
    1324                 :            :         }
    1325                 :          0 :         spin_unlock(&uprobes_treelock);
    1326                 :          0 : }
    1327                 :            : 
    1328                 :            : /* @vma contains reference counter, not the probed instruction. */
    1329                 :          0 : static int delayed_ref_ctr_inc(struct vm_area_struct *vma)
    1330                 :            : {
    1331                 :          0 :         struct list_head *pos, *q;
    1332                 :          0 :         struct delayed_uprobe *du;
    1333                 :          0 :         unsigned long vaddr;
    1334                 :          0 :         int ret = 0, err = 0;
    1335                 :            : 
    1336                 :          0 :         mutex_lock(&delayed_uprobe_lock);
    1337         [ #  # ]:          0 :         list_for_each_safe(pos, q, &delayed_uprobe_list) {
    1338                 :          0 :                 du = list_entry(pos, struct delayed_uprobe, list);
    1339                 :            : 
    1340         [ #  # ]:          0 :                 if (du->mm != vma->vm_mm ||
    1341         [ #  # ]:          0 :                     !valid_ref_ctr_vma(du->uprobe, vma))
    1342                 :          0 :                         continue;
    1343                 :            : 
    1344                 :          0 :                 vaddr = offset_to_vaddr(vma, du->uprobe->ref_ctr_offset);
    1345                 :          0 :                 ret = __update_ref_ctr(vma->vm_mm, vaddr, 1);
    1346         [ #  # ]:          0 :                 if (ret) {
    1347                 :          0 :                         update_ref_ctr_warn(du->uprobe, vma->vm_mm, 1);
    1348         [ #  # ]:          0 :                         if (!err)
    1349                 :          0 :                                 err = ret;
    1350                 :            :                 }
    1351                 :          0 :                 delayed_uprobe_delete(du);
    1352                 :            :         }
    1353                 :          0 :         mutex_unlock(&delayed_uprobe_lock);
    1354                 :          0 :         return err;
    1355                 :            : }
    1356                 :            : 
    1357                 :            : /*
    1358                 :            :  * Called from mmap_region/vma_adjust with mm->mmap_sem acquired.
    1359                 :            :  *
    1360                 :            :  * Currently we ignore all errors and always return 0, the callers
    1361                 :            :  * can't handle the failure anyway.
    1362                 :            :  */
    1363                 :    1807602 : int uprobe_mmap(struct vm_area_struct *vma)
    1364                 :            : {
    1365                 :    1807602 :         struct list_head tmp_list;
    1366                 :    1807602 :         struct uprobe *uprobe, *u;
    1367                 :    1807602 :         struct inode *inode;
    1368                 :            : 
    1369         [ -  + ]:    1807602 :         if (no_uprobe_events())
    1370                 :            :                 return 0;
    1371                 :            : 
    1372         [ #  # ]:          0 :         if (vma->vm_file &&
    1373   [ #  #  #  # ]:          0 :             (vma->vm_flags & (VM_WRITE|VM_SHARED)) == VM_WRITE &&
    1374                 :          0 :             test_bit(MMF_HAS_UPROBES, &vma->vm_mm->flags))
    1375                 :          0 :                 delayed_ref_ctr_inc(vma);
    1376                 :            : 
    1377   [ #  #  #  # ]:          0 :         if (!valid_vma(vma, true))
    1378                 :            :                 return 0;
    1379                 :            : 
    1380         [ #  # ]:          0 :         inode = file_inode(vma->vm_file);
    1381         [ #  # ]:          0 :         if (!inode)
    1382                 :            :                 return 0;
    1383                 :            : 
    1384                 :          0 :         mutex_lock(uprobes_mmap_hash(inode));
    1385                 :          0 :         build_probe_list(inode, vma, vma->vm_start, vma->vm_end, &tmp_list);
    1386                 :            :         /*
    1387                 :            :          * We can race with uprobe_unregister(), this uprobe can be already
    1388                 :            :          * removed. But in this case filter_chain() must return false, all
    1389                 :            :          * consumers have gone away.
    1390                 :            :          */
    1391         [ #  # ]:          0 :         list_for_each_entry_safe(uprobe, u, &tmp_list, pending_list) {
    1392   [ #  #  #  # ]:          0 :                 if (!fatal_signal_pending(current) &&
    1393                 :          0 :                     filter_chain(uprobe, UPROBE_FILTER_MMAP, vma->vm_mm)) {
    1394                 :          0 :                         unsigned long vaddr = offset_to_vaddr(vma, uprobe->offset);
    1395                 :          0 :                         install_breakpoint(uprobe, vma->vm_mm, vma, vaddr);
    1396                 :            :                 }
    1397                 :          0 :                 put_uprobe(uprobe);
    1398                 :            :         }
    1399                 :          0 :         mutex_unlock(uprobes_mmap_hash(inode));
    1400                 :            : 
    1401                 :          0 :         return 0;
    1402                 :            : }
    1403                 :            : 
    1404                 :            : static bool
    1405                 :          0 : vma_has_uprobes(struct vm_area_struct *vma, unsigned long start, unsigned long end)
    1406                 :            : {
    1407                 :          0 :         loff_t min, max;
    1408                 :          0 :         struct inode *inode;
    1409                 :          0 :         struct rb_node *n;
    1410                 :            : 
    1411                 :          0 :         inode = file_inode(vma->vm_file);
    1412                 :            : 
    1413                 :          0 :         min = vaddr_to_offset(vma, start);
    1414                 :          0 :         max = min + (end - start) - 1;
    1415                 :            : 
    1416                 :          0 :         spin_lock(&uprobes_treelock);
    1417                 :          0 :         n = find_node_in_range(inode, min, max);
    1418                 :          0 :         spin_unlock(&uprobes_treelock);
    1419                 :            : 
    1420                 :          0 :         return !!n;
    1421                 :            : }
    1422                 :            : 
    1423                 :            : /*
    1424                 :            :  * Called in context of a munmap of a vma.
    1425                 :            :  */
    1426                 :    2837226 : void uprobe_munmap(struct vm_area_struct *vma, unsigned long start, unsigned long end)
    1427                 :            : {
    1428   [ -  +  -  - ]:    2837226 :         if (no_uprobe_events() || !valid_vma(vma, false))
    1429                 :            :                 return;
    1430                 :            : 
    1431         [ #  # ]:          0 :         if (!atomic_read(&vma->vm_mm->mm_users)) /* called by mmput() ? */
    1432                 :            :                 return;
    1433                 :            : 
    1434   [ #  #  #  # ]:          0 :         if (!test_bit(MMF_HAS_UPROBES, &vma->vm_mm->flags) ||
    1435                 :          0 :              test_bit(MMF_RECALC_UPROBES, &vma->vm_mm->flags))
    1436                 :          0 :                 return;
    1437                 :            : 
    1438         [ #  # ]:          0 :         if (vma_has_uprobes(vma, start, end))
    1439                 :          0 :                 set_bit(MMF_RECALC_UPROBES, &vma->vm_mm->flags);
    1440                 :            : }
    1441                 :            : 
    1442                 :            : /* Slot allocation for XOL */
    1443                 :          0 : static int xol_add_vma(struct mm_struct *mm, struct xol_area *area)
    1444                 :            : {
    1445                 :          0 :         struct vm_area_struct *vma;
    1446                 :          0 :         int ret;
    1447                 :            : 
    1448         [ #  # ]:          0 :         if (down_write_killable(&mm->mmap_sem))
    1449                 :            :                 return -EINTR;
    1450                 :            : 
    1451         [ #  # ]:          0 :         if (mm->uprobes_state.xol_area) {
    1452                 :          0 :                 ret = -EALREADY;
    1453                 :          0 :                 goto fail;
    1454                 :            :         }
    1455                 :            : 
    1456         [ #  # ]:          0 :         if (!area->vaddr) {
    1457                 :            :                 /* Try to map as high as possible, this is only a hint. */
    1458   [ #  #  #  # ]:          0 :                 area->vaddr = get_unmapped_area(NULL, TASK_SIZE - PAGE_SIZE,
    1459                 :            :                                                 PAGE_SIZE, 0, 0);
    1460         [ #  # ]:          0 :                 if (IS_ERR_VALUE(area->vaddr)) {
    1461                 :          0 :                         ret = area->vaddr;
    1462                 :          0 :                         goto fail;
    1463                 :            :                 }
    1464                 :            :         }
    1465                 :            : 
    1466                 :          0 :         vma = _install_special_mapping(mm, area->vaddr, PAGE_SIZE,
    1467                 :            :                                 VM_EXEC|VM_MAYEXEC|VM_DONTCOPY|VM_IO,
    1468                 :          0 :                                 &area->xol_mapping);
    1469         [ #  # ]:          0 :         if (IS_ERR(vma)) {
    1470                 :          0 :                 ret = PTR_ERR(vma);
    1471                 :          0 :                 goto fail;
    1472                 :            :         }
    1473                 :            : 
    1474                 :          0 :         ret = 0;
    1475                 :            :         /* pairs with get_xol_area() */
    1476                 :          0 :         smp_store_release(&mm->uprobes_state.xol_area, area); /* ^^^ */
    1477                 :          0 :  fail:
    1478                 :          0 :         up_write(&mm->mmap_sem);
    1479                 :            : 
    1480                 :          0 :         return ret;
    1481                 :            : }
    1482                 :            : 
    1483                 :          0 : static struct xol_area *__create_xol_area(unsigned long vaddr)
    1484                 :            : {
    1485                 :          0 :         struct mm_struct *mm = current->mm;
    1486                 :          0 :         uprobe_opcode_t insn = UPROBE_SWBP_INSN;
    1487                 :          0 :         struct xol_area *area;
    1488                 :            : 
    1489                 :          0 :         area = kmalloc(sizeof(*area), GFP_KERNEL);
    1490         [ #  # ]:          0 :         if (unlikely(!area))
    1491                 :          0 :                 goto out;
    1492                 :            : 
    1493                 :          0 :         area->bitmap = kcalloc(BITS_TO_LONGS(UINSNS_PER_PAGE), sizeof(long),
    1494                 :            :                                GFP_KERNEL);
    1495         [ #  # ]:          0 :         if (!area->bitmap)
    1496                 :          0 :                 goto free_area;
    1497                 :            : 
    1498                 :          0 :         area->xol_mapping.name = "[uprobes]";
    1499                 :          0 :         area->xol_mapping.fault = NULL;
    1500                 :          0 :         area->xol_mapping.pages = area->pages;
    1501                 :          0 :         area->pages[0] = alloc_page(GFP_HIGHUSER);
    1502         [ #  # ]:          0 :         if (!area->pages[0])
    1503                 :          0 :                 goto free_bitmap;
    1504                 :          0 :         area->pages[1] = NULL;
    1505                 :            : 
    1506                 :          0 :         area->vaddr = vaddr;
    1507                 :          0 :         init_waitqueue_head(&area->wq);
    1508                 :            :         /* Reserve the 1st slot for get_trampoline_vaddr() */
    1509                 :          0 :         set_bit(0, area->bitmap);
    1510                 :          0 :         atomic_set(&area->slot_count, 1);
    1511                 :          0 :         arch_uprobe_copy_ixol(area->pages[0], 0, &insn, UPROBE_SWBP_INSN_SIZE);
    1512                 :            : 
    1513         [ #  # ]:          0 :         if (!xol_add_vma(mm, area))
    1514                 :            :                 return area;
    1515                 :            : 
    1516                 :          0 :         __free_page(area->pages[0]);
    1517                 :          0 :  free_bitmap:
    1518                 :          0 :         kfree(area->bitmap);
    1519                 :          0 :  free_area:
    1520                 :          0 :         kfree(area);
    1521                 :            :  out:
    1522                 :            :         return NULL;
    1523                 :            : }
    1524                 :            : 
    1525                 :            : /*
    1526                 :            :  * get_xol_area - Allocate process's xol_area if necessary.
    1527                 :            :  * This area will be used for storing instructions for execution out of line.
    1528                 :            :  *
    1529                 :            :  * Returns the allocated area or NULL.
    1530                 :            :  */
    1531                 :          0 : static struct xol_area *get_xol_area(void)
    1532                 :            : {
    1533                 :          0 :         struct mm_struct *mm = current->mm;
    1534                 :          0 :         struct xol_area *area;
    1535                 :            : 
    1536   [ #  #  #  # ]:          0 :         if (!mm->uprobes_state.xol_area)
    1537                 :          0 :                 __create_xol_area(0);
    1538                 :            : 
    1539                 :            :         /* Pairs with xol_add_vma() smp_store_release() */
    1540   [ #  #  #  # ]:          0 :         area = READ_ONCE(mm->uprobes_state.xol_area); /* ^^^ */
    1541                 :          0 :         return area;
    1542                 :            : }
    1543                 :            : 
    1544                 :            : /*
    1545                 :            :  * uprobe_clear_state - Free the area allocated for slots.
    1546                 :            :  */
    1547                 :      44820 : void uprobe_clear_state(struct mm_struct *mm)
    1548                 :            : {
    1549                 :      44820 :         struct xol_area *area = mm->uprobes_state.xol_area;
    1550                 :            : 
    1551                 :      44820 :         mutex_lock(&delayed_uprobe_lock);
    1552                 :      44820 :         delayed_uprobe_remove(NULL, mm);
    1553                 :      44820 :         mutex_unlock(&delayed_uprobe_lock);
    1554                 :            : 
    1555         [ -  + ]:      44820 :         if (!area)
    1556                 :            :                 return;
    1557                 :            : 
    1558                 :          0 :         put_page(area->pages[0]);
    1559                 :          0 :         kfree(area->bitmap);
    1560                 :          0 :         kfree(area);
    1561                 :            : }
    1562                 :            : 
    1563                 :      22896 : void uprobe_start_dup_mmap(void)
    1564                 :            : {
    1565                 :      22896 :         percpu_down_read(&dup_mmap_sem);
    1566                 :      22896 : }
    1567                 :            : 
    1568                 :      22896 : void uprobe_end_dup_mmap(void)
    1569                 :            : {
    1570                 :      22896 :         percpu_up_read(&dup_mmap_sem);
    1571                 :      22896 : }
    1572                 :            : 
    1573                 :      22896 : void uprobe_dup_mmap(struct mm_struct *oldmm, struct mm_struct *newmm)
    1574                 :            : {
    1575         [ -  + ]:      22896 :         if (test_bit(MMF_HAS_UPROBES, &oldmm->flags)) {
    1576                 :          0 :                 set_bit(MMF_HAS_UPROBES, &newmm->flags);
    1577                 :            :                 /* unconditionally, dup_mmap() skips VM_DONTCOPY vmas */
    1578                 :          0 :                 set_bit(MMF_RECALC_UPROBES, &newmm->flags);
    1579                 :            :         }
    1580                 :      22896 : }
    1581                 :            : 
    1582                 :            : /*
    1583                 :            :  *  - search for a free slot.
    1584                 :            :  */
    1585                 :          0 : static unsigned long xol_take_insn_slot(struct xol_area *area)
    1586                 :            : {
    1587                 :          0 :         unsigned long slot_addr;
    1588                 :          0 :         int slot_nr;
    1589                 :            : 
    1590                 :          0 :         do {
    1591                 :          0 :                 slot_nr = find_first_zero_bit(area->bitmap, UINSNS_PER_PAGE);
    1592         [ #  # ]:          0 :                 if (slot_nr < UINSNS_PER_PAGE) {
    1593         [ #  # ]:          0 :                         if (!test_and_set_bit(slot_nr, area->bitmap))
    1594                 :            :                                 break;
    1595                 :            : 
    1596                 :          0 :                         slot_nr = UINSNS_PER_PAGE;
    1597                 :          0 :                         continue;
    1598                 :            :                 }
    1599   [ #  #  #  # ]:          0 :                 wait_event(area->wq, (atomic_read(&area->slot_count) < UINSNS_PER_PAGE));
    1600         [ #  # ]:          0 :         } while (slot_nr >= UINSNS_PER_PAGE);
    1601                 :            : 
    1602                 :          0 :         slot_addr = area->vaddr + (slot_nr * UPROBE_XOL_SLOT_BYTES);
    1603                 :          0 :         atomic_inc(&area->slot_count);
    1604                 :            : 
    1605                 :          0 :         return slot_addr;
    1606                 :            : }
    1607                 :            : 
    1608                 :            : /*
    1609                 :            :  * xol_get_insn_slot - allocate a slot for xol.
    1610                 :            :  * Returns the allocated slot address or 0.
    1611                 :            :  */
    1612                 :          0 : static unsigned long xol_get_insn_slot(struct uprobe *uprobe)
    1613                 :            : {
    1614                 :          0 :         struct xol_area *area;
    1615                 :          0 :         unsigned long xol_vaddr;
    1616                 :            : 
    1617         [ #  # ]:          0 :         area = get_xol_area();
    1618         [ #  # ]:          0 :         if (!area)
    1619                 :            :                 return 0;
    1620                 :            : 
    1621                 :          0 :         xol_vaddr = xol_take_insn_slot(area);
    1622         [ #  # ]:          0 :         if (unlikely(!xol_vaddr))
    1623                 :            :                 return 0;
    1624                 :            : 
    1625                 :          0 :         arch_uprobe_copy_ixol(area->pages[0], xol_vaddr,
    1626                 :          0 :                               &uprobe->arch.ixol, sizeof(uprobe->arch.ixol));
    1627                 :            : 
    1628                 :          0 :         return xol_vaddr;
    1629                 :            : }
    1630                 :            : 
    1631                 :            : /*
    1632                 :            :  * xol_free_insn_slot - If slot was earlier allocated by
    1633                 :            :  * @xol_get_insn_slot(), make the slot available for
    1634                 :            :  * subsequent requests.
    1635                 :            :  */
    1636                 :          0 : static void xol_free_insn_slot(struct task_struct *tsk)
    1637                 :            : {
    1638                 :          0 :         struct xol_area *area;
    1639                 :          0 :         unsigned long vma_end;
    1640                 :          0 :         unsigned long slot_addr;
    1641                 :            : 
    1642   [ #  #  #  #  :          0 :         if (!tsk->mm || !tsk->mm->uprobes_state.xol_area || !tsk->utask)
                   #  # ]
    1643                 :            :                 return;
    1644                 :            : 
    1645                 :          0 :         slot_addr = tsk->utask->xol_vaddr;
    1646         [ #  # ]:          0 :         if (unlikely(!slot_addr))
    1647                 :            :                 return;
    1648                 :            : 
    1649                 :          0 :         area = tsk->mm->uprobes_state.xol_area;
    1650                 :          0 :         vma_end = area->vaddr + PAGE_SIZE;
    1651   [ #  #  #  # ]:          0 :         if (area->vaddr <= slot_addr && slot_addr < vma_end) {
    1652                 :          0 :                 unsigned long offset;
    1653                 :          0 :                 int slot_nr;
    1654                 :            : 
    1655                 :          0 :                 offset = slot_addr - area->vaddr;
    1656                 :          0 :                 slot_nr = offset / UPROBE_XOL_SLOT_BYTES;
    1657         [ #  # ]:          0 :                 if (slot_nr >= UINSNS_PER_PAGE)
    1658                 :            :                         return;
    1659                 :            : 
    1660                 :          0 :                 clear_bit(slot_nr, area->bitmap);
    1661                 :          0 :                 atomic_dec(&area->slot_count);
    1662                 :          0 :                 smp_mb__after_atomic(); /* pairs with prepare_to_wait() */
    1663         [ #  # ]:          0 :                 if (waitqueue_active(&area->wq))
    1664                 :          0 :                         wake_up(&area->wq);
    1665                 :            : 
    1666                 :          0 :                 tsk->utask->xol_vaddr = 0;
    1667                 :            :         }
    1668                 :            : }
    1669                 :            : 
    1670                 :          0 : void __weak arch_uprobe_copy_ixol(struct page *page, unsigned long vaddr,
    1671                 :            :                                   void *src, unsigned long len)
    1672                 :            : {
    1673                 :            :         /* Initialize the slot */
    1674                 :          0 :         copy_to_page(page, vaddr, src, len);
    1675                 :            : 
    1676                 :            :         /*
    1677                 :            :          * We probably need flush_icache_user_range() but it needs vma.
    1678                 :            :          * This should work on most of architectures by default. If
    1679                 :            :          * architecture needs to do something different it can define
    1680                 :            :          * its own version of the function.
    1681                 :            :          */
    1682                 :          0 :         flush_dcache_page(page);
    1683                 :          0 : }
    1684                 :            : 
    1685                 :            : /**
    1686                 :            :  * uprobe_get_swbp_addr - compute address of swbp given post-swbp regs
    1687                 :            :  * @regs: Reflects the saved state of the task after it has hit a breakpoint
    1688                 :            :  * instruction.
    1689                 :            :  * Return the address of the breakpoint instruction.
    1690                 :            :  */
    1691                 :          0 : unsigned long __weak uprobe_get_swbp_addr(struct pt_regs *regs)
    1692                 :            : {
    1693                 :          0 :         return instruction_pointer(regs) - UPROBE_SWBP_INSN_SIZE;
    1694                 :            : }
    1695                 :            : 
    1696                 :         70 : unsigned long uprobe_get_trap_addr(struct pt_regs *regs)
    1697                 :            : {
    1698         [ -  + ]:         70 :         struct uprobe_task *utask = current->utask;
    1699                 :            : 
    1700   [ -  +  -  - ]:         70 :         if (unlikely(utask && utask->active_uprobe))
    1701                 :          0 :                 return utask->vaddr;
    1702                 :            : 
    1703                 :         70 :         return instruction_pointer(regs);
    1704                 :            : }
    1705                 :            : 
    1706                 :          0 : static struct return_instance *free_ret_instance(struct return_instance *ri)
    1707                 :            : {
    1708                 :          0 :         struct return_instance *next = ri->next;
    1709                 :          0 :         put_uprobe(ri->uprobe);
    1710                 :          0 :         kfree(ri);
    1711                 :          0 :         return next;
    1712                 :            : }
    1713                 :            : 
    1714                 :            : /*
    1715                 :            :  * Called with no locks held.
    1716                 :            :  * Called in context of an exiting or an exec-ing thread.
    1717                 :            :  */
    1718                 :      46500 : void uprobe_free_utask(struct task_struct *t)
    1719                 :            : {
    1720                 :      46500 :         struct uprobe_task *utask = t->utask;
    1721                 :      46500 :         struct return_instance *ri;
    1722                 :            : 
    1723         [ -  + ]:      46500 :         if (!utask)
    1724                 :            :                 return;
    1725                 :            : 
    1726         [ #  # ]:          0 :         if (utask->active_uprobe)
    1727                 :          0 :                 put_uprobe(utask->active_uprobe);
    1728                 :            : 
    1729                 :          0 :         ri = utask->return_instances;
    1730         [ #  # ]:          0 :         while (ri)
    1731                 :          0 :                 ri = free_ret_instance(ri);
    1732                 :            : 
    1733                 :          0 :         xol_free_insn_slot(t);
    1734                 :          0 :         kfree(utask);
    1735                 :          0 :         t->utask = NULL;
    1736                 :            : }
    1737                 :            : 
    1738                 :            : /*
    1739                 :            :  * Allocate a uprobe_task object for the task if if necessary.
    1740                 :            :  * Called when the thread hits a breakpoint.
    1741                 :            :  *
    1742                 :            :  * Returns:
    1743                 :            :  * - pointer to new uprobe_task on success
    1744                 :            :  * - NULL otherwise
    1745                 :            :  */
    1746                 :          0 : static struct uprobe_task *get_utask(void)
    1747                 :            : {
    1748         [ #  # ]:          0 :         if (!current->utask)
    1749                 :          0 :                 current->utask = kzalloc(sizeof(struct uprobe_task), GFP_KERNEL);
    1750                 :          0 :         return current->utask;
    1751                 :            : }
    1752                 :            : 
    1753                 :            : static int dup_utask(struct task_struct *t, struct uprobe_task *o_utask)
    1754                 :            : {
    1755                 :            :         struct uprobe_task *n_utask;
    1756                 :            :         struct return_instance **p, *o, *n;
    1757                 :            : 
    1758                 :            :         n_utask = kzalloc(sizeof(struct uprobe_task), GFP_KERNEL);
    1759                 :            :         if (!n_utask)
    1760                 :            :                 return -ENOMEM;
    1761                 :            :         t->utask = n_utask;
    1762                 :            : 
    1763                 :            :         p = &n_utask->return_instances;
    1764                 :            :         for (o = o_utask->return_instances; o; o = o->next) {
    1765                 :            :                 n = kmalloc(sizeof(struct return_instance), GFP_KERNEL);
    1766                 :            :                 if (!n)
    1767                 :            :                         return -ENOMEM;
    1768                 :            : 
    1769                 :            :                 *n = *o;
    1770                 :            :                 get_uprobe(n->uprobe);
    1771                 :            :                 n->next = NULL;
    1772                 :            : 
    1773                 :            :                 *p = n;
    1774                 :            :                 p = &n->next;
    1775                 :            :                 n_utask->depth++;
    1776                 :            :         }
    1777                 :            : 
    1778                 :            :         return 0;
    1779                 :            : }
    1780                 :            : 
    1781                 :            : static void uprobe_warn(struct task_struct *t, const char *msg)
    1782                 :            : {
    1783                 :            :         pr_warn("uprobe: %s:%d failed to %s\n",
    1784                 :            :                         current->comm, current->pid, msg);
    1785                 :            : }
    1786                 :            : 
    1787                 :          0 : static void dup_xol_work(struct callback_head *work)
    1788                 :            : {
    1789         [ #  # ]:          0 :         if (current->flags & PF_EXITING)
    1790                 :            :                 return;
    1791                 :            : 
    1792   [ #  #  #  # ]:          0 :         if (!__create_xol_area(current->utask->dup_xol_addr) &&
    1793                 :          0 :                         !fatal_signal_pending(current))
    1794                 :          0 :                 uprobe_warn(current, "dup xol area");
    1795                 :            : }
    1796                 :            : 
    1797                 :            : /*
    1798                 :            :  * Called in context of a new clone/fork from copy_process.
    1799                 :            :  */
    1800                 :      26013 : void uprobe_copy_process(struct task_struct *t, unsigned long flags)
    1801                 :            : {
    1802         [ -  + ]:      26013 :         struct uprobe_task *utask = current->utask;
    1803                 :      26013 :         struct mm_struct *mm = current->mm;
    1804                 :      26013 :         struct xol_area *area;
    1805                 :            : 
    1806                 :      26013 :         t->utask = NULL;
    1807                 :            : 
    1808   [ -  +  -  - ]:      26013 :         if (!utask || !utask->return_instances)
    1809                 :            :                 return;
    1810                 :            : 
    1811   [ #  #  #  # ]:          0 :         if (mm == t->mm && !(flags & CLONE_VFORK))
    1812                 :            :                 return;
    1813                 :            : 
    1814         [ #  # ]:          0 :         if (dup_utask(t, utask))
    1815                 :          0 :                 return uprobe_warn(t, "dup ret instances");
    1816                 :            : 
    1817                 :            :         /* The task can fork() after dup_xol_work() fails */
    1818                 :          0 :         area = mm->uprobes_state.xol_area;
    1819         [ #  # ]:          0 :         if (!area)
    1820                 :          0 :                 return uprobe_warn(t, "dup xol area");
    1821                 :            : 
    1822         [ #  # ]:          0 :         if (mm == t->mm)
    1823                 :            :                 return;
    1824                 :            : 
    1825                 :          0 :         t->utask->dup_xol_addr = area->vaddr;
    1826                 :          0 :         init_task_work(&t->utask->dup_xol_work, dup_xol_work);
    1827                 :          0 :         task_work_add(t, &t->utask->dup_xol_work, true);
    1828                 :            : }
    1829                 :            : 
    1830                 :            : /*
    1831                 :            :  * Current area->vaddr notion assume the trampoline address is always
    1832                 :            :  * equal area->vaddr.
    1833                 :            :  *
    1834                 :            :  * Returns -1 in case the xol_area is not allocated.
    1835                 :            :  */
    1836                 :          0 : static unsigned long get_trampoline_vaddr(void)
    1837                 :            : {
    1838                 :          0 :         struct xol_area *area;
    1839                 :          0 :         unsigned long trampoline_vaddr = -1;
    1840                 :            : 
    1841                 :            :         /* Pairs with xol_add_vma() smp_store_release() */
    1842                 :          0 :         area = READ_ONCE(current->mm->uprobes_state.xol_area); /* ^^^ */
    1843   [ #  #  #  # ]:          0 :         if (area)
    1844                 :          0 :                 trampoline_vaddr = area->vaddr;
    1845                 :            : 
    1846                 :          0 :         return trampoline_vaddr;
    1847                 :            : }
    1848                 :            : 
    1849                 :          0 : static void cleanup_return_instances(struct uprobe_task *utask, bool chained,
    1850                 :            :                                         struct pt_regs *regs)
    1851                 :            : {
    1852                 :          0 :         struct return_instance *ri = utask->return_instances;
    1853                 :          0 :         enum rp_check ctx = chained ? RP_CHECK_CHAIN_CALL : RP_CHECK_CALL;
    1854                 :            : 
    1855   [ #  #  #  # ]:          0 :         while (ri && !arch_uretprobe_is_alive(ri, ctx, regs)) {
    1856                 :          0 :                 ri = free_ret_instance(ri);
    1857                 :          0 :                 utask->depth--;
    1858                 :            :         }
    1859                 :          0 :         utask->return_instances = ri;
    1860                 :          0 : }
    1861                 :            : 
    1862                 :          0 : static void prepare_uretprobe(struct uprobe *uprobe, struct pt_regs *regs)
    1863                 :            : {
    1864                 :          0 :         struct return_instance *ri;
    1865                 :          0 :         struct uprobe_task *utask;
    1866                 :          0 :         unsigned long orig_ret_vaddr, trampoline_vaddr;
    1867                 :          0 :         bool chained;
    1868                 :            : 
    1869   [ #  #  #  # ]:          0 :         if (!get_xol_area())
    1870                 :            :                 return;
    1871                 :            : 
    1872                 :          0 :         utask = get_utask();
    1873         [ #  # ]:          0 :         if (!utask)
    1874                 :            :                 return;
    1875                 :            : 
    1876         [ #  # ]:          0 :         if (utask->depth >= MAX_URETPROBE_DEPTH) {
    1877         [ #  # ]:          0 :                 printk_ratelimited(KERN_INFO "uprobe: omit uretprobe due to"
    1878                 :            :                                 " nestedness limit pid/tgid=%d/%d\n",
    1879                 :            :                                 current->pid, current->tgid);
    1880                 :          0 :                 return;
    1881                 :            :         }
    1882                 :            : 
    1883                 :          0 :         ri = kmalloc(sizeof(struct return_instance), GFP_KERNEL);
    1884         [ #  # ]:          0 :         if (!ri)
    1885                 :            :                 return;
    1886                 :            : 
    1887         [ #  # ]:          0 :         trampoline_vaddr = get_trampoline_vaddr();
    1888                 :          0 :         orig_ret_vaddr = arch_uretprobe_hijack_return_addr(trampoline_vaddr, regs);
    1889         [ #  # ]:          0 :         if (orig_ret_vaddr == -1)
    1890                 :          0 :                 goto fail;
    1891                 :            : 
    1892                 :            :         /* drop the entries invalidated by longjmp() */
    1893                 :          0 :         chained = (orig_ret_vaddr == trampoline_vaddr);
    1894                 :          0 :         cleanup_return_instances(utask, chained, regs);
    1895                 :            : 
    1896                 :            :         /*
    1897                 :            :          * We don't want to keep trampoline address in stack, rather keep the
    1898                 :            :          * original return address of first caller thru all the consequent
    1899                 :            :          * instances. This also makes breakpoint unwrapping easier.
    1900                 :            :          */
    1901         [ #  # ]:          0 :         if (chained) {
    1902         [ #  # ]:          0 :                 if (!utask->return_instances) {
    1903                 :            :                         /*
    1904                 :            :                          * This situation is not possible. Likely we have an
    1905                 :            :                          * attack from user-space.
    1906                 :            :                          */
    1907                 :          0 :                         uprobe_warn(current, "handle tail call");
    1908                 :          0 :                         goto fail;
    1909                 :            :                 }
    1910                 :          0 :                 orig_ret_vaddr = utask->return_instances->orig_ret_vaddr;
    1911                 :            :         }
    1912                 :            : 
    1913                 :          0 :         ri->uprobe = get_uprobe(uprobe);
    1914                 :          0 :         ri->func = instruction_pointer(regs);
    1915                 :          0 :         ri->stack = user_stack_pointer(regs);
    1916                 :          0 :         ri->orig_ret_vaddr = orig_ret_vaddr;
    1917                 :          0 :         ri->chained = chained;
    1918                 :            : 
    1919                 :          0 :         utask->depth++;
    1920                 :          0 :         ri->next = utask->return_instances;
    1921                 :          0 :         utask->return_instances = ri;
    1922                 :            : 
    1923                 :          0 :         return;
    1924                 :          0 :  fail:
    1925                 :          0 :         kfree(ri);
    1926                 :            : }
    1927                 :            : 
    1928                 :            : /* Prepare to single-step probed instruction out of line. */
    1929                 :            : static int
    1930                 :          0 : pre_ssout(struct uprobe *uprobe, struct pt_regs *regs, unsigned long bp_vaddr)
    1931                 :            : {
    1932                 :          0 :         struct uprobe_task *utask;
    1933                 :          0 :         unsigned long xol_vaddr;
    1934                 :          0 :         int err;
    1935                 :            : 
    1936                 :          0 :         utask = get_utask();
    1937         [ #  # ]:          0 :         if (!utask)
    1938                 :            :                 return -ENOMEM;
    1939                 :            : 
    1940                 :          0 :         xol_vaddr = xol_get_insn_slot(uprobe);
    1941         [ #  # ]:          0 :         if (!xol_vaddr)
    1942                 :            :                 return -ENOMEM;
    1943                 :            : 
    1944                 :          0 :         utask->xol_vaddr = xol_vaddr;
    1945                 :          0 :         utask->vaddr = bp_vaddr;
    1946                 :            : 
    1947                 :          0 :         err = arch_uprobe_pre_xol(&uprobe->arch, regs);
    1948         [ #  # ]:          0 :         if (unlikely(err)) {
    1949                 :          0 :                 xol_free_insn_slot(current);
    1950                 :          0 :                 return err;
    1951                 :            :         }
    1952                 :            : 
    1953                 :          0 :         utask->active_uprobe = uprobe;
    1954                 :          0 :         utask->state = UTASK_SSTEP;
    1955                 :          0 :         return 0;
    1956                 :            : }
    1957                 :            : 
    1958                 :            : /*
    1959                 :            :  * If we are singlestepping, then ensure this thread is not connected to
    1960                 :            :  * non-fatal signals until completion of singlestep.  When xol insn itself
    1961                 :            :  * triggers the signal,  restart the original insn even if the task is
    1962                 :            :  * already SIGKILL'ed (since coredump should report the correct ip).  This
    1963                 :            :  * is even more important if the task has a handler for SIGSEGV/etc, The
    1964                 :            :  * _same_ instruction should be repeated again after return from the signal
    1965                 :            :  * handler, and SSTEP can never finish in this case.
    1966                 :            :  */
    1967                 :      10337 : bool uprobe_deny_signal(void)
    1968                 :            : {
    1969         [ -  + ]:      10337 :         struct task_struct *t = current;
    1970                 :      10337 :         struct uprobe_task *utask = t->utask;
    1971                 :            : 
    1972   [ -  +  -  - ]:      10337 :         if (likely(!utask || !utask->active_uprobe))
    1973                 :            :                 return false;
    1974                 :            : 
    1975         [ #  # ]:          0 :         WARN_ON_ONCE(utask->state != UTASK_SSTEP);
    1976                 :            : 
    1977         [ #  # ]:          0 :         if (signal_pending(t)) {
    1978                 :          0 :                 spin_lock_irq(&t->sighand->siglock);
    1979                 :          0 :                 clear_tsk_thread_flag(t, TIF_SIGPENDING);
    1980                 :          0 :                 spin_unlock_irq(&t->sighand->siglock);
    1981                 :            : 
    1982   [ #  #  #  # ]:          0 :                 if (__fatal_signal_pending(t) || arch_uprobe_xol_was_trapped(t)) {
    1983                 :          0 :                         utask->state = UTASK_SSTEP_TRAPPED;
    1984                 :          0 :                         set_tsk_thread_flag(t, TIF_UPROBE);
    1985                 :            :                 }
    1986                 :            :         }
    1987                 :            : 
    1988                 :            :         return true;
    1989                 :            : }
    1990                 :            : 
    1991                 :          0 : static void mmf_recalc_uprobes(struct mm_struct *mm)
    1992                 :            : {
    1993                 :          0 :         struct vm_area_struct *vma;
    1994                 :            : 
    1995         [ #  # ]:          0 :         for (vma = mm->mmap; vma; vma = vma->vm_next) {
    1996   [ #  #  #  # ]:          0 :                 if (!valid_vma(vma, false))
    1997                 :          0 :                         continue;
    1998                 :            :                 /*
    1999                 :            :                  * This is not strictly accurate, we can race with
    2000                 :            :                  * uprobe_unregister() and see the already removed
    2001                 :            :                  * uprobe if delete_uprobe() was not yet called.
    2002                 :            :                  * Or this uprobe can be filtered out.
    2003                 :            :                  */
    2004         [ #  # ]:          0 :                 if (vma_has_uprobes(vma, vma->vm_start, vma->vm_end))
    2005                 :            :                         return;
    2006                 :            :         }
    2007                 :            : 
    2008                 :          0 :         clear_bit(MMF_HAS_UPROBES, &mm->flags);
    2009                 :            : }
    2010                 :            : 
    2011                 :          0 : static int is_trap_at_addr(struct mm_struct *mm, unsigned long vaddr)
    2012                 :            : {
    2013                 :          0 :         struct page *page;
    2014                 :          0 :         uprobe_opcode_t opcode;
    2015                 :          0 :         int result;
    2016                 :            : 
    2017                 :          0 :         pagefault_disable();
    2018                 :          0 :         result = __get_user(opcode, (uprobe_opcode_t __user *)vaddr);
    2019                 :          0 :         pagefault_enable();
    2020                 :            : 
    2021         [ #  # ]:          0 :         if (likely(result == 0))
    2022                 :          0 :                 goto out;
    2023                 :            : 
    2024                 :            :         /*
    2025                 :            :          * The NULL 'tsk' here ensures that any faults that occur here
    2026                 :            :          * will not be accounted to the task.  'mm' *is* current->mm,
    2027                 :            :          * but we treat this as a 'remote' access since it is
    2028                 :            :          * essentially a kernel access to the memory.
    2029                 :            :          */
    2030                 :          0 :         result = get_user_pages_remote(NULL, mm, vaddr, 1, FOLL_FORCE, &page,
    2031                 :            :                         NULL, NULL);
    2032         [ #  # ]:          0 :         if (result < 0)
    2033                 :            :                 return result;
    2034                 :            : 
    2035                 :          0 :         copy_from_page(page, vaddr, &opcode, UPROBE_SWBP_INSN_SIZE);
    2036                 :          0 :         put_page(page);
    2037                 :          0 :  out:
    2038                 :            :         /* This needs to return true for any variant of the trap insn */
    2039                 :          0 :         return is_trap_insn(&opcode);
    2040                 :            : }
    2041                 :            : 
    2042                 :          0 : static struct uprobe *find_active_uprobe(unsigned long bp_vaddr, int *is_swbp)
    2043                 :            : {
    2044                 :          0 :         struct mm_struct *mm = current->mm;
    2045                 :          0 :         struct uprobe *uprobe = NULL;
    2046                 :          0 :         struct vm_area_struct *vma;
    2047                 :            : 
    2048                 :          0 :         down_read(&mm->mmap_sem);
    2049                 :          0 :         vma = find_vma(mm, bp_vaddr);
    2050   [ #  #  #  # ]:          0 :         if (vma && vma->vm_start <= bp_vaddr) {
    2051   [ #  #  #  # ]:          0 :                 if (valid_vma(vma, false)) {
    2052                 :          0 :                         struct inode *inode = file_inode(vma->vm_file);
    2053                 :          0 :                         loff_t offset = vaddr_to_offset(vma, bp_vaddr);
    2054                 :            : 
    2055                 :          0 :                         uprobe = find_uprobe(inode, offset);
    2056                 :            :                 }
    2057                 :            : 
    2058         [ #  # ]:          0 :                 if (!uprobe)
    2059                 :          0 :                         *is_swbp = is_trap_at_addr(mm, bp_vaddr);
    2060                 :            :         } else {
    2061                 :          0 :                 *is_swbp = -EFAULT;
    2062                 :            :         }
    2063                 :            : 
    2064   [ #  #  #  # ]:          0 :         if (!uprobe && test_and_clear_bit(MMF_RECALC_UPROBES, &mm->flags))
    2065                 :          0 :                 mmf_recalc_uprobes(mm);
    2066                 :          0 :         up_read(&mm->mmap_sem);
    2067                 :            : 
    2068                 :          0 :         return uprobe;
    2069                 :            : }
    2070                 :            : 
    2071                 :          0 : static void handler_chain(struct uprobe *uprobe, struct pt_regs *regs)
    2072                 :            : {
    2073                 :          0 :         struct uprobe_consumer *uc;
    2074                 :          0 :         int remove = UPROBE_HANDLER_REMOVE;
    2075                 :          0 :         bool need_prep = false; /* prepare return uprobe, when needed */
    2076                 :            : 
    2077                 :          0 :         down_read(&uprobe->register_rwsem);
    2078         [ #  # ]:          0 :         for (uc = uprobe->consumers; uc; uc = uc->next) {
    2079                 :          0 :                 int rc = 0;
    2080                 :            : 
    2081         [ #  # ]:          0 :                 if (uc->handler) {
    2082                 :          0 :                         rc = uc->handler(uc, regs);
    2083         [ #  # ]:          0 :                         WARN(rc & ~UPROBE_HANDLER_MASK,
    2084                 :            :                                 "bad rc=0x%x from %ps()\n", rc, uc->handler);
    2085                 :            :                 }
    2086                 :            : 
    2087         [ #  # ]:          0 :                 if (uc->ret_handler)
    2088                 :          0 :                         need_prep = true;
    2089                 :            : 
    2090                 :          0 :                 remove &= rc;
    2091                 :            :         }
    2092                 :            : 
    2093         [ #  # ]:          0 :         if (need_prep && !remove)
    2094                 :          0 :                 prepare_uretprobe(uprobe, regs); /* put bp at return */
    2095                 :            : 
    2096   [ #  #  #  # ]:          0 :         if (remove && uprobe->consumers) {
    2097         [ #  # ]:          0 :                 WARN_ON(!uprobe_is_active(uprobe));
    2098                 :          0 :                 unapply_uprobe(uprobe, current->mm);
    2099                 :            :         }
    2100                 :          0 :         up_read(&uprobe->register_rwsem);
    2101                 :          0 : }
    2102                 :            : 
    2103                 :            : static void
    2104                 :            : handle_uretprobe_chain(struct return_instance *ri, struct pt_regs *regs)
    2105                 :            : {
    2106                 :            :         struct uprobe *uprobe = ri->uprobe;
    2107                 :            :         struct uprobe_consumer *uc;
    2108                 :            : 
    2109                 :            :         down_read(&uprobe->register_rwsem);
    2110                 :            :         for (uc = uprobe->consumers; uc; uc = uc->next) {
    2111                 :            :                 if (uc->ret_handler)
    2112                 :            :                         uc->ret_handler(uc, ri->func, regs);
    2113                 :            :         }
    2114                 :            :         up_read(&uprobe->register_rwsem);
    2115                 :            : }
    2116                 :            : 
    2117                 :          0 : static struct return_instance *find_next_ret_chain(struct return_instance *ri)
    2118                 :            : {
    2119                 :          0 :         bool chained;
    2120                 :            : 
    2121                 :          0 :         do {
    2122                 :          0 :                 chained = ri->chained;
    2123                 :          0 :                 ri = ri->next;       /* can't be NULL if chained */
    2124         [ #  # ]:          0 :         } while (chained);
    2125                 :            : 
    2126                 :          0 :         return ri;
    2127                 :            : }
    2128                 :            : 
    2129                 :          0 : static void handle_trampoline(struct pt_regs *regs)
    2130                 :            : {
    2131                 :          0 :         struct uprobe_task *utask;
    2132                 :          0 :         struct return_instance *ri, *next;
    2133                 :          0 :         bool valid;
    2134                 :            : 
    2135         [ #  # ]:          0 :         utask = current->utask;
    2136         [ #  # ]:          0 :         if (!utask)
    2137                 :          0 :                 goto sigill;
    2138                 :            : 
    2139                 :          0 :         ri = utask->return_instances;
    2140         [ #  # ]:          0 :         if (!ri)
    2141                 :          0 :                 goto sigill;
    2142                 :            : 
    2143                 :          0 :         do {
    2144                 :            :                 /*
    2145                 :            :                  * We should throw out the frames invalidated by longjmp().
    2146                 :            :                  * If this chain is valid, then the next one should be alive
    2147                 :            :                  * or NULL; the latter case means that nobody but ri->func
    2148                 :            :                  * could hit this trampoline on return. TODO: sigaltstack().
    2149                 :            :                  */
    2150                 :          0 :                 next = find_next_ret_chain(ri);
    2151   [ #  #  #  # ]:          0 :                 valid = !next || arch_uretprobe_is_alive(next, RP_CHECK_RET, regs);
    2152                 :            : 
    2153                 :          0 :                 instruction_pointer_set(regs, ri->orig_ret_vaddr);
    2154                 :          0 :                 do {
    2155         [ #  # ]:          0 :                         if (valid)
    2156                 :          0 :                                 handle_uretprobe_chain(ri, regs);
    2157                 :          0 :                         ri = free_ret_instance(ri);
    2158                 :          0 :                         utask->depth--;
    2159         [ #  # ]:          0 :                 } while (ri != next);
    2160         [ #  # ]:          0 :         } while (!valid);
    2161                 :            : 
    2162                 :          0 :         utask->return_instances = ri;
    2163                 :          0 :         return;
    2164                 :            : 
    2165                 :          0 :  sigill:
    2166                 :          0 :         uprobe_warn(current, "handle uretprobe, sending SIGILL.");
    2167                 :          0 :         force_sig(SIGILL);
    2168                 :            : 
    2169                 :            : }
    2170                 :            : 
    2171                 :          0 : bool __weak arch_uprobe_ignore(struct arch_uprobe *aup, struct pt_regs *regs)
    2172                 :            : {
    2173                 :          0 :         return false;
    2174                 :            : }
    2175                 :            : 
    2176                 :          0 : bool __weak arch_uretprobe_is_alive(struct return_instance *ret, enum rp_check ctx,
    2177                 :            :                                         struct pt_regs *regs)
    2178                 :            : {
    2179                 :          0 :         return true;
    2180                 :            : }
    2181                 :            : 
    2182                 :            : /*
    2183                 :            :  * Run handler and ask thread to singlestep.
    2184                 :            :  * Ensure all non-fatal signals cannot interrupt thread while it singlesteps.
    2185                 :            :  */
    2186                 :          0 : static void handle_swbp(struct pt_regs *regs)
    2187                 :            : {
    2188                 :          0 :         struct uprobe *uprobe;
    2189                 :          0 :         unsigned long bp_vaddr;
    2190                 :          0 :         int uninitialized_var(is_swbp);
    2191                 :            : 
    2192                 :          0 :         bp_vaddr = uprobe_get_swbp_addr(regs);
    2193   [ #  #  #  # ]:          0 :         if (bp_vaddr == get_trampoline_vaddr())
    2194                 :          0 :                 return handle_trampoline(regs);
    2195                 :            : 
    2196                 :          0 :         uprobe = find_active_uprobe(bp_vaddr, &is_swbp);
    2197         [ #  # ]:          0 :         if (!uprobe) {
    2198         [ #  # ]:          0 :                 if (is_swbp > 0) {
    2199                 :            :                         /* No matching uprobe; signal SIGTRAP. */
    2200                 :          0 :                         send_sig(SIGTRAP, current, 0);
    2201                 :            :                 } else {
    2202                 :            :                         /*
    2203                 :            :                          * Either we raced with uprobe_unregister() or we can't
    2204                 :            :                          * access this memory. The latter is only possible if
    2205                 :            :                          * another thread plays with our ->mm. In both cases
    2206                 :            :                          * we can simply restart. If this vma was unmapped we
    2207                 :            :                          * can pretend this insn was not executed yet and get
    2208                 :            :                          * the (correct) SIGSEGV after restart.
    2209                 :            :                          */
    2210                 :          0 :                         instruction_pointer_set(regs, bp_vaddr);
    2211                 :            :                 }
    2212                 :          0 :                 return;
    2213                 :            :         }
    2214                 :            : 
    2215                 :            :         /* change it in advance for ->handler() and restart */
    2216                 :          0 :         instruction_pointer_set(regs, bp_vaddr);
    2217                 :            : 
    2218                 :            :         /*
    2219                 :            :          * TODO: move copy_insn/etc into _register and remove this hack.
    2220                 :            :          * After we hit the bp, _unregister + _register can install the
    2221                 :            :          * new and not-yet-analyzed uprobe at the same address, restart.
    2222                 :            :          */
    2223         [ #  # ]:          0 :         if (unlikely(!test_bit(UPROBE_COPY_INSN, &uprobe->flags)))
    2224                 :          0 :                 goto out;
    2225                 :            : 
    2226                 :            :         /*
    2227                 :            :          * Pairs with the smp_wmb() in prepare_uprobe().
    2228                 :            :          *
    2229                 :            :          * Guarantees that if we see the UPROBE_COPY_INSN bit set, then
    2230                 :            :          * we must also see the stores to &uprobe->arch performed by the
    2231                 :            :          * prepare_uprobe() call.
    2232                 :            :          */
    2233                 :          0 :         smp_rmb();
    2234                 :            : 
    2235                 :            :         /* Tracing handlers use ->utask to communicate with fetch methods */
    2236         [ #  # ]:          0 :         if (!get_utask())
    2237                 :          0 :                 goto out;
    2238                 :            : 
    2239         [ #  # ]:          0 :         if (arch_uprobe_ignore(&uprobe->arch, regs))
    2240                 :          0 :                 goto out;
    2241                 :            : 
    2242                 :          0 :         handler_chain(uprobe, regs);
    2243                 :            : 
    2244         [ #  # ]:          0 :         if (arch_uprobe_skip_sstep(&uprobe->arch, regs))
    2245                 :          0 :                 goto out;
    2246                 :            : 
    2247         [ #  # ]:          0 :         if (!pre_ssout(uprobe, regs, bp_vaddr))
    2248                 :            :                 return;
    2249                 :            : 
    2250                 :            :         /* arch_uprobe_skip_sstep() succeeded, or restart if can't singlestep */
    2251                 :          0 : out:
    2252                 :          0 :         put_uprobe(uprobe);
    2253                 :            : }
    2254                 :            : 
    2255                 :            : /*
    2256                 :            :  * Perform required fix-ups and disable singlestep.
    2257                 :            :  * Allow pending signals to take effect.
    2258                 :            :  */
    2259                 :            : static void handle_singlestep(struct uprobe_task *utask, struct pt_regs *regs)
    2260                 :            : {
    2261                 :            :         struct uprobe *uprobe;
    2262                 :            :         int err = 0;
    2263                 :            : 
    2264                 :            :         uprobe = utask->active_uprobe;
    2265                 :            :         if (utask->state == UTASK_SSTEP_ACK)
    2266                 :            :                 err = arch_uprobe_post_xol(&uprobe->arch, regs);
    2267                 :            :         else if (utask->state == UTASK_SSTEP_TRAPPED)
    2268                 :            :                 arch_uprobe_abort_xol(&uprobe->arch, regs);
    2269                 :            :         else
    2270                 :            :                 WARN_ON_ONCE(1);
    2271                 :            : 
    2272                 :            :         put_uprobe(uprobe);
    2273                 :            :         utask->active_uprobe = NULL;
    2274                 :            :         utask->state = UTASK_RUNNING;
    2275                 :            :         xol_free_insn_slot(current);
    2276                 :            : 
    2277                 :            :         spin_lock_irq(&current->sighand->siglock);
    2278                 :            :         recalc_sigpending(); /* see uprobe_deny_signal() */
    2279                 :            :         spin_unlock_irq(&current->sighand->siglock);
    2280                 :            : 
    2281                 :            :         if (unlikely(err)) {
    2282                 :            :                 uprobe_warn(current, "execute the probed insn, sending SIGILL.");
    2283                 :            :                 force_sig(SIGILL);
    2284                 :            :         }
    2285                 :            : }
    2286                 :            : 
    2287                 :            : /*
    2288                 :            :  * On breakpoint hit, breakpoint notifier sets the TIF_UPROBE flag and
    2289                 :            :  * allows the thread to return from interrupt. After that handle_swbp()
    2290                 :            :  * sets utask->active_uprobe.
    2291                 :            :  *
    2292                 :            :  * On singlestep exception, singlestep notifier sets the TIF_UPROBE flag
    2293                 :            :  * and allows the thread to return from interrupt.
    2294                 :            :  *
    2295                 :            :  * While returning to userspace, thread notices the TIF_UPROBE flag and calls
    2296                 :            :  * uprobe_notify_resume().
    2297                 :            :  */
    2298                 :          0 : void uprobe_notify_resume(struct pt_regs *regs)
    2299                 :            : {
    2300                 :          0 :         struct uprobe_task *utask;
    2301                 :            : 
    2302                 :          0 :         clear_thread_flag(TIF_UPROBE);
    2303                 :            : 
    2304         [ #  # ]:          0 :         utask = current->utask;
    2305   [ #  #  #  # ]:          0 :         if (utask && utask->active_uprobe)
    2306                 :          0 :                 handle_singlestep(utask, regs);
    2307                 :            :         else
    2308                 :          0 :                 handle_swbp(regs);
    2309                 :          0 : }
    2310                 :            : 
    2311                 :            : /*
    2312                 :            :  * uprobe_pre_sstep_notifier gets called from interrupt context as part of
    2313                 :            :  * notifier mechanism. Set TIF_UPROBE flag and indicate breakpoint hit.
    2314                 :            :  */
    2315                 :          0 : int uprobe_pre_sstep_notifier(struct pt_regs *regs)
    2316                 :            : {
    2317         [ #  # ]:          0 :         if (!current->mm)
    2318                 :            :                 return 0;
    2319                 :            : 
    2320         [ #  # ]:          0 :         if (!test_bit(MMF_HAS_UPROBES, &current->mm->flags) &&
    2321   [ #  #  #  # ]:          0 :             (!current->utask || !current->utask->return_instances))
    2322                 :            :                 return 0;
    2323                 :            : 
    2324                 :          0 :         set_thread_flag(TIF_UPROBE);
    2325                 :          0 :         return 1;
    2326                 :            : }
    2327                 :            : 
    2328                 :            : /*
    2329                 :            :  * uprobe_post_sstep_notifier gets called in interrupt context as part of notifier
    2330                 :            :  * mechanism. Set TIF_UPROBE flag and indicate completion of singlestep.
    2331                 :            :  */
    2332                 :          0 : int uprobe_post_sstep_notifier(struct pt_regs *regs)
    2333                 :            : {
    2334         [ #  # ]:          0 :         struct uprobe_task *utask = current->utask;
    2335                 :            : 
    2336   [ #  #  #  #  :          0 :         if (!current->mm || !utask || !utask->active_uprobe)
                   #  # ]
    2337                 :            :                 /* task is currently not uprobed */
    2338                 :            :                 return 0;
    2339                 :            : 
    2340                 :          0 :         utask->state = UTASK_SSTEP_ACK;
    2341                 :          0 :         set_thread_flag(TIF_UPROBE);
    2342                 :          0 :         return 1;
    2343                 :            : }
    2344                 :            : 
    2345                 :            : static struct notifier_block uprobe_exception_nb = {
    2346                 :            :         .notifier_call          = arch_uprobe_exception_notify,
    2347                 :            :         .priority               = INT_MAX-1,    /* notified after kprobes, kgdb */
    2348                 :            : };
    2349                 :            : 
    2350                 :         30 : void __init uprobes_init(void)
    2351                 :            : {
    2352                 :         30 :         int i;
    2353                 :            : 
    2354         [ +  + ]:        420 :         for (i = 0; i < UPROBES_HASH_SZ; i++)
    2355                 :        390 :                 mutex_init(&uprobes_mmap_mutex[i]);
    2356                 :            : 
    2357         [ -  + ]:         30 :         BUG_ON(register_die_notifier(&uprobe_exception_nb));
    2358                 :         30 : }

Generated by: LCOV version 1.14