LCOV - code coverage report
Current view: top level - kernel - kprobes.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 110 1098 10.0 %
Date: 2022-04-01 13:59:58 Functions: 11 94 11.7 %
Branches: 37 749 4.9 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /*
       3                 :            :  *  Kernel Probes (KProbes)
       4                 :            :  *  kernel/kprobes.c
       5                 :            :  *
       6                 :            :  * Copyright (C) IBM Corporation, 2002, 2004
       7                 :            :  *
       8                 :            :  * 2002-Oct     Created by Vamsi Krishna S <vamsi_krishna@in.ibm.com> Kernel
       9                 :            :  *              Probes initial implementation (includes suggestions from
      10                 :            :  *              Rusty Russell).
      11                 :            :  * 2004-Aug     Updated by Prasanna S Panchamukhi <prasanna@in.ibm.com> with
      12                 :            :  *              hlists and exceptions notifier as suggested by Andi Kleen.
      13                 :            :  * 2004-July    Suparna Bhattacharya <suparna@in.ibm.com> added jumper probes
      14                 :            :  *              interface to access function arguments.
      15                 :            :  * 2004-Sep     Prasanna S Panchamukhi <prasanna@in.ibm.com> Changed Kprobes
      16                 :            :  *              exceptions notifier to be first on the priority list.
      17                 :            :  * 2005-May     Hien Nguyen <hien@us.ibm.com>, Jim Keniston
      18                 :            :  *              <jkenisto@us.ibm.com> and Prasanna S Panchamukhi
      19                 :            :  *              <prasanna@in.ibm.com> added function-return probes.
      20                 :            :  */
      21                 :            : #include <linux/kprobes.h>
      22                 :            : #include <linux/hash.h>
      23                 :            : #include <linux/init.h>
      24                 :            : #include <linux/slab.h>
      25                 :            : #include <linux/stddef.h>
      26                 :            : #include <linux/export.h>
      27                 :            : #include <linux/moduleloader.h>
      28                 :            : #include <linux/kallsyms.h>
      29                 :            : #include <linux/freezer.h>
      30                 :            : #include <linux/seq_file.h>
      31                 :            : #include <linux/debugfs.h>
      32                 :            : #include <linux/sysctl.h>
      33                 :            : #include <linux/kdebug.h>
      34                 :            : #include <linux/memory.h>
      35                 :            : #include <linux/ftrace.h>
      36                 :            : #include <linux/cpu.h>
      37                 :            : #include <linux/jump_label.h>
      38                 :            : 
      39                 :            : #include <asm/sections.h>
      40                 :            : #include <asm/cacheflush.h>
      41                 :            : #include <asm/errno.h>
      42                 :            : #include <linux/uaccess.h>
      43                 :            : 
      44                 :            : #define KPROBE_HASH_BITS 6
      45                 :            : #define KPROBE_TABLE_SIZE (1 << KPROBE_HASH_BITS)
      46                 :            : 
      47                 :            : 
      48                 :            : static int kprobes_initialized;
      49                 :            : static struct hlist_head kprobe_table[KPROBE_TABLE_SIZE];
      50                 :            : static struct hlist_head kretprobe_inst_table[KPROBE_TABLE_SIZE];
      51                 :            : 
      52                 :            : /* NOTE: change this value only with kprobe_mutex held */
      53                 :            : static bool kprobes_all_disarmed;
      54                 :            : 
      55                 :            : /* This protects kprobe_table and optimizing_list */
      56                 :            : static DEFINE_MUTEX(kprobe_mutex);
      57                 :            : static DEFINE_PER_CPU(struct kprobe *, kprobe_instance) = NULL;
      58                 :            : static struct {
      59                 :            :         raw_spinlock_t lock ____cacheline_aligned_in_smp;
      60                 :            : } kretprobe_table_locks[KPROBE_TABLE_SIZE];
      61                 :            : 
      62                 :         78 : kprobe_opcode_t * __weak kprobe_lookup_name(const char *name,
      63                 :            :                                         unsigned int __unused)
      64                 :            : {
      65                 :         78 :         return ((kprobe_opcode_t *)(kallsyms_lookup_name(name)));
      66                 :            : }
      67                 :            : 
      68                 :     112618 : static raw_spinlock_t *kretprobe_table_lock_ptr(unsigned long hash)
      69                 :            : {
      70                 :     112618 :         return &(kretprobe_table_locks[hash].lock);
      71                 :            : }
      72                 :            : 
      73                 :            : /* Blacklist -- list of struct kprobe_blacklist_entry */
      74                 :            : static LIST_HEAD(kprobe_blacklist);
      75                 :            : 
      76                 :            : #ifdef __ARCH_WANT_KPROBES_INSN_SLOT
      77                 :            : /*
      78                 :            :  * kprobe->ainsn.insn points to the copy of the instruction to be
      79                 :            :  * single-stepped. x86_64, POWER4 and above have no-exec support and
      80                 :            :  * stepping on the instruction on a vmalloced/kmalloced/data page
      81                 :            :  * is a recipe for disaster
      82                 :            :  */
      83                 :            : struct kprobe_insn_page {
      84                 :            :         struct list_head list;
      85                 :            :         kprobe_opcode_t *insns;         /* Page of instruction slots */
      86                 :            :         struct kprobe_insn_cache *cache;
      87                 :            :         int nused;
      88                 :            :         int ngarbage;
      89                 :            :         char slot_used[];
      90                 :            : };
      91                 :            : 
      92                 :            : #define KPROBE_INSN_PAGE_SIZE(slots)                    \
      93                 :            :         (offsetof(struct kprobe_insn_page, slot_used) + \
      94                 :            :          (sizeof(char) * (slots)))
      95                 :            : 
      96                 :          0 : static int slots_per_page(struct kprobe_insn_cache *c)
      97                 :            : {
      98                 :          0 :         return PAGE_SIZE/(c->insn_size * sizeof(kprobe_opcode_t));
      99                 :            : }
     100                 :            : 
     101                 :            : enum kprobe_slot_state {
     102                 :            :         SLOT_CLEAN = 0,
     103                 :            :         SLOT_DIRTY = 1,
     104                 :            :         SLOT_USED = 2,
     105                 :            : };
     106                 :            : 
     107                 :          0 : void __weak *alloc_insn_page(void)
     108                 :            : {
     109                 :          0 :         return module_alloc(PAGE_SIZE);
     110                 :            : }
     111                 :            : 
     112                 :          0 : void __weak free_insn_page(void *page)
     113                 :            : {
     114                 :          0 :         module_memfree(page);
     115                 :          0 : }
     116                 :            : 
     117                 :            : struct kprobe_insn_cache kprobe_insn_slots = {
     118                 :            :         .mutex = __MUTEX_INITIALIZER(kprobe_insn_slots.mutex),
     119                 :            :         .alloc = alloc_insn_page,
     120                 :            :         .free = free_insn_page,
     121                 :            :         .pages = LIST_HEAD_INIT(kprobe_insn_slots.pages),
     122                 :            :         .insn_size = MAX_INSN_SIZE,
     123                 :            :         .nr_garbage = 0,
     124                 :            : };
     125                 :            : static int collect_garbage_slots(struct kprobe_insn_cache *c);
     126                 :            : 
     127                 :            : /**
     128                 :            :  * __get_insn_slot() - Find a slot on an executable page for an instruction.
     129                 :            :  * We allocate an executable page if there's no room on existing ones.
     130                 :            :  */
     131                 :          0 : kprobe_opcode_t *__get_insn_slot(struct kprobe_insn_cache *c)
     132                 :            : {
     133                 :          0 :         struct kprobe_insn_page *kip;
     134                 :          0 :         kprobe_opcode_t *slot = NULL;
     135                 :            : 
     136                 :            :         /* Since the slot array is not protected by rcu, we need a mutex */
     137                 :          0 :         mutex_lock(&c->mutex);
     138                 :          0 :  retry:
     139                 :          0 :         rcu_read_lock();
     140         [ #  # ]:          0 :         list_for_each_entry_rcu(kip, &c->pages, list) {
     141         [ #  # ]:          0 :                 if (kip->nused < slots_per_page(c)) {
     142                 :            :                         int i;
     143         [ #  # ]:          0 :                         for (i = 0; i < slots_per_page(c); i++) {
     144         [ #  # ]:          0 :                                 if (kip->slot_used[i] == SLOT_CLEAN) {
     145                 :          0 :                                         kip->slot_used[i] = SLOT_USED;
     146                 :          0 :                                         kip->nused++;
     147                 :          0 :                                         slot = kip->insns + (i * c->insn_size);
     148                 :          0 :                                         rcu_read_unlock();
     149                 :          0 :                                         goto out;
     150                 :            :                                 }
     151                 :            :                         }
     152                 :            :                         /* kip->nused is broken. Fix it. */
     153                 :          0 :                         kip->nused = slots_per_page(c);
     154                 :          0 :                         WARN_ON(1);
     155                 :            :                 }
     156                 :            :         }
     157                 :          0 :         rcu_read_unlock();
     158                 :            : 
     159                 :            :         /* If there are any garbage slots, collect it and try again. */
     160   [ #  #  #  # ]:          0 :         if (c->nr_garbage && collect_garbage_slots(c) == 0)
     161                 :          0 :                 goto retry;
     162                 :            : 
     163                 :            :         /* All out of space.  Need to allocate a new page. */
     164         [ #  # ]:          0 :         kip = kmalloc(KPROBE_INSN_PAGE_SIZE(slots_per_page(c)), GFP_KERNEL);
     165         [ #  # ]:          0 :         if (!kip)
     166                 :          0 :                 goto out;
     167                 :            : 
     168                 :            :         /*
     169                 :            :          * Use module_alloc so this page is within +/- 2GB of where the
     170                 :            :          * kernel image and loaded module images reside. This is required
     171                 :            :          * so x86_64 can correctly handle the %rip-relative fixups.
     172                 :            :          */
     173                 :          0 :         kip->insns = c->alloc();
     174         [ #  # ]:          0 :         if (!kip->insns) {
     175                 :          0 :                 kfree(kip);
     176                 :          0 :                 goto out;
     177                 :            :         }
     178                 :          0 :         INIT_LIST_HEAD(&kip->list);
     179                 :          0 :         memset(kip->slot_used, SLOT_CLEAN, slots_per_page(c));
     180                 :          0 :         kip->slot_used[0] = SLOT_USED;
     181                 :          0 :         kip->nused = 1;
     182                 :          0 :         kip->ngarbage = 0;
     183                 :          0 :         kip->cache = c;
     184                 :          0 :         list_add_rcu(&kip->list, &c->pages);
     185                 :          0 :         slot = kip->insns;
     186                 :          0 : out:
     187                 :          0 :         mutex_unlock(&c->mutex);
     188                 :          0 :         return slot;
     189                 :            : }
     190                 :            : 
     191                 :            : /* Return 1 if all garbages are collected, otherwise 0. */
     192                 :          0 : static int collect_one_slot(struct kprobe_insn_page *kip, int idx)
     193                 :            : {
     194                 :          0 :         kip->slot_used[idx] = SLOT_CLEAN;
     195                 :          0 :         kip->nused--;
     196         [ #  # ]:          0 :         if (kip->nused == 0) {
     197                 :            :                 /*
     198                 :            :                  * Page is no longer in use.  Free it unless
     199                 :            :                  * it's the last one.  We keep the last one
     200                 :            :                  * so as not to have to set it up again the
     201                 :            :                  * next time somebody inserts a probe.
     202                 :            :                  */
     203         [ #  # ]:          0 :                 if (!list_is_singular(&kip->list)) {
     204                 :          0 :                         list_del_rcu(&kip->list);
     205                 :          0 :                         synchronize_rcu();
     206                 :          0 :                         kip->cache->free(kip->insns);
     207                 :          0 :                         kfree(kip);
     208                 :            :                 }
     209                 :          0 :                 return 1;
     210                 :            :         }
     211                 :            :         return 0;
     212                 :            : }
     213                 :            : 
     214                 :          0 : static int collect_garbage_slots(struct kprobe_insn_cache *c)
     215                 :            : {
     216                 :          0 :         struct kprobe_insn_page *kip, *next;
     217                 :            : 
     218                 :            :         /* Ensure no-one is interrupted on the garbages */
     219                 :          0 :         synchronize_rcu();
     220                 :            : 
     221         [ #  # ]:          0 :         list_for_each_entry_safe(kip, next, &c->pages, list) {
     222                 :          0 :                 int i;
     223         [ #  # ]:          0 :                 if (kip->ngarbage == 0)
     224                 :          0 :                         continue;
     225                 :          0 :                 kip->ngarbage = 0;   /* we will collect all garbages */
     226         [ #  # ]:          0 :                 for (i = 0; i < slots_per_page(c); i++) {
     227   [ #  #  #  # ]:          0 :                         if (kip->slot_used[i] == SLOT_DIRTY && collect_one_slot(kip, i))
     228                 :            :                                 break;
     229                 :            :                 }
     230                 :            :         }
     231                 :          0 :         c->nr_garbage = 0;
     232                 :          0 :         return 0;
     233                 :            : }
     234                 :            : 
     235                 :          0 : void __free_insn_slot(struct kprobe_insn_cache *c,
     236                 :            :                       kprobe_opcode_t *slot, int dirty)
     237                 :            : {
     238                 :          0 :         struct kprobe_insn_page *kip;
     239                 :          0 :         long idx;
     240                 :            : 
     241                 :          0 :         mutex_lock(&c->mutex);
     242                 :          0 :         rcu_read_lock();
     243         [ #  # ]:          0 :         list_for_each_entry_rcu(kip, &c->pages, list) {
     244                 :          0 :                 idx = ((long)slot - (long)kip->insns) /
     245                 :          0 :                         (c->insn_size * sizeof(kprobe_opcode_t));
     246   [ #  #  #  # ]:          0 :                 if (idx >= 0 && idx < slots_per_page(c))
     247                 :          0 :                         goto out;
     248                 :            :         }
     249                 :            :         /* Could not find this slot. */
     250                 :          0 :         WARN_ON(1);
     251                 :          0 :         kip = NULL;
     252                 :          0 : out:
     253                 :          0 :         rcu_read_unlock();
     254                 :            :         /* Mark and sweep: this may sleep */
     255         [ #  # ]:          0 :         if (kip) {
     256                 :            :                 /* Check double free */
     257         [ #  # ]:          0 :                 WARN_ON(kip->slot_used[idx] != SLOT_USED);
     258         [ #  # ]:          0 :                 if (dirty) {
     259                 :          0 :                         kip->slot_used[idx] = SLOT_DIRTY;
     260                 :          0 :                         kip->ngarbage++;
     261         [ #  # ]:          0 :                         if (++c->nr_garbage > slots_per_page(c))
     262                 :          0 :                                 collect_garbage_slots(c);
     263                 :            :                 } else {
     264                 :          0 :                         collect_one_slot(kip, idx);
     265                 :            :                 }
     266                 :            :         }
     267                 :          0 :         mutex_unlock(&c->mutex);
     268                 :          0 : }
     269                 :            : 
     270                 :            : /*
     271                 :            :  * Check given address is on the page of kprobe instruction slots.
     272                 :            :  * This will be used for checking whether the address on a stack
     273                 :            :  * is on a text area or not.
     274                 :            :  */
     275                 :       7020 : bool __is_insn_slot_addr(struct kprobe_insn_cache *c, unsigned long addr)
     276                 :            : {
     277                 :       7020 :         struct kprobe_insn_page *kip;
     278                 :       7020 :         bool ret = false;
     279                 :            : 
     280                 :       7020 :         rcu_read_lock();
     281         [ -  + ]:       7020 :         list_for_each_entry_rcu(kip, &c->pages, list) {
     282         [ #  # ]:          0 :                 if (addr >= (unsigned long)kip->insns &&
     283         [ #  # ]:          0 :                     addr < (unsigned long)kip->insns + PAGE_SIZE) {
     284                 :            :                         ret = true;
     285                 :            :                         break;
     286                 :            :                 }
     287                 :            :         }
     288                 :       7020 :         rcu_read_unlock();
     289                 :            : 
     290                 :       7020 :         return ret;
     291                 :            : }
     292                 :            : 
     293                 :            : #ifdef CONFIG_OPTPROBES
     294                 :            : /* For optimized_kprobe buffer */
     295                 :            : struct kprobe_insn_cache kprobe_optinsn_slots = {
     296                 :            :         .mutex = __MUTEX_INITIALIZER(kprobe_optinsn_slots.mutex),
     297                 :            :         .alloc = alloc_insn_page,
     298                 :            :         .free = free_insn_page,
     299                 :            :         .pages = LIST_HEAD_INIT(kprobe_optinsn_slots.pages),
     300                 :            :         /* .insn_size is initialized later */
     301                 :            :         .nr_garbage = 0,
     302                 :            : };
     303                 :            : #endif
     304                 :            : #endif
     305                 :            : 
     306                 :            : /* We have preemption disabled.. so it is safe to use __ versions */
     307                 :          0 : static inline void set_kprobe_instance(struct kprobe *kp)
     308                 :            : {
     309                 :          0 :         __this_cpu_write(kprobe_instance, kp);
     310                 :            : }
     311                 :            : 
     312                 :          0 : static inline void reset_kprobe_instance(void)
     313                 :            : {
     314                 :          0 :         __this_cpu_write(kprobe_instance, NULL);
     315                 :          0 : }
     316                 :            : 
     317                 :            : /*
     318                 :            :  * This routine is called either:
     319                 :            :  *      - under the kprobe_mutex - during kprobe_[un]register()
     320                 :            :  *                              OR
     321                 :            :  *      - with preemption disabled - from arch/xxx/kernel/kprobes.c
     322                 :            :  */
     323                 :         78 : struct kprobe *get_kprobe(void *addr)
     324                 :            : {
     325                 :         78 :         struct hlist_head *head;
     326                 :         78 :         struct kprobe *p;
     327                 :            : 
     328         [ +  - ]:         78 :         head = &kprobe_table[hash_ptr(addr, KPROBE_HASH_BITS)];
     329   [ -  -  -  -  :        156 :         hlist_for_each_entry_rcu(p, head, hlist) {
          -  -  -  -  -  
          -  -  -  +  -  
             -  -  -  + ]
     330   [ #  #  #  #  :          0 :                 if (p->addr == addr)
             #  #  #  # ]
     331                 :          0 :                         return p;
     332                 :            :         }
     333                 :            : 
     334                 :            :         return NULL;
     335                 :            : }
     336                 :            : NOKPROBE_SYMBOL(get_kprobe);
     337                 :            : 
     338                 :            : static int aggr_pre_handler(struct kprobe *p, struct pt_regs *regs);
     339                 :            : 
     340                 :            : /* Return true if the kprobe is an aggregator */
     341                 :          0 : static inline int kprobe_aggrprobe(struct kprobe *p)
     342                 :            : {
     343                 :          0 :         return p->pre_handler == aggr_pre_handler;
     344                 :            : }
     345                 :            : 
     346                 :            : /* Return true(!0) if the kprobe is unused */
     347                 :          0 : static inline int kprobe_unused(struct kprobe *p)
     348                 :            : {
     349   [ #  #  #  #  :          0 :         return kprobe_aggrprobe(p) && kprobe_disabled(p) &&
          #  #  #  #  #  
             #  #  #  #  
                      # ]
     350   [ #  #  #  #  :          0 :                list_empty(&p->list);
             #  #  #  # ]
     351                 :            : }
     352                 :            : 
     353                 :            : /*
     354                 :            :  * Keep all fields in the kprobe consistent
     355                 :            :  */
     356                 :          0 : static inline void copy_kprobe(struct kprobe *ap, struct kprobe *p)
     357                 :            : {
     358                 :          0 :         memcpy(&p->opcode, &ap->opcode, sizeof(kprobe_opcode_t));
     359                 :          0 :         memcpy(&p->ainsn, &ap->ainsn, sizeof(struct arch_specific_insn));
     360                 :            : }
     361                 :            : 
     362                 :            : #ifdef CONFIG_OPTPROBES
     363                 :            : /* NOTE: change this value only with kprobe_mutex held */
     364                 :            : static bool kprobes_allow_optimization;
     365                 :            : 
     366                 :            : /*
     367                 :            :  * Call all pre_handler on the list, but ignores its return value.
     368                 :            :  * This must be called from arch-dep optimized caller.
     369                 :            :  */
     370                 :          0 : void opt_pre_handler(struct kprobe *p, struct pt_regs *regs)
     371                 :            : {
     372                 :          0 :         struct kprobe *kp;
     373                 :            : 
     374         [ #  # ]:          0 :         list_for_each_entry_rcu(kp, &p->list, list) {
     375   [ #  #  #  # ]:          0 :                 if (kp->pre_handler && likely(!kprobe_disabled(kp))) {
     376                 :          0 :                         set_kprobe_instance(kp);
     377                 :          0 :                         kp->pre_handler(kp, regs);
     378                 :            :                 }
     379                 :          0 :                 reset_kprobe_instance();
     380                 :            :         }
     381                 :          0 : }
     382                 :            : NOKPROBE_SYMBOL(opt_pre_handler);
     383                 :            : 
     384                 :            : /* Free optimized instructions and optimized_kprobe */
     385                 :          0 : static void free_aggr_kprobe(struct kprobe *p)
     386                 :            : {
     387                 :          0 :         struct optimized_kprobe *op;
     388                 :            : 
     389                 :          0 :         op = container_of(p, struct optimized_kprobe, kp);
     390                 :          0 :         arch_remove_optimized_kprobe(op);
     391                 :          0 :         arch_remove_kprobe(p);
     392                 :          0 :         kfree(op);
     393                 :          0 : }
     394                 :            : 
     395                 :            : /* Return true(!0) if the kprobe is ready for optimization. */
     396                 :          0 : static inline int kprobe_optready(struct kprobe *p)
     397                 :            : {
     398                 :          0 :         struct optimized_kprobe *op;
     399                 :            : 
     400         [ #  # ]:          0 :         if (kprobe_aggrprobe(p)) {
     401                 :          0 :                 op = container_of(p, struct optimized_kprobe, kp);
     402   [ #  #  #  #  :          0 :                 return arch_prepared_optinsn(&op->optinsn);
                   #  # ]
     403                 :            :         }
     404                 :            : 
     405                 :            :         return 0;
     406                 :            : }
     407                 :            : 
     408                 :            : /* Return true(!0) if the kprobe is disarmed. Note: p must be on hash list */
     409                 :          0 : static inline int kprobe_disarmed(struct kprobe *p)
     410                 :            : {
     411                 :          0 :         struct optimized_kprobe *op;
     412                 :            : 
     413                 :            :         /* If kprobe is not aggr/opt probe, just return kprobe is disabled */
     414         [ #  # ]:          0 :         if (!kprobe_aggrprobe(p))
     415         [ #  # ]:          0 :                 return kprobe_disabled(p);
     416                 :            : 
     417                 :          0 :         op = container_of(p, struct optimized_kprobe, kp);
     418                 :            : 
     419   [ #  #  #  #  :          0 :         return kprobe_disabled(p) && list_empty(&op->list);
             #  #  #  # ]
     420                 :            : }
     421                 :            : 
     422                 :            : /* Return true(!0) if the probe is queued on (un)optimizing lists */
     423                 :          0 : static int kprobe_queued(struct kprobe *p)
     424                 :            : {
     425                 :          0 :         struct optimized_kprobe *op;
     426                 :            : 
     427                 :          0 :         if (kprobe_aggrprobe(p)) {
     428                 :          0 :                 op = container_of(p, struct optimized_kprobe, kp);
     429         [ #  # ]:          0 :                 if (!list_empty(&op->list))
     430                 :            :                         return 1;
     431                 :            :         }
     432                 :            :         return 0;
     433                 :            : }
     434                 :            : 
     435                 :            : /*
     436                 :            :  * Return an optimized kprobe whose optimizing code replaces
     437                 :            :  * instructions including addr (exclude breakpoint).
     438                 :            :  */
     439                 :          0 : static struct kprobe *get_optimized_kprobe(unsigned long addr)
     440                 :            : {
     441                 :          0 :         int i;
     442                 :          0 :         struct kprobe *p = NULL;
     443                 :          0 :         struct optimized_kprobe *op;
     444                 :            : 
     445                 :            :         /* Don't check i == 0, since that is a breakpoint case. */
     446         [ #  # ]:          0 :         for (i = 1; !p && i < MAX_OPTIMIZED_LENGTH; i++)
     447                 :          0 :                 p = get_kprobe((void *)(addr - i));
     448                 :            : 
     449   [ #  #  #  # ]:          0 :         if (p && kprobe_optready(p)) {
     450                 :          0 :                 op = container_of(p, struct optimized_kprobe, kp);
     451         [ #  # ]:          0 :                 if (arch_within_optimized_kprobe(op, addr))
     452                 :          0 :                         return p;
     453                 :            :         }
     454                 :            : 
     455                 :            :         return NULL;
     456                 :            : }
     457                 :            : 
     458                 :            : /* Optimization staging list, protected by kprobe_mutex */
     459                 :            : static LIST_HEAD(optimizing_list);
     460                 :            : static LIST_HEAD(unoptimizing_list);
     461                 :            : static LIST_HEAD(freeing_list);
     462                 :            : 
     463                 :            : static void kprobe_optimizer(struct work_struct *work);
     464                 :            : static DECLARE_DELAYED_WORK(optimizing_work, kprobe_optimizer);
     465                 :            : #define OPTIMIZE_DELAY 5
     466                 :            : 
     467                 :            : /*
     468                 :            :  * Optimize (replace a breakpoint with a jump) kprobes listed on
     469                 :            :  * optimizing_list.
     470                 :            :  */
     471                 :          0 : static void do_optimize_kprobes(void)
     472                 :            : {
     473                 :          0 :         lockdep_assert_held(&text_mutex);
     474                 :            :         /*
     475                 :            :          * The optimization/unoptimization refers online_cpus via
     476                 :            :          * stop_machine() and cpu-hotplug modifies online_cpus.
     477                 :            :          * And same time, text_mutex will be held in cpu-hotplug and here.
     478                 :            :          * This combination can cause a deadlock (cpu-hotplug try to lock
     479                 :            :          * text_mutex but stop_machine can not be done because online_cpus
     480                 :            :          * has been changed)
     481                 :            :          * To avoid this deadlock, caller must have locked cpu hotplug
     482                 :            :          * for preventing cpu-hotplug outside of text_mutex locking.
     483                 :            :          */
     484                 :          0 :         lockdep_assert_cpus_held();
     485                 :            : 
     486                 :            :         /* Optimization never be done when disarmed */
     487   [ #  #  #  #  :          0 :         if (kprobes_all_disarmed || !kprobes_allow_optimization ||
                   #  # ]
     488                 :            :             list_empty(&optimizing_list))
     489                 :            :                 return;
     490                 :            : 
     491                 :          0 :         arch_optimize_kprobes(&optimizing_list);
     492                 :            : }
     493                 :            : 
     494                 :            : /*
     495                 :            :  * Unoptimize (replace a jump with a breakpoint and remove the breakpoint
     496                 :            :  * if need) kprobes listed on unoptimizing_list.
     497                 :            :  */
     498                 :          0 : static void do_unoptimize_kprobes(void)
     499                 :            : {
     500                 :          0 :         struct optimized_kprobe *op, *tmp;
     501                 :            : 
     502                 :          0 :         lockdep_assert_held(&text_mutex);
     503                 :            :         /* See comment in do_optimize_kprobes() */
     504                 :          0 :         lockdep_assert_cpus_held();
     505                 :            : 
     506                 :            :         /* Unoptimization must be done anytime */
     507         [ #  # ]:          0 :         if (list_empty(&unoptimizing_list))
     508                 :            :                 return;
     509                 :            : 
     510                 :          0 :         arch_unoptimize_kprobes(&unoptimizing_list, &freeing_list);
     511                 :            :         /* Loop free_list for disarming */
     512         [ #  # ]:          0 :         list_for_each_entry_safe(op, tmp, &freeing_list, list) {
     513                 :            :                 /* Switching from detour code to origin */
     514                 :          0 :                 op->kp.flags &= ~KPROBE_FLAG_OPTIMIZED;
     515                 :            :                 /* Disarm probes if marked disabled */
     516         [ #  # ]:          0 :                 if (kprobe_disabled(&op->kp))
     517                 :          0 :                         arch_disarm_kprobe(&op->kp);
     518         [ #  # ]:          0 :                 if (kprobe_unused(&op->kp)) {
     519                 :            :                         /*
     520                 :            :                          * Remove unused probes from hash list. After waiting
     521                 :            :                          * for synchronization, these probes are reclaimed.
     522                 :            :                          * (reclaiming is done by do_free_cleaned_kprobes.)
     523                 :            :                          */
     524         [ #  # ]:          0 :                         hlist_del_rcu(&op->kp.hlist);
     525                 :            :                 } else
     526                 :          0 :                         list_del_init(&op->list);
     527                 :            :         }
     528                 :            : }
     529                 :            : 
     530                 :            : /* Reclaim all kprobes on the free_list */
     531                 :          0 : static void do_free_cleaned_kprobes(void)
     532                 :            : {
     533                 :          0 :         struct optimized_kprobe *op, *tmp;
     534                 :            : 
     535         [ #  # ]:          0 :         list_for_each_entry_safe(op, tmp, &freeing_list, list) {
     536         [ #  # ]:          0 :                 list_del_init(&op->list);
     537   [ #  #  #  #  :          0 :                 if (WARN_ON_ONCE(!kprobe_unused(&op->kp))) {
                   #  # ]
     538                 :            :                         /*
     539                 :            :                          * This must not happen, but if there is a kprobe
     540                 :            :                          * still in use, keep it on kprobes hash list.
     541                 :            :                          */
     542                 :          0 :                         continue;
     543                 :            :                 }
     544                 :          0 :                 free_aggr_kprobe(&op->kp);
     545                 :            :         }
     546                 :          0 : }
     547                 :            : 
     548                 :            : /* Start optimizer after OPTIMIZE_DELAY passed */
     549                 :          0 : static void kick_kprobe_optimizer(void)
     550                 :            : {
     551                 :          0 :         schedule_delayed_work(&optimizing_work, OPTIMIZE_DELAY);
     552                 :          0 : }
     553                 :            : 
     554                 :            : /* Kprobe jump optimizer */
     555                 :          0 : static void kprobe_optimizer(struct work_struct *work)
     556                 :            : {
     557                 :          0 :         mutex_lock(&kprobe_mutex);
     558                 :          0 :         cpus_read_lock();
     559                 :          0 :         mutex_lock(&text_mutex);
     560                 :            :         /* Lock modules while optimizing kprobes */
     561                 :          0 :         mutex_lock(&module_mutex);
     562                 :            : 
     563                 :            :         /*
     564                 :            :          * Step 1: Unoptimize kprobes and collect cleaned (unused and disarmed)
     565                 :            :          * kprobes before waiting for quiesence period.
     566                 :            :          */
     567                 :          0 :         do_unoptimize_kprobes();
     568                 :            : 
     569                 :            :         /*
     570                 :            :          * Step 2: Wait for quiesence period to ensure all potentially
     571                 :            :          * preempted tasks to have normally scheduled. Because optprobe
     572                 :            :          * may modify multiple instructions, there is a chance that Nth
     573                 :            :          * instruction is preempted. In that case, such tasks can return
     574                 :            :          * to 2nd-Nth byte of jump instruction. This wait is for avoiding it.
     575                 :            :          * Note that on non-preemptive kernel, this is transparently converted
     576                 :            :          * to synchronoze_sched() to wait for all interrupts to have completed.
     577                 :            :          */
     578                 :          0 :         synchronize_rcu_tasks();
     579                 :            : 
     580                 :            :         /* Step 3: Optimize kprobes after quiesence period */
     581                 :          0 :         do_optimize_kprobes();
     582                 :            : 
     583                 :            :         /* Step 4: Free cleaned kprobes after quiesence period */
     584                 :          0 :         do_free_cleaned_kprobes();
     585                 :            : 
     586                 :          0 :         mutex_unlock(&module_mutex);
     587                 :          0 :         mutex_unlock(&text_mutex);
     588                 :          0 :         cpus_read_unlock();
     589                 :          0 :         mutex_unlock(&kprobe_mutex);
     590                 :            : 
     591                 :            :         /* Step 5: Kick optimizer again if needed */
     592   [ #  #  #  # ]:          0 :         if (!list_empty(&optimizing_list) || !list_empty(&unoptimizing_list))
     593                 :          0 :                 kick_kprobe_optimizer();
     594                 :          0 : }
     595                 :            : 
     596                 :            : /* Wait for completing optimization and unoptimization */
     597                 :          0 : void wait_for_kprobe_optimizer(void)
     598                 :            : {
     599                 :          0 :         mutex_lock(&kprobe_mutex);
     600                 :            : 
     601   [ #  #  #  # ]:          0 :         while (!list_empty(&optimizing_list) || !list_empty(&unoptimizing_list)) {
     602                 :          0 :                 mutex_unlock(&kprobe_mutex);
     603                 :            : 
     604                 :            :                 /* this will also make optimizing_work execute immmediately */
     605                 :          0 :                 flush_delayed_work(&optimizing_work);
     606                 :            :                 /* @optimizing_work might not have been queued yet, relax */
     607                 :          0 :                 cpu_relax();
     608                 :            : 
     609                 :          0 :                 mutex_lock(&kprobe_mutex);
     610                 :            :         }
     611                 :            : 
     612                 :          0 :         mutex_unlock(&kprobe_mutex);
     613                 :          0 : }
     614                 :            : 
     615                 :          0 : static bool optprobe_queued_unopt(struct optimized_kprobe *op)
     616                 :            : {
     617                 :          0 :         struct optimized_kprobe *_op;
     618                 :            : 
     619   [ #  #  #  # ]:          0 :         list_for_each_entry(_op, &unoptimizing_list, list) {
     620   [ #  #  #  # ]:          0 :                 if (op == _op)
     621                 :            :                         return true;
     622                 :            :         }
     623                 :            : 
     624                 :            :         return false;
     625                 :            : }
     626                 :            : 
     627                 :            : /* Optimize kprobe if p is ready to be optimized */
     628                 :          0 : static void optimize_kprobe(struct kprobe *p)
     629                 :            : {
     630                 :          0 :         struct optimized_kprobe *op;
     631                 :            : 
     632                 :            :         /* Check if the kprobe is disabled or not ready for optimization. */
     633   [ #  #  #  #  :          0 :         if (!kprobe_optready(p) || !kprobes_allow_optimization ||
             #  #  #  # ]
     634   [ #  #  #  # ]:          0 :             (kprobe_disabled(p) || kprobes_all_disarmed))
     635                 :            :                 return;
     636                 :            : 
     637                 :            :         /* kprobes with post_handler can not be optimized */
     638         [ #  # ]:          0 :         if (p->post_handler)
     639                 :            :                 return;
     640                 :            : 
     641                 :          0 :         op = container_of(p, struct optimized_kprobe, kp);
     642                 :            : 
     643                 :            :         /* Check there is no other kprobes at the optimized instructions */
     644         [ #  # ]:          0 :         if (arch_check_optimized_kprobe(op) < 0)
     645                 :            :                 return;
     646                 :            : 
     647                 :            :         /* Check if it is already optimized. */
     648         [ #  # ]:          0 :         if (op->kp.flags & KPROBE_FLAG_OPTIMIZED) {
     649         [ #  # ]:          0 :                 if (optprobe_queued_unopt(op)) {
     650                 :            :                         /* This is under unoptimizing. Just dequeue the probe */
     651                 :          0 :                         list_del_init(&op->list);
     652                 :            :                 }
     653                 :          0 :                 return;
     654                 :            :         }
     655                 :          0 :         op->kp.flags |= KPROBE_FLAG_OPTIMIZED;
     656                 :            : 
     657                 :            :         /* On unoptimizing/optimizing_list, op must have OPTIMIZED flag */
     658   [ #  #  #  # ]:          0 :         if (WARN_ON_ONCE(!list_empty(&op->list)))
     659                 :            :                 return;
     660                 :            : 
     661                 :          0 :         list_add(&op->list, &optimizing_list);
     662                 :          0 :         kick_kprobe_optimizer();
     663                 :            : }
     664                 :            : 
     665                 :            : /* Short cut to direct unoptimizing */
     666                 :          0 : static void force_unoptimize_kprobe(struct optimized_kprobe *op)
     667                 :            : {
     668                 :          0 :         lockdep_assert_cpus_held();
     669                 :          0 :         arch_unoptimize_kprobe(op);
     670                 :          0 :         op->kp.flags &= ~KPROBE_FLAG_OPTIMIZED;
     671         [ #  # ]:          0 :         if (kprobe_disabled(&op->kp))
     672                 :          0 :                 arch_disarm_kprobe(&op->kp);
     673                 :          0 : }
     674                 :            : 
     675                 :            : /* Unoptimize a kprobe if p is optimized */
     676                 :          0 : static void unoptimize_kprobe(struct kprobe *p, bool force)
     677                 :            : {
     678                 :          0 :         struct optimized_kprobe *op;
     679                 :            : 
     680         [ #  # ]:          0 :         if (!kprobe_aggrprobe(p) || kprobe_disarmed(p))
     681                 :            :                 return; /* This is not an optprobe nor optimized */
     682                 :            : 
     683                 :          0 :         op = container_of(p, struct optimized_kprobe, kp);
     684         [ #  # ]:          0 :         if (!kprobe_optimized(p))
     685                 :            :                 return;
     686                 :            : 
     687         [ #  # ]:          0 :         if (!list_empty(&op->list)) {
     688         [ #  # ]:          0 :                 if (optprobe_queued_unopt(op)) {
     689                 :            :                         /* Queued in unoptimizing queue */
     690         [ #  # ]:          0 :                         if (force) {
     691                 :            :                                 /*
     692                 :            :                                  * Forcibly unoptimize the kprobe here, and queue it
     693                 :            :                                  * in the freeing list for release afterwards.
     694                 :            :                                  */
     695                 :          0 :                                 force_unoptimize_kprobe(op);
     696                 :          0 :                                 list_move(&op->list, &freeing_list);
     697                 :            :                         }
     698                 :            :                 } else {
     699                 :            :                         /* Dequeue from the optimizing queue */
     700                 :          0 :                         list_del_init(&op->list);
     701                 :          0 :                         op->kp.flags &= ~KPROBE_FLAG_OPTIMIZED;
     702                 :            :                 }
     703                 :          0 :                 return;
     704                 :            :         }
     705                 :            : 
     706                 :            :         /* Optimized kprobe case */
     707         [ #  # ]:          0 :         if (force) {
     708                 :            :                 /* Forcibly update the code: this is a special case */
     709                 :          0 :                 force_unoptimize_kprobe(op);
     710                 :            :         } else {
     711                 :          0 :                 list_add(&op->list, &unoptimizing_list);
     712                 :          0 :                 kick_kprobe_optimizer();
     713                 :            :         }
     714                 :            : }
     715                 :            : 
     716                 :            : /* Cancel unoptimizing for reusing */
     717                 :          0 : static int reuse_unused_kprobe(struct kprobe *ap)
     718                 :            : {
     719                 :          0 :         struct optimized_kprobe *op;
     720                 :            : 
     721                 :            :         /*
     722                 :            :          * Unused kprobe MUST be on the way of delayed unoptimizing (means
     723                 :            :          * there is still a relative jump) and disabled.
     724                 :            :          */
     725                 :          0 :         op = container_of(ap, struct optimized_kprobe, kp);
     726         [ #  # ]:          0 :         WARN_ON_ONCE(list_empty(&op->list));
     727                 :            :         /* Enable the probe again */
     728                 :          0 :         ap->flags &= ~KPROBE_FLAG_DISABLED;
     729                 :            :         /* Optimize it again (remove from op->list) */
     730   [ #  #  #  # ]:          0 :         if (!kprobe_optready(ap))
     731                 :            :                 return -EINVAL;
     732                 :            : 
     733                 :          0 :         optimize_kprobe(ap);
     734                 :          0 :         return 0;
     735                 :            : }
     736                 :            : 
     737                 :            : /* Remove optimized instructions */
     738                 :          0 : static void kill_optimized_kprobe(struct kprobe *p)
     739                 :            : {
     740                 :          0 :         struct optimized_kprobe *op;
     741                 :            : 
     742                 :          0 :         op = container_of(p, struct optimized_kprobe, kp);
     743         [ #  # ]:          0 :         if (!list_empty(&op->list))
     744                 :            :                 /* Dequeue from the (un)optimization queue */
     745                 :          0 :                 list_del_init(&op->list);
     746                 :          0 :         op->kp.flags &= ~KPROBE_FLAG_OPTIMIZED;
     747                 :            : 
     748         [ #  # ]:          0 :         if (kprobe_unused(p)) {
     749                 :            :                 /* Enqueue if it is unused */
     750         [ #  # ]:          0 :                 list_add(&op->list, &freeing_list);
     751                 :            :                 /*
     752                 :            :                  * Remove unused probes from the hash list. After waiting
     753                 :            :                  * for synchronization, this probe is reclaimed.
     754                 :            :                  * (reclaiming is done by do_free_cleaned_kprobes().)
     755                 :            :                  */
     756         [ #  # ]:          0 :                 hlist_del_rcu(&op->kp.hlist);
     757                 :            :         }
     758                 :            : 
     759                 :            :         /* Don't touch the code, because it is already freed. */
     760                 :          0 :         arch_remove_optimized_kprobe(op);
     761                 :          0 : }
     762                 :            : 
     763                 :            : static inline
     764                 :          0 : void __prepare_optimized_kprobe(struct optimized_kprobe *op, struct kprobe *p)
     765                 :            : {
     766                 :          0 :         if (!kprobe_ftrace(p))
     767                 :          0 :                 arch_prepare_optimized_kprobe(op, p);
     768                 :            : }
     769                 :            : 
     770                 :            : /* Try to prepare optimized instructions */
     771                 :          0 : static void prepare_optimized_kprobe(struct kprobe *p)
     772                 :            : {
     773                 :          0 :         struct optimized_kprobe *op;
     774                 :            : 
     775                 :          0 :         op = container_of(p, struct optimized_kprobe, kp);
     776                 :          0 :         __prepare_optimized_kprobe(op, p);
     777                 :            : }
     778                 :            : 
     779                 :            : /* Allocate new optimized_kprobe and try to prepare optimized instructions */
     780                 :          0 : static struct kprobe *alloc_aggr_kprobe(struct kprobe *p)
     781                 :            : {
     782                 :          0 :         struct optimized_kprobe *op;
     783                 :            : 
     784                 :          0 :         op = kzalloc(sizeof(struct optimized_kprobe), GFP_KERNEL);
     785         [ #  # ]:          0 :         if (!op)
     786                 :            :                 return NULL;
     787                 :            : 
     788         [ #  # ]:          0 :         INIT_LIST_HEAD(&op->list);
     789                 :          0 :         op->kp.addr = p->addr;
     790         [ #  # ]:          0 :         __prepare_optimized_kprobe(op, p);
     791                 :            : 
     792                 :          0 :         return &op->kp;
     793                 :            : }
     794                 :            : 
     795                 :            : static void init_aggr_kprobe(struct kprobe *ap, struct kprobe *p);
     796                 :            : 
     797                 :            : /*
     798                 :            :  * Prepare an optimized_kprobe and optimize it
     799                 :            :  * NOTE: p must be a normal registered kprobe
     800                 :            :  */
     801                 :          0 : static void try_to_optimize_kprobe(struct kprobe *p)
     802                 :            : {
     803                 :          0 :         struct kprobe *ap;
     804                 :          0 :         struct optimized_kprobe *op;
     805                 :            : 
     806                 :            :         /* Impossible to optimize ftrace-based kprobe */
     807         [ #  # ]:          0 :         if (kprobe_ftrace(p))
     808                 :            :                 return;
     809                 :            : 
     810                 :            :         /* For preparing optimization, jump_label_text_reserved() is called */
     811                 :          0 :         cpus_read_lock();
     812                 :          0 :         jump_label_lock();
     813                 :          0 :         mutex_lock(&text_mutex);
     814                 :            : 
     815                 :          0 :         ap = alloc_aggr_kprobe(p);
     816         [ #  # ]:          0 :         if (!ap)
     817                 :          0 :                 goto out;
     818                 :            : 
     819                 :          0 :         op = container_of(ap, struct optimized_kprobe, kp);
     820         [ #  # ]:          0 :         if (!arch_prepared_optinsn(&op->optinsn)) {
     821                 :            :                 /* If failed to setup optimizing, fallback to kprobe */
     822                 :          0 :                 arch_remove_optimized_kprobe(op);
     823                 :          0 :                 kfree(op);
     824                 :          0 :                 goto out;
     825                 :            :         }
     826                 :            : 
     827                 :          0 :         init_aggr_kprobe(ap, p);
     828                 :          0 :         optimize_kprobe(ap);    /* This just kicks optimizer thread */
     829                 :            : 
     830                 :          0 : out:
     831                 :          0 :         mutex_unlock(&text_mutex);
     832                 :          0 :         jump_label_unlock();
     833                 :          0 :         cpus_read_unlock();
     834                 :            : }
     835                 :            : 
     836                 :            : #ifdef CONFIG_SYSCTL
     837                 :          0 : static void optimize_all_kprobes(void)
     838                 :            : {
     839                 :          0 :         struct hlist_head *head;
     840                 :          0 :         struct kprobe *p;
     841                 :          0 :         unsigned int i;
     842                 :            : 
     843                 :          0 :         mutex_lock(&kprobe_mutex);
     844                 :            :         /* If optimization is already allowed, just return */
     845         [ #  # ]:          0 :         if (kprobes_allow_optimization)
     846                 :          0 :                 goto out;
     847                 :            : 
     848                 :          0 :         cpus_read_lock();
     849                 :          0 :         kprobes_allow_optimization = true;
     850         [ #  # ]:          0 :         for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
     851                 :          0 :                 head = &kprobe_table[i];
     852   [ #  #  #  #  :          0 :                 hlist_for_each_entry_rcu(p, head, hlist)
                   #  # ]
     853         [ #  # ]:          0 :                         if (!kprobe_disabled(p))
     854                 :          0 :                                 optimize_kprobe(p);
     855                 :            :         }
     856                 :          0 :         cpus_read_unlock();
     857                 :          0 :         printk(KERN_INFO "Kprobes globally optimized\n");
     858                 :          0 : out:
     859                 :          0 :         mutex_unlock(&kprobe_mutex);
     860                 :          0 : }
     861                 :            : 
     862                 :          0 : static void unoptimize_all_kprobes(void)
     863                 :            : {
     864                 :          0 :         struct hlist_head *head;
     865                 :          0 :         struct kprobe *p;
     866                 :          0 :         unsigned int i;
     867                 :            : 
     868                 :          0 :         mutex_lock(&kprobe_mutex);
     869                 :            :         /* If optimization is already prohibited, just return */
     870         [ #  # ]:          0 :         if (!kprobes_allow_optimization) {
     871                 :          0 :                 mutex_unlock(&kprobe_mutex);
     872                 :          0 :                 return;
     873                 :            :         }
     874                 :            : 
     875                 :          0 :         cpus_read_lock();
     876                 :          0 :         kprobes_allow_optimization = false;
     877         [ #  # ]:          0 :         for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
     878                 :          0 :                 head = &kprobe_table[i];
     879   [ #  #  #  #  :          0 :                 hlist_for_each_entry_rcu(p, head, hlist) {
                   #  # ]
     880         [ #  # ]:          0 :                         if (!kprobe_disabled(p))
     881                 :          0 :                                 unoptimize_kprobe(p, false);
     882                 :            :                 }
     883                 :            :         }
     884                 :          0 :         cpus_read_unlock();
     885                 :          0 :         mutex_unlock(&kprobe_mutex);
     886                 :            : 
     887                 :            :         /* Wait for unoptimizing completion */
     888                 :          0 :         wait_for_kprobe_optimizer();
     889                 :          0 :         printk(KERN_INFO "Kprobes globally unoptimized\n");
     890                 :            : }
     891                 :            : 
     892                 :            : static DEFINE_MUTEX(kprobe_sysctl_mutex);
     893                 :            : int sysctl_kprobes_optimization;
     894                 :          0 : int proc_kprobes_optimization_handler(struct ctl_table *table, int write,
     895                 :            :                                       void __user *buffer, size_t *length,
     896                 :            :                                       loff_t *ppos)
     897                 :            : {
     898                 :          0 :         int ret;
     899                 :            : 
     900                 :          0 :         mutex_lock(&kprobe_sysctl_mutex);
     901                 :          0 :         sysctl_kprobes_optimization = kprobes_allow_optimization ? 1 : 0;
     902                 :          0 :         ret = proc_dointvec_minmax(table, write, buffer, length, ppos);
     903                 :            : 
     904         [ #  # ]:          0 :         if (sysctl_kprobes_optimization)
     905                 :          0 :                 optimize_all_kprobes();
     906                 :            :         else
     907                 :          0 :                 unoptimize_all_kprobes();
     908                 :          0 :         mutex_unlock(&kprobe_sysctl_mutex);
     909                 :            : 
     910                 :          0 :         return ret;
     911                 :            : }
     912                 :            : #endif /* CONFIG_SYSCTL */
     913                 :            : 
     914                 :            : /* Put a breakpoint for a probe. Must be called with text_mutex locked */
     915                 :          0 : static void __arm_kprobe(struct kprobe *p)
     916                 :            : {
     917                 :          0 :         struct kprobe *_p;
     918                 :            : 
     919                 :            :         /* Check collision with other optimized kprobes */
     920                 :          0 :         _p = get_optimized_kprobe((unsigned long)p->addr);
     921         [ #  # ]:          0 :         if (unlikely(_p))
     922                 :            :                 /* Fallback to unoptimized kprobe */
     923                 :          0 :                 unoptimize_kprobe(_p, true);
     924                 :            : 
     925                 :          0 :         arch_arm_kprobe(p);
     926                 :          0 :         optimize_kprobe(p);     /* Try to optimize (add kprobe to a list) */
     927                 :          0 : }
     928                 :            : 
     929                 :            : /* Remove the breakpoint of a probe. Must be called with text_mutex locked */
     930                 :          0 : static void __disarm_kprobe(struct kprobe *p, bool reopt)
     931                 :            : {
     932                 :          0 :         struct kprobe *_p;
     933                 :            : 
     934                 :            :         /* Try to unoptimize */
     935                 :          0 :         unoptimize_kprobe(p, kprobes_all_disarmed);
     936                 :            : 
     937         [ #  # ]:          0 :         if (!kprobe_queued(p)) {
     938                 :          0 :                 arch_disarm_kprobe(p);
     939                 :            :                 /* If another kprobe was blocked, optimize it. */
     940                 :          0 :                 _p = get_optimized_kprobe((unsigned long)p->addr);
     941   [ #  #  #  # ]:          0 :                 if (unlikely(_p) && reopt)
     942                 :          0 :                         optimize_kprobe(_p);
     943                 :            :         }
     944                 :            :         /* TODO: reoptimize others after unoptimized this probe */
     945                 :          0 : }
     946                 :            : 
     947                 :            : #else /* !CONFIG_OPTPROBES */
     948                 :            : 
     949                 :            : #define optimize_kprobe(p)                      do {} while (0)
     950                 :            : #define unoptimize_kprobe(p, f)                 do {} while (0)
     951                 :            : #define kill_optimized_kprobe(p)                do {} while (0)
     952                 :            : #define prepare_optimized_kprobe(p)             do {} while (0)
     953                 :            : #define try_to_optimize_kprobe(p)               do {} while (0)
     954                 :            : #define __arm_kprobe(p)                         arch_arm_kprobe(p)
     955                 :            : #define __disarm_kprobe(p, o)                   arch_disarm_kprobe(p)
     956                 :            : #define kprobe_disarmed(p)                      kprobe_disabled(p)
     957                 :            : #define wait_for_kprobe_optimizer()             do {} while (0)
     958                 :            : 
     959                 :            : static int reuse_unused_kprobe(struct kprobe *ap)
     960                 :            : {
     961                 :            :         /*
     962                 :            :          * If the optimized kprobe is NOT supported, the aggr kprobe is
     963                 :            :          * released at the same time that the last aggregated kprobe is
     964                 :            :          * unregistered.
     965                 :            :          * Thus there should be no chance to reuse unused kprobe.
     966                 :            :          */
     967                 :            :         printk(KERN_ERR "Error: There should be no unused kprobe here.\n");
     968                 :            :         return -EINVAL;
     969                 :            : }
     970                 :            : 
     971                 :            : static void free_aggr_kprobe(struct kprobe *p)
     972                 :            : {
     973                 :            :         arch_remove_kprobe(p);
     974                 :            :         kfree(p);
     975                 :            : }
     976                 :            : 
     977                 :            : static struct kprobe *alloc_aggr_kprobe(struct kprobe *p)
     978                 :            : {
     979                 :            :         return kzalloc(sizeof(struct kprobe), GFP_KERNEL);
     980                 :            : }
     981                 :            : #endif /* CONFIG_OPTPROBES */
     982                 :            : 
     983                 :            : #ifdef CONFIG_KPROBES_ON_FTRACE
     984                 :            : static struct ftrace_ops kprobe_ftrace_ops __read_mostly = {
     985                 :            :         .func = kprobe_ftrace_handler,
     986                 :            :         .flags = FTRACE_OPS_FL_SAVE_REGS,
     987                 :            : };
     988                 :            : 
     989                 :            : static struct ftrace_ops kprobe_ipmodify_ops __read_mostly = {
     990                 :            :         .func = kprobe_ftrace_handler,
     991                 :            :         .flags = FTRACE_OPS_FL_SAVE_REGS | FTRACE_OPS_FL_IPMODIFY,
     992                 :            : };
     993                 :            : 
     994                 :            : static int kprobe_ipmodify_enabled;
     995                 :            : static int kprobe_ftrace_enabled;
     996                 :            : 
     997                 :            : /* Must ensure p->addr is really on ftrace */
     998                 :            : static int prepare_kprobe(struct kprobe *p)
     999                 :            : {
    1000                 :            :         if (!kprobe_ftrace(p))
    1001                 :            :                 return arch_prepare_kprobe(p);
    1002                 :            : 
    1003                 :            :         return arch_prepare_kprobe_ftrace(p);
    1004                 :            : }
    1005                 :            : 
    1006                 :            : /* Caller must lock kprobe_mutex */
    1007                 :            : static int __arm_kprobe_ftrace(struct kprobe *p, struct ftrace_ops *ops,
    1008                 :            :                                int *cnt)
    1009                 :            : {
    1010                 :            :         int ret = 0;
    1011                 :            : 
    1012                 :            :         ret = ftrace_set_filter_ip(ops, (unsigned long)p->addr, 0, 0);
    1013                 :            :         if (ret) {
    1014                 :            :                 pr_debug("Failed to arm kprobe-ftrace at %pS (%d)\n",
    1015                 :            :                          p->addr, ret);
    1016                 :            :                 return ret;
    1017                 :            :         }
    1018                 :            : 
    1019                 :            :         if (*cnt == 0) {
    1020                 :            :                 ret = register_ftrace_function(ops);
    1021                 :            :                 if (ret) {
    1022                 :            :                         pr_debug("Failed to init kprobe-ftrace (%d)\n", ret);
    1023                 :            :                         goto err_ftrace;
    1024                 :            :                 }
    1025                 :            :         }
    1026                 :            : 
    1027                 :            :         (*cnt)++;
    1028                 :            :         return ret;
    1029                 :            : 
    1030                 :            : err_ftrace:
    1031                 :            :         /*
    1032                 :            :          * At this point, sinec ops is not registered, we should be sefe from
    1033                 :            :          * registering empty filter.
    1034                 :            :          */
    1035                 :            :         ftrace_set_filter_ip(ops, (unsigned long)p->addr, 1, 0);
    1036                 :            :         return ret;
    1037                 :            : }
    1038                 :            : 
    1039                 :            : static int arm_kprobe_ftrace(struct kprobe *p)
    1040                 :            : {
    1041                 :            :         bool ipmodify = (p->post_handler != NULL);
    1042                 :            : 
    1043                 :            :         return __arm_kprobe_ftrace(p,
    1044                 :            :                 ipmodify ? &kprobe_ipmodify_ops : &kprobe_ftrace_ops,
    1045                 :            :                 ipmodify ? &kprobe_ipmodify_enabled : &kprobe_ftrace_enabled);
    1046                 :            : }
    1047                 :            : 
    1048                 :            : /* Caller must lock kprobe_mutex */
    1049                 :            : static int __disarm_kprobe_ftrace(struct kprobe *p, struct ftrace_ops *ops,
    1050                 :            :                                   int *cnt)
    1051                 :            : {
    1052                 :            :         int ret = 0;
    1053                 :            : 
    1054                 :            :         if (*cnt == 1) {
    1055                 :            :                 ret = unregister_ftrace_function(ops);
    1056                 :            :                 if (WARN(ret < 0, "Failed to unregister kprobe-ftrace (%d)\n", ret))
    1057                 :            :                         return ret;
    1058                 :            :         }
    1059                 :            : 
    1060                 :            :         (*cnt)--;
    1061                 :            : 
    1062                 :            :         ret = ftrace_set_filter_ip(ops, (unsigned long)p->addr, 1, 0);
    1063                 :            :         WARN_ONCE(ret < 0, "Failed to disarm kprobe-ftrace at %pS (%d)\n",
    1064                 :            :                   p->addr, ret);
    1065                 :            :         return ret;
    1066                 :            : }
    1067                 :            : 
    1068                 :            : static int disarm_kprobe_ftrace(struct kprobe *p)
    1069                 :            : {
    1070                 :            :         bool ipmodify = (p->post_handler != NULL);
    1071                 :            : 
    1072                 :            :         return __disarm_kprobe_ftrace(p,
    1073                 :            :                 ipmodify ? &kprobe_ipmodify_ops : &kprobe_ftrace_ops,
    1074                 :            :                 ipmodify ? &kprobe_ipmodify_enabled : &kprobe_ftrace_enabled);
    1075                 :            : }
    1076                 :            : #else   /* !CONFIG_KPROBES_ON_FTRACE */
    1077                 :            : #define prepare_kprobe(p)       arch_prepare_kprobe(p)
    1078                 :            : #define arm_kprobe_ftrace(p)    (-ENODEV)
    1079                 :            : #define disarm_kprobe_ftrace(p) (-ENODEV)
    1080                 :            : #endif
    1081                 :            : 
    1082                 :            : /* Arm a kprobe with text_mutex */
    1083                 :          0 : static int arm_kprobe(struct kprobe *kp)
    1084                 :            : {
    1085         [ #  # ]:          0 :         if (unlikely(kprobe_ftrace(kp)))
    1086                 :            :                 return arm_kprobe_ftrace(kp);
    1087                 :            : 
    1088                 :          0 :         cpus_read_lock();
    1089                 :          0 :         mutex_lock(&text_mutex);
    1090                 :          0 :         __arm_kprobe(kp);
    1091                 :          0 :         mutex_unlock(&text_mutex);
    1092                 :          0 :         cpus_read_unlock();
    1093                 :            : 
    1094                 :          0 :         return 0;
    1095                 :            : }
    1096                 :            : 
    1097                 :            : /* Disarm a kprobe with text_mutex */
    1098                 :          0 : static int disarm_kprobe(struct kprobe *kp, bool reopt)
    1099                 :            : {
    1100         [ #  # ]:          0 :         if (unlikely(kprobe_ftrace(kp)))
    1101                 :            :                 return disarm_kprobe_ftrace(kp);
    1102                 :            : 
    1103                 :          0 :         cpus_read_lock();
    1104                 :          0 :         mutex_lock(&text_mutex);
    1105                 :          0 :         __disarm_kprobe(kp, reopt);
    1106                 :          0 :         mutex_unlock(&text_mutex);
    1107                 :          0 :         cpus_read_unlock();
    1108                 :            : 
    1109                 :          0 :         return 0;
    1110                 :            : }
    1111                 :            : 
    1112                 :            : /*
    1113                 :            :  * Aggregate handlers for multiple kprobes support - these handlers
    1114                 :            :  * take care of invoking the individual kprobe handlers on p->list
    1115                 :            :  */
    1116                 :          0 : static int aggr_pre_handler(struct kprobe *p, struct pt_regs *regs)
    1117                 :            : {
    1118                 :          0 :         struct kprobe *kp;
    1119                 :            : 
    1120         [ #  # ]:          0 :         list_for_each_entry_rcu(kp, &p->list, list) {
    1121   [ #  #  #  # ]:          0 :                 if (kp->pre_handler && likely(!kprobe_disabled(kp))) {
    1122                 :          0 :                         set_kprobe_instance(kp);
    1123         [ #  # ]:          0 :                         if (kp->pre_handler(kp, regs))
    1124                 :            :                                 return 1;
    1125                 :            :                 }
    1126                 :          0 :                 reset_kprobe_instance();
    1127                 :            :         }
    1128                 :            :         return 0;
    1129                 :            : }
    1130                 :            : NOKPROBE_SYMBOL(aggr_pre_handler);
    1131                 :            : 
    1132                 :          0 : static void aggr_post_handler(struct kprobe *p, struct pt_regs *regs,
    1133                 :            :                               unsigned long flags)
    1134                 :            : {
    1135                 :          0 :         struct kprobe *kp;
    1136                 :            : 
    1137         [ #  # ]:          0 :         list_for_each_entry_rcu(kp, &p->list, list) {
    1138   [ #  #  #  # ]:          0 :                 if (kp->post_handler && likely(!kprobe_disabled(kp))) {
    1139                 :          0 :                         set_kprobe_instance(kp);
    1140                 :          0 :                         kp->post_handler(kp, regs, flags);
    1141                 :          0 :                         reset_kprobe_instance();
    1142                 :            :                 }
    1143                 :            :         }
    1144                 :          0 : }
    1145                 :            : NOKPROBE_SYMBOL(aggr_post_handler);
    1146                 :            : 
    1147                 :          0 : static int aggr_fault_handler(struct kprobe *p, struct pt_regs *regs,
    1148                 :            :                               int trapnr)
    1149                 :            : {
    1150         [ #  # ]:          0 :         struct kprobe *cur = __this_cpu_read(kprobe_instance);
    1151                 :            : 
    1152                 :            :         /*
    1153                 :            :          * if we faulted "during" the execution of a user specified
    1154                 :            :          * probe handler, invoke just that probe's fault handler
    1155                 :            :          */
    1156   [ #  #  #  # ]:          0 :         if (cur && cur->fault_handler) {
    1157         [ #  # ]:          0 :                 if (cur->fault_handler(cur, regs, trapnr))
    1158                 :          0 :                         return 1;
    1159                 :            :         }
    1160                 :            :         return 0;
    1161                 :            : }
    1162                 :            : NOKPROBE_SYMBOL(aggr_fault_handler);
    1163                 :            : 
    1164                 :            : /* Walks the list and increments nmissed count for multiprobe case */
    1165                 :          0 : void kprobes_inc_nmissed_count(struct kprobe *p)
    1166                 :            : {
    1167                 :          0 :         struct kprobe *kp;
    1168         [ #  # ]:          0 :         if (!kprobe_aggrprobe(p)) {
    1169                 :          0 :                 p->nmissed++;
    1170                 :            :         } else {
    1171         [ #  # ]:          0 :                 list_for_each_entry_rcu(kp, &p->list, list)
    1172                 :          0 :                         kp->nmissed++;
    1173                 :            :         }
    1174                 :          0 :         return;
    1175                 :            : }
    1176                 :            : NOKPROBE_SYMBOL(kprobes_inc_nmissed_count);
    1177                 :            : 
    1178                 :          0 : void recycle_rp_inst(struct kretprobe_instance *ri,
    1179                 :            :                      struct hlist_head *head)
    1180                 :            : {
    1181                 :          0 :         struct kretprobe *rp = ri->rp;
    1182                 :            : 
    1183                 :            :         /* remove rp inst off the rprobe_inst_table */
    1184         [ #  # ]:          0 :         hlist_del(&ri->hlist);
    1185         [ #  # ]:          0 :         INIT_HLIST_NODE(&ri->hlist);
    1186         [ #  # ]:          0 :         if (likely(rp)) {
    1187                 :          0 :                 raw_spin_lock(&rp->lock);
    1188         [ #  # ]:          0 :                 hlist_add_head(&ri->hlist, &rp->free_instances);
    1189                 :          0 :                 raw_spin_unlock(&rp->lock);
    1190                 :            :         } else
    1191                 :            :                 /* Unregistering */
    1192         [ #  # ]:          0 :                 hlist_add_head(&ri->hlist, head);
    1193                 :          0 : }
    1194                 :            : NOKPROBE_SYMBOL(recycle_rp_inst);
    1195                 :            : 
    1196                 :          0 : void kretprobe_hash_lock(struct task_struct *tsk,
    1197                 :            :                          struct hlist_head **head, unsigned long *flags)
    1198                 :            : __acquires(hlist_lock)
    1199                 :            : {
    1200                 :          0 :         unsigned long hash = hash_ptr(tsk, KPROBE_HASH_BITS);
    1201                 :          0 :         raw_spinlock_t *hlist_lock;
    1202                 :            : 
    1203                 :          0 :         *head = &kretprobe_inst_table[hash];
    1204                 :          0 :         hlist_lock = kretprobe_table_lock_ptr(hash);
    1205                 :          0 :         raw_spin_lock_irqsave(hlist_lock, *flags);
    1206                 :          0 : }
    1207                 :            : NOKPROBE_SYMBOL(kretprobe_hash_lock);
    1208                 :            : 
    1209                 :      56309 : static void kretprobe_table_lock(unsigned long hash,
    1210                 :            :                                  unsigned long *flags)
    1211                 :            : __acquires(hlist_lock)
    1212                 :            : {
    1213                 :      56309 :         raw_spinlock_t *hlist_lock = kretprobe_table_lock_ptr(hash);
    1214                 :          0 :         raw_spin_lock_irqsave(hlist_lock, *flags);
    1215                 :          0 : }
    1216                 :            : NOKPROBE_SYMBOL(kretprobe_table_lock);
    1217                 :            : 
    1218                 :          0 : void kretprobe_hash_unlock(struct task_struct *tsk,
    1219                 :            :                            unsigned long *flags)
    1220                 :            : __releases(hlist_lock)
    1221                 :            : {
    1222                 :          0 :         unsigned long hash = hash_ptr(tsk, KPROBE_HASH_BITS);
    1223                 :          0 :         raw_spinlock_t *hlist_lock;
    1224                 :            : 
    1225                 :          0 :         hlist_lock = kretprobe_table_lock_ptr(hash);
    1226                 :          0 :         raw_spin_unlock_irqrestore(hlist_lock, *flags);
    1227                 :          0 : }
    1228                 :            : NOKPROBE_SYMBOL(kretprobe_hash_unlock);
    1229                 :            : 
    1230                 :      56309 : static void kretprobe_table_unlock(unsigned long hash,
    1231                 :            :                                    unsigned long *flags)
    1232                 :            : __releases(hlist_lock)
    1233                 :            : {
    1234                 :      56309 :         raw_spinlock_t *hlist_lock = kretprobe_table_lock_ptr(hash);
    1235                 :          0 :         raw_spin_unlock_irqrestore(hlist_lock, *flags);
    1236                 :          0 : }
    1237                 :            : NOKPROBE_SYMBOL(kretprobe_table_unlock);
    1238                 :            : 
    1239                 :            : /*
    1240                 :            :  * This function is called from finish_task_switch when task tk becomes dead,
    1241                 :            :  * so that we can recycle any function-return probe instances associated
    1242                 :            :  * with this task. These left over instances represent probed functions
    1243                 :            :  * that have been called but will never return.
    1244                 :            :  */
    1245                 :      56309 : void kprobe_flush_task(struct task_struct *tk)
    1246                 :            : {
    1247                 :      56309 :         struct kretprobe_instance *ri;
    1248                 :      56309 :         struct hlist_head *head, empty_rp;
    1249                 :      56309 :         struct hlist_node *tmp;
    1250                 :      56309 :         unsigned long hash, flags = 0;
    1251                 :            : 
    1252         [ -  + ]:      56309 :         if (unlikely(!kprobes_initialized))
    1253                 :            :                 /* Early boot.  kretprobe_table_locks not yet initialized. */
    1254                 :          0 :                 return;
    1255                 :            : 
    1256                 :      56309 :         INIT_HLIST_HEAD(&empty_rp);
    1257                 :      56309 :         hash = hash_ptr(tk, KPROBE_HASH_BITS);
    1258                 :      56309 :         head = &kretprobe_inst_table[hash];
    1259                 :      56309 :         kretprobe_table_lock(hash, &flags);
    1260   [ +  -  -  -  :     112618 :         hlist_for_each_entry_safe(ri, tmp, head, hlist) {
                   -  + ]
    1261         [ #  # ]:          0 :                 if (ri->task == tk)
    1262                 :          0 :                         recycle_rp_inst(ri, &empty_rp);
    1263                 :            :         }
    1264                 :      56309 :         kretprobe_table_unlock(hash, &flags);
    1265   [ +  -  -  -  :     112618 :         hlist_for_each_entry_safe(ri, tmp, &empty_rp, hlist) {
                   -  + ]
    1266         [ #  # ]:          0 :                 hlist_del(&ri->hlist);
    1267                 :          0 :                 kfree(ri);
    1268                 :            :         }
    1269                 :            : }
    1270                 :            : NOKPROBE_SYMBOL(kprobe_flush_task);
    1271                 :            : 
    1272                 :            : static inline void free_rp_inst(struct kretprobe *rp)
    1273                 :            : {
    1274                 :            :         struct kretprobe_instance *ri;
    1275                 :            :         struct hlist_node *next;
    1276                 :            : 
    1277                 :            :         hlist_for_each_entry_safe(ri, next, &rp->free_instances, hlist) {
    1278                 :            :                 hlist_del(&ri->hlist);
    1279                 :            :                 kfree(ri);
    1280                 :            :         }
    1281                 :            : }
    1282                 :            : 
    1283                 :          0 : static void cleanup_rp_inst(struct kretprobe *rp)
    1284                 :            : {
    1285                 :          0 :         unsigned long flags, hash;
    1286                 :          0 :         struct kretprobe_instance *ri;
    1287                 :          0 :         struct hlist_node *next;
    1288                 :          0 :         struct hlist_head *head;
    1289                 :            : 
    1290                 :            :         /* No race here */
    1291         [ #  # ]:          0 :         for (hash = 0; hash < KPROBE_TABLE_SIZE; hash++) {
    1292                 :          0 :                 kretprobe_table_lock(hash, &flags);
    1293                 :          0 :                 head = &kretprobe_inst_table[hash];
    1294   [ #  #  #  #  :          0 :                 hlist_for_each_entry_safe(ri, next, head, hlist) {
                   #  # ]
    1295         [ #  # ]:          0 :                         if (ri->rp == rp)
    1296                 :          0 :                                 ri->rp = NULL;
    1297                 :            :                 }
    1298                 :          0 :                 kretprobe_table_unlock(hash, &flags);
    1299                 :            :         }
    1300                 :          0 :         free_rp_inst(rp);
    1301                 :          0 : }
    1302                 :            : NOKPROBE_SYMBOL(cleanup_rp_inst);
    1303                 :            : 
    1304                 :            : /* Add the new probe to ap->list */
    1305                 :          0 : static int add_new_kprobe(struct kprobe *ap, struct kprobe *p)
    1306                 :            : {
    1307         [ #  # ]:          0 :         if (p->post_handler)
    1308                 :          0 :                 unoptimize_kprobe(ap, true);    /* Fall back to normal kprobe */
    1309                 :            : 
    1310                 :          0 :         list_add_rcu(&p->list, &ap->list);
    1311   [ #  #  #  # ]:          0 :         if (p->post_handler && !ap->post_handler)
    1312                 :          0 :                 ap->post_handler = aggr_post_handler;
    1313                 :            : 
    1314                 :          0 :         return 0;
    1315                 :            : }
    1316                 :            : 
    1317                 :            : /*
    1318                 :            :  * Fill in the required fields of the "manager kprobe". Replace the
    1319                 :            :  * earlier kprobe in the hlist with the manager kprobe
    1320                 :            :  */
    1321                 :          0 : static void init_aggr_kprobe(struct kprobe *ap, struct kprobe *p)
    1322                 :            : {
    1323                 :            :         /* Copy p's insn slot to ap */
    1324                 :          0 :         copy_kprobe(p, ap);
    1325                 :          0 :         flush_insn_slot(ap);
    1326                 :          0 :         ap->addr = p->addr;
    1327                 :          0 :         ap->flags = p->flags & ~KPROBE_FLAG_OPTIMIZED;
    1328                 :          0 :         ap->pre_handler = aggr_pre_handler;
    1329                 :          0 :         ap->fault_handler = aggr_fault_handler;
    1330                 :            :         /* We don't care the kprobe which has gone. */
    1331   [ #  #  #  # ]:          0 :         if (p->post_handler && !kprobe_gone(p))
    1332                 :          0 :                 ap->post_handler = aggr_post_handler;
    1333                 :            : 
    1334                 :          0 :         INIT_LIST_HEAD(&ap->list);
    1335                 :          0 :         INIT_HLIST_NODE(&ap->hlist);
    1336                 :            : 
    1337                 :          0 :         list_add_rcu(&p->list, &ap->list);
    1338                 :          0 :         hlist_replace_rcu(&p->hlist, &ap->hlist);
    1339                 :          0 : }
    1340                 :            : 
    1341                 :            : /*
    1342                 :            :  * This is the second or subsequent kprobe at the address - handle
    1343                 :            :  * the intricacies
    1344                 :            :  */
    1345                 :          0 : static int register_aggr_kprobe(struct kprobe *orig_p, struct kprobe *p)
    1346                 :            : {
    1347                 :          0 :         int ret = 0;
    1348                 :          0 :         struct kprobe *ap = orig_p;
    1349                 :            : 
    1350                 :          0 :         cpus_read_lock();
    1351                 :            : 
    1352                 :            :         /* For preparing optimization, jump_label_text_reserved() is called */
    1353                 :          0 :         jump_label_lock();
    1354                 :          0 :         mutex_lock(&text_mutex);
    1355                 :            : 
    1356         [ #  # ]:          0 :         if (!kprobe_aggrprobe(orig_p)) {
    1357                 :            :                 /* If orig_p is not an aggr_kprobe, create new aggr_kprobe. */
    1358                 :          0 :                 ap = alloc_aggr_kprobe(orig_p);
    1359         [ #  # ]:          0 :                 if (!ap) {
    1360                 :          0 :                         ret = -ENOMEM;
    1361                 :          0 :                         goto out;
    1362                 :            :                 }
    1363                 :          0 :                 init_aggr_kprobe(ap, orig_p);
    1364         [ #  # ]:          0 :         } else if (kprobe_unused(ap)) {
    1365                 :            :                 /* This probe is going to die. Rescue it */
    1366                 :          0 :                 ret = reuse_unused_kprobe(ap);
    1367         [ #  # ]:          0 :                 if (ret)
    1368                 :          0 :                         goto out;
    1369                 :            :         }
    1370                 :            : 
    1371         [ #  # ]:          0 :         if (kprobe_gone(ap)) {
    1372                 :            :                 /*
    1373                 :            :                  * Attempting to insert new probe at the same location that
    1374                 :            :                  * had a probe in the module vaddr area which already
    1375                 :            :                  * freed. So, the instruction slot has already been
    1376                 :            :                  * released. We need a new slot for the new probe.
    1377                 :            :                  */
    1378                 :          0 :                 ret = arch_prepare_kprobe(ap);
    1379         [ #  # ]:          0 :                 if (ret)
    1380                 :            :                         /*
    1381                 :            :                          * Even if fail to allocate new slot, don't need to
    1382                 :            :                          * free aggr_probe. It will be used next time, or
    1383                 :            :                          * freed by unregister_kprobe.
    1384                 :            :                          */
    1385                 :          0 :                         goto out;
    1386                 :            : 
    1387                 :            :                 /* Prepare optimized instructions if possible. */
    1388         [ #  # ]:          0 :                 prepare_optimized_kprobe(ap);
    1389                 :            : 
    1390                 :            :                 /*
    1391                 :            :                  * Clear gone flag to prevent allocating new slot again, and
    1392                 :            :                  * set disabled flag because it is not armed yet.
    1393                 :            :                  */
    1394                 :          0 :                 ap->flags = (ap->flags & ~KPROBE_FLAG_GONE)
    1395                 :          0 :                             | KPROBE_FLAG_DISABLED;
    1396                 :            :         }
    1397                 :            : 
    1398                 :            :         /* Copy ap's insn slot to p */
    1399                 :          0 :         copy_kprobe(ap, p);
    1400                 :          0 :         ret = add_new_kprobe(ap, p);
    1401                 :            : 
    1402                 :          0 : out:
    1403                 :          0 :         mutex_unlock(&text_mutex);
    1404                 :          0 :         jump_label_unlock();
    1405                 :          0 :         cpus_read_unlock();
    1406                 :            : 
    1407   [ #  #  #  #  :          0 :         if (ret == 0 && kprobe_disabled(ap) && !kprobe_disabled(p)) {
                   #  # ]
    1408                 :          0 :                 ap->flags &= ~KPROBE_FLAG_DISABLED;
    1409         [ #  # ]:          0 :                 if (!kprobes_all_disarmed) {
    1410                 :            :                         /* Arm the breakpoint again. */
    1411                 :          0 :                         ret = arm_kprobe(ap);
    1412         [ #  # ]:          0 :                         if (ret) {
    1413                 :          0 :                                 ap->flags |= KPROBE_FLAG_DISABLED;
    1414                 :          0 :                                 list_del_rcu(&p->list);
    1415                 :          0 :                                 synchronize_rcu();
    1416                 :            :                         }
    1417                 :            :                 }
    1418                 :            :         }
    1419                 :          0 :         return ret;
    1420                 :            : }
    1421                 :            : 
    1422                 :          0 : bool __weak arch_within_kprobe_blacklist(unsigned long addr)
    1423                 :            : {
    1424                 :            :         /* The __kprobes marked functions and entry code must not be probed */
    1425         [ #  # ]:          0 :         return addr >= (unsigned long)__kprobes_text_start &&
    1426         [ #  # ]:          0 :                addr < (unsigned long)__kprobes_text_end;
    1427                 :            : }
    1428                 :            : 
    1429                 :          0 : static bool __within_kprobe_blacklist(unsigned long addr)
    1430                 :            : {
    1431                 :          0 :         struct kprobe_blacklist_entry *ent;
    1432                 :            : 
    1433         [ #  # ]:          0 :         if (arch_within_kprobe_blacklist(addr))
    1434                 :            :                 return true;
    1435                 :            :         /*
    1436                 :            :          * If there exists a kprobe_blacklist, verify and
    1437                 :            :          * fail any probe registration in the prohibited area
    1438                 :            :          */
    1439         [ #  # ]:          0 :         list_for_each_entry(ent, &kprobe_blacklist, list) {
    1440   [ #  #  #  # ]:          0 :                 if (addr >= ent->start_addr && addr < ent->end_addr)
    1441                 :            :                         return true;
    1442                 :            :         }
    1443                 :            :         return false;
    1444                 :            : }
    1445                 :            : 
    1446                 :          0 : bool within_kprobe_blacklist(unsigned long addr)
    1447                 :            : {
    1448                 :          0 :         char symname[KSYM_NAME_LEN], *p;
    1449                 :            : 
    1450         [ #  # ]:          0 :         if (__within_kprobe_blacklist(addr))
    1451                 :            :                 return true;
    1452                 :            : 
    1453                 :            :         /* Check if the address is on a suffixed-symbol */
    1454         [ #  # ]:          0 :         if (!lookup_symbol_name(addr, symname)) {
    1455                 :          0 :                 p = strchr(symname, '.');
    1456         [ #  # ]:          0 :                 if (!p)
    1457                 :            :                         return false;
    1458                 :          0 :                 *p = '\0';
    1459                 :          0 :                 addr = (unsigned long)kprobe_lookup_name(symname, 0);
    1460         [ #  # ]:          0 :                 if (addr)
    1461                 :          0 :                         return __within_kprobe_blacklist(addr);
    1462                 :            :         }
    1463                 :            :         return false;
    1464                 :            : }
    1465                 :            : 
    1466                 :            : /*
    1467                 :            :  * If we have a symbol_name argument, look it up and add the offset field
    1468                 :            :  * to it. This way, we can specify a relative address to a symbol.
    1469                 :            :  * This returns encoded errors if it fails to look up symbol or invalid
    1470                 :            :  * combination of parameters.
    1471                 :            :  */
    1472                 :          0 : static kprobe_opcode_t *_kprobe_addr(kprobe_opcode_t *addr,
    1473                 :            :                         const char *symbol_name, unsigned int offset)
    1474                 :            : {
    1475         [ #  # ]:          0 :         if ((symbol_name && addr) || (!symbol_name && !addr))
    1476                 :          0 :                 goto invalid;
    1477                 :            : 
    1478         [ #  # ]:          0 :         if (symbol_name) {
    1479                 :          0 :                 addr = kprobe_lookup_name(symbol_name, offset);
    1480         [ #  # ]:          0 :                 if (!addr)
    1481                 :            :                         return ERR_PTR(-ENOENT);
    1482                 :            :         }
    1483                 :            : 
    1484                 :          0 :         addr = (kprobe_opcode_t *)(((char *)addr) + offset);
    1485         [ #  # ]:          0 :         if (addr)
    1486                 :          0 :                 return addr;
    1487                 :            : 
    1488                 :          0 : invalid:
    1489                 :            :         return ERR_PTR(-EINVAL);
    1490                 :            : }
    1491                 :            : 
    1492                 :          0 : static kprobe_opcode_t *kprobe_addr(struct kprobe *p)
    1493                 :            : {
    1494                 :          0 :         return _kprobe_addr(p->addr, p->symbol_name, p->offset);
    1495                 :            : }
    1496                 :            : 
    1497                 :            : /* Check passed kprobe is valid and return kprobe in kprobe_table. */
    1498                 :          0 : static struct kprobe *__get_valid_kprobe(struct kprobe *p)
    1499                 :            : {
    1500                 :          0 :         struct kprobe *ap, *list_p;
    1501                 :            : 
    1502                 :          0 :         ap = get_kprobe(p->addr);
    1503         [ #  # ]:          0 :         if (unlikely(!ap))
    1504                 :            :                 return NULL;
    1505                 :            : 
    1506         [ #  # ]:          0 :         if (p != ap) {
    1507         [ #  # ]:          0 :                 list_for_each_entry_rcu(list_p, &ap->list, list)
    1508         [ #  # ]:          0 :                         if (list_p == p)
    1509                 :            :                         /* kprobe p is a valid probe */
    1510                 :          0 :                                 goto valid;
    1511                 :            :                 return NULL;
    1512                 :            :         }
    1513                 :          0 : valid:
    1514                 :            :         return ap;
    1515                 :            : }
    1516                 :            : 
    1517                 :            : /* Return error if the kprobe is being re-registered */
    1518                 :          0 : static inline int check_kprobe_rereg(struct kprobe *p)
    1519                 :            : {
    1520                 :          0 :         int ret = 0;
    1521                 :            : 
    1522                 :          0 :         mutex_lock(&kprobe_mutex);
    1523         [ #  # ]:          0 :         if (__get_valid_kprobe(p))
    1524                 :          0 :                 ret = -EINVAL;
    1525                 :          0 :         mutex_unlock(&kprobe_mutex);
    1526                 :            : 
    1527                 :          0 :         return ret;
    1528                 :            : }
    1529                 :            : 
    1530                 :          0 : int __weak arch_check_ftrace_location(struct kprobe *p)
    1531                 :            : {
    1532                 :          0 :         unsigned long ftrace_addr;
    1533                 :            : 
    1534                 :          0 :         ftrace_addr = ftrace_location((unsigned long)p->addr);
    1535                 :          0 :         if (ftrace_addr) {
    1536                 :            : #ifdef CONFIG_KPROBES_ON_FTRACE
    1537                 :            :                 /* Given address is not on the instruction boundary */
    1538                 :            :                 if ((unsigned long)p->addr != ftrace_addr)
    1539                 :            :                         return -EILSEQ;
    1540                 :            :                 p->flags |= KPROBE_FLAG_FTRACE;
    1541                 :            : #else   /* !CONFIG_KPROBES_ON_FTRACE */
    1542                 :            :                 return -EINVAL;
    1543                 :            : #endif
    1544                 :            :         }
    1545                 :          0 :         return 0;
    1546                 :            : }
    1547                 :            : 
    1548                 :          0 : static int check_kprobe_address_safe(struct kprobe *p,
    1549                 :            :                                      struct module **probed_mod)
    1550                 :            : {
    1551                 :          0 :         int ret;
    1552                 :            : 
    1553                 :          0 :         ret = arch_check_ftrace_location(p);
    1554         [ #  # ]:          0 :         if (ret)
    1555                 :            :                 return ret;
    1556                 :          0 :         jump_label_lock();
    1557                 :          0 :         preempt_disable();
    1558                 :            : 
    1559                 :            :         /* Ensure it is not in reserved area nor out of text */
    1560   [ #  #  #  # ]:          0 :         if (!kernel_text_address((unsigned long) p->addr) ||
    1561         [ #  # ]:          0 :             within_kprobe_blacklist((unsigned long) p->addr) ||
    1562         [ #  # ]:          0 :             jump_label_text_reserved(p->addr, p->addr) ||
    1563                 :          0 :             find_bug((unsigned long)p->addr)) {
    1564                 :          0 :                 ret = -EINVAL;
    1565                 :          0 :                 goto out;
    1566                 :            :         }
    1567                 :            : 
    1568                 :            :         /* Check if are we probing a module */
    1569                 :          0 :         *probed_mod = __module_text_address((unsigned long) p->addr);
    1570         [ #  # ]:          0 :         if (*probed_mod) {
    1571                 :            :                 /*
    1572                 :            :                  * We must hold a refcount of the probed module while updating
    1573                 :            :                  * its code to prohibit unexpected unloading.
    1574                 :            :                  */
    1575         [ #  # ]:          0 :                 if (unlikely(!try_module_get(*probed_mod))) {
    1576                 :          0 :                         ret = -ENOENT;
    1577                 :          0 :                         goto out;
    1578                 :            :                 }
    1579                 :            : 
    1580                 :            :                 /*
    1581                 :            :                  * If the module freed .init.text, we couldn't insert
    1582                 :            :                  * kprobes in there.
    1583                 :            :                  */
    1584   [ #  #  #  # ]:          0 :                 if (within_module_init((unsigned long)p->addr, *probed_mod) &&
    1585         [ #  # ]:          0 :                     (*probed_mod)->state != MODULE_STATE_COMING) {
    1586                 :          0 :                         module_put(*probed_mod);
    1587                 :          0 :                         *probed_mod = NULL;
    1588                 :          0 :                         ret = -ENOENT;
    1589                 :            :                 }
    1590                 :            :         }
    1591                 :          0 : out:
    1592                 :          0 :         preempt_enable();
    1593                 :          0 :         jump_label_unlock();
    1594                 :            : 
    1595                 :          0 :         return ret;
    1596                 :            : }
    1597                 :            : 
    1598                 :          0 : int register_kprobe(struct kprobe *p)
    1599                 :            : {
    1600                 :          0 :         int ret;
    1601                 :          0 :         struct kprobe *old_p;
    1602                 :          0 :         struct module *probed_mod;
    1603                 :          0 :         kprobe_opcode_t *addr;
    1604                 :            : 
    1605                 :            :         /* Adjust probe address from symbol */
    1606                 :          0 :         addr = kprobe_addr(p);
    1607         [ #  # ]:          0 :         if (IS_ERR(addr))
    1608                 :          0 :                 return PTR_ERR(addr);
    1609                 :          0 :         p->addr = addr;
    1610                 :            : 
    1611                 :          0 :         ret = check_kprobe_rereg(p);
    1612         [ #  # ]:          0 :         if (ret)
    1613                 :            :                 return ret;
    1614                 :            : 
    1615                 :            :         /* User can pass only KPROBE_FLAG_DISABLED to register_kprobe */
    1616                 :          0 :         p->flags &= KPROBE_FLAG_DISABLED;
    1617                 :          0 :         p->nmissed = 0;
    1618                 :          0 :         INIT_LIST_HEAD(&p->list);
    1619                 :            : 
    1620                 :          0 :         ret = check_kprobe_address_safe(p, &probed_mod);
    1621         [ #  # ]:          0 :         if (ret)
    1622                 :            :                 return ret;
    1623                 :            : 
    1624                 :          0 :         mutex_lock(&kprobe_mutex);
    1625                 :            : 
    1626                 :          0 :         old_p = get_kprobe(p->addr);
    1627         [ #  # ]:          0 :         if (old_p) {
    1628                 :            :                 /* Since this may unoptimize old_p, locking text_mutex. */
    1629                 :          0 :                 ret = register_aggr_kprobe(old_p, p);
    1630                 :          0 :                 goto out;
    1631                 :            :         }
    1632                 :            : 
    1633                 :          0 :         cpus_read_lock();
    1634                 :            :         /* Prevent text modification */
    1635                 :          0 :         mutex_lock(&text_mutex);
    1636                 :          0 :         ret = prepare_kprobe(p);
    1637                 :          0 :         mutex_unlock(&text_mutex);
    1638                 :          0 :         cpus_read_unlock();
    1639         [ #  # ]:          0 :         if (ret)
    1640                 :          0 :                 goto out;
    1641                 :            : 
    1642                 :          0 :         INIT_HLIST_NODE(&p->hlist);
    1643                 :          0 :         hlist_add_head_rcu(&p->hlist,
    1644                 :          0 :                        &kprobe_table[hash_ptr(p->addr, KPROBE_HASH_BITS)]);
    1645                 :            : 
    1646   [ #  #  #  # ]:          0 :         if (!kprobes_all_disarmed && !kprobe_disabled(p)) {
    1647                 :          0 :                 ret = arm_kprobe(p);
    1648         [ #  # ]:          0 :                 if (ret) {
    1649         [ #  # ]:          0 :                         hlist_del_rcu(&p->hlist);
    1650                 :          0 :                         synchronize_rcu();
    1651                 :          0 :                         goto out;
    1652                 :            :                 }
    1653                 :            :         }
    1654                 :            : 
    1655                 :            :         /* Try to optimize kprobe */
    1656                 :          0 :         try_to_optimize_kprobe(p);
    1657                 :          0 : out:
    1658                 :          0 :         mutex_unlock(&kprobe_mutex);
    1659                 :            : 
    1660         [ #  # ]:          0 :         if (probed_mod)
    1661                 :          0 :                 module_put(probed_mod);
    1662                 :            : 
    1663                 :            :         return ret;
    1664                 :            : }
    1665                 :            : EXPORT_SYMBOL_GPL(register_kprobe);
    1666                 :            : 
    1667                 :            : /* Check if all probes on the aggrprobe are disabled */
    1668                 :          0 : static int aggr_kprobe_disabled(struct kprobe *ap)
    1669                 :            : {
    1670                 :          0 :         struct kprobe *kp;
    1671                 :            : 
    1672         [ #  # ]:          0 :         list_for_each_entry_rcu(kp, &ap->list, list)
    1673         [ #  # ]:          0 :                 if (!kprobe_disabled(kp))
    1674                 :            :                         /*
    1675                 :            :                          * There is an active probe on the list.
    1676                 :            :                          * We can't disable this ap.
    1677                 :            :                          */
    1678                 :            :                         return 0;
    1679                 :            : 
    1680                 :            :         return 1;
    1681                 :            : }
    1682                 :            : 
    1683                 :            : /* Disable one kprobe: Make sure called under kprobe_mutex is locked */
    1684                 :          0 : static struct kprobe *__disable_kprobe(struct kprobe *p)
    1685                 :            : {
    1686                 :          0 :         struct kprobe *orig_p;
    1687                 :          0 :         int ret;
    1688                 :            : 
    1689                 :            :         /* Get an original kprobe for return */
    1690                 :          0 :         orig_p = __get_valid_kprobe(p);
    1691         [ #  # ]:          0 :         if (unlikely(orig_p == NULL))
    1692                 :            :                 return ERR_PTR(-EINVAL);
    1693                 :            : 
    1694         [ #  # ]:          0 :         if (!kprobe_disabled(p)) {
    1695                 :            :                 /* Disable probe if it is a child probe */
    1696         [ #  # ]:          0 :                 if (p != orig_p)
    1697                 :          0 :                         p->flags |= KPROBE_FLAG_DISABLED;
    1698                 :            : 
    1699                 :            :                 /* Try to disarm and disable this/parent probe */
    1700   [ #  #  #  # ]:          0 :                 if (p == orig_p || aggr_kprobe_disabled(orig_p)) {
    1701                 :            :                         /*
    1702                 :            :                          * If kprobes_all_disarmed is set, orig_p
    1703                 :            :                          * should have already been disarmed, so
    1704                 :            :                          * skip unneed disarming process.
    1705                 :            :                          */
    1706         [ #  # ]:          0 :                         if (!kprobes_all_disarmed) {
    1707                 :          0 :                                 ret = disarm_kprobe(orig_p, true);
    1708         [ #  # ]:          0 :                                 if (ret) {
    1709                 :          0 :                                         p->flags &= ~KPROBE_FLAG_DISABLED;
    1710                 :          0 :                                         return ERR_PTR(ret);
    1711                 :            :                                 }
    1712                 :            :                         }
    1713                 :          0 :                         orig_p->flags |= KPROBE_FLAG_DISABLED;
    1714                 :            :                 }
    1715                 :            :         }
    1716                 :            : 
    1717                 :            :         return orig_p;
    1718                 :            : }
    1719                 :            : 
    1720                 :            : /*
    1721                 :            :  * Unregister a kprobe without a scheduler synchronization.
    1722                 :            :  */
    1723                 :          0 : static int __unregister_kprobe_top(struct kprobe *p)
    1724                 :            : {
    1725                 :          0 :         struct kprobe *ap, *list_p;
    1726                 :            : 
    1727                 :            :         /* Disable kprobe. This will disarm it if needed. */
    1728                 :          0 :         ap = __disable_kprobe(p);
    1729         [ #  # ]:          0 :         if (IS_ERR(ap))
    1730                 :          0 :                 return PTR_ERR(ap);
    1731                 :            : 
    1732         [ #  # ]:          0 :         if (ap == p)
    1733                 :            :                 /*
    1734                 :            :                  * This probe is an independent(and non-optimized) kprobe
    1735                 :            :                  * (not an aggrprobe). Remove from the hash list.
    1736                 :            :                  */
    1737                 :          0 :                 goto disarmed;
    1738                 :            : 
    1739                 :            :         /* Following process expects this probe is an aggrprobe */
    1740         [ #  # ]:          0 :         WARN_ON(!kprobe_aggrprobe(ap));
    1741                 :            : 
    1742   [ #  #  #  # ]:          0 :         if (list_is_singular(&ap->list) && kprobe_disarmed(ap))
    1743                 :            :                 /*
    1744                 :            :                  * !disarmed could be happen if the probe is under delayed
    1745                 :            :                  * unoptimizing.
    1746                 :            :                  */
    1747                 :          0 :                 goto disarmed;
    1748                 :            :         else {
    1749                 :            :                 /* If disabling probe has special handlers, update aggrprobe */
    1750   [ #  #  #  # ]:          0 :                 if (p->post_handler && !kprobe_gone(p)) {
    1751         [ #  # ]:          0 :                         list_for_each_entry_rcu(list_p, &ap->list, list) {
    1752   [ #  #  #  # ]:          0 :                                 if ((list_p != p) && (list_p->post_handler))
    1753                 :          0 :                                         goto noclean;
    1754                 :            :                         }
    1755                 :          0 :                         ap->post_handler = NULL;
    1756                 :            :                 }
    1757                 :          0 : noclean:
    1758                 :            :                 /*
    1759                 :            :                  * Remove from the aggrprobe: this path will do nothing in
    1760                 :            :                  * __unregister_kprobe_bottom().
    1761                 :            :                  */
    1762         [ #  # ]:          0 :                 list_del_rcu(&p->list);
    1763   [ #  #  #  # ]:          0 :                 if (!kprobe_disabled(ap) && !kprobes_all_disarmed)
    1764                 :            :                         /*
    1765                 :            :                          * Try to optimize this probe again, because post
    1766                 :            :                          * handler may have been changed.
    1767                 :            :                          */
    1768                 :          0 :                         optimize_kprobe(ap);
    1769                 :            :         }
    1770                 :            :         return 0;
    1771                 :            : 
    1772                 :          0 : disarmed:
    1773         [ #  # ]:          0 :         hlist_del_rcu(&ap->hlist);
    1774                 :          0 :         return 0;
    1775                 :            : }
    1776                 :            : 
    1777                 :          0 : static void __unregister_kprobe_bottom(struct kprobe *p)
    1778                 :            : {
    1779                 :          0 :         struct kprobe *ap;
    1780                 :            : 
    1781         [ #  # ]:          0 :         if (list_empty(&p->list))
    1782                 :            :                 /* This is an independent kprobe */
    1783                 :          0 :                 arch_remove_kprobe(p);
    1784         [ #  # ]:          0 :         else if (list_is_singular(&p->list)) {
    1785                 :            :                 /* This is the last child of an aggrprobe */
    1786                 :          0 :                 ap = list_entry(p->list.next, struct kprobe, list);
    1787                 :          0 :                 list_del(&p->list);
    1788                 :          0 :                 free_aggr_kprobe(ap);
    1789                 :            :         }
    1790                 :            :         /* Otherwise, do nothing. */
    1791                 :          0 : }
    1792                 :            : 
    1793                 :          0 : int register_kprobes(struct kprobe **kps, int num)
    1794                 :            : {
    1795                 :          0 :         int i, ret = 0;
    1796                 :            : 
    1797         [ #  # ]:          0 :         if (num <= 0)
    1798                 :            :                 return -EINVAL;
    1799         [ #  # ]:          0 :         for (i = 0; i < num; i++) {
    1800                 :          0 :                 ret = register_kprobe(kps[i]);
    1801         [ #  # ]:          0 :                 if (ret < 0) {
    1802         [ #  # ]:          0 :                         if (i > 0)
    1803                 :          0 :                                 unregister_kprobes(kps, i);
    1804                 :            :                         break;
    1805                 :            :                 }
    1806                 :            :         }
    1807                 :            :         return ret;
    1808                 :            : }
    1809                 :            : EXPORT_SYMBOL_GPL(register_kprobes);
    1810                 :            : 
    1811                 :          0 : void unregister_kprobe(struct kprobe *p)
    1812                 :            : {
    1813                 :          0 :         unregister_kprobes(&p, 1);
    1814                 :          0 : }
    1815                 :            : EXPORT_SYMBOL_GPL(unregister_kprobe);
    1816                 :            : 
    1817                 :          0 : void unregister_kprobes(struct kprobe **kps, int num)
    1818                 :            : {
    1819                 :          0 :         int i;
    1820                 :            : 
    1821         [ #  # ]:          0 :         if (num <= 0)
    1822                 :            :                 return;
    1823                 :          0 :         mutex_lock(&kprobe_mutex);
    1824         [ #  # ]:          0 :         for (i = 0; i < num; i++)
    1825         [ #  # ]:          0 :                 if (__unregister_kprobe_top(kps[i]) < 0)
    1826                 :          0 :                         kps[i]->addr = NULL;
    1827                 :          0 :         mutex_unlock(&kprobe_mutex);
    1828                 :            : 
    1829                 :          0 :         synchronize_rcu();
    1830         [ #  # ]:          0 :         for (i = 0; i < num; i++)
    1831         [ #  # ]:          0 :                 if (kps[i]->addr)
    1832                 :          0 :                         __unregister_kprobe_bottom(kps[i]);
    1833                 :            : }
    1834                 :            : EXPORT_SYMBOL_GPL(unregister_kprobes);
    1835                 :            : 
    1836                 :          0 : int __weak kprobe_exceptions_notify(struct notifier_block *self,
    1837                 :            :                                         unsigned long val, void *data)
    1838                 :            : {
    1839                 :          0 :         return NOTIFY_DONE;
    1840                 :            : }
    1841                 :            : NOKPROBE_SYMBOL(kprobe_exceptions_notify);
    1842                 :            : 
    1843                 :            : static struct notifier_block kprobe_exceptions_nb = {
    1844                 :            :         .notifier_call = kprobe_exceptions_notify,
    1845                 :            :         .priority = 0x7fffffff /* we need to be notified first */
    1846                 :            : };
    1847                 :            : 
    1848                 :      82368 : unsigned long __weak arch_deref_entry_point(void *entry)
    1849                 :            : {
    1850                 :      82368 :         return (unsigned long)entry;
    1851                 :            : }
    1852                 :            : 
    1853                 :            : #ifdef CONFIG_KRETPROBES
    1854                 :            : /*
    1855                 :            :  * This kprobe pre_handler is registered with every kretprobe. When probe
    1856                 :            :  * hits it will set up the return probe.
    1857                 :            :  */
    1858                 :          0 : static int pre_handler_kretprobe(struct kprobe *p, struct pt_regs *regs)
    1859                 :            : {
    1860                 :          0 :         struct kretprobe *rp = container_of(p, struct kretprobe, kp);
    1861                 :          0 :         unsigned long hash, flags = 0;
    1862                 :          0 :         struct kretprobe_instance *ri;
    1863                 :            : 
    1864                 :            :         /*
    1865                 :            :          * To avoid deadlocks, prohibit return probing in NMI contexts,
    1866                 :            :          * just skip the probe and increase the (inexact) 'nmissed'
    1867                 :            :          * statistical counter, so that the user is informed that
    1868                 :            :          * something happened:
    1869                 :            :          */
    1870         [ #  # ]:          0 :         if (unlikely(in_nmi())) {
    1871                 :          0 :                 rp->nmissed++;
    1872                 :          0 :                 return 0;
    1873                 :            :         }
    1874                 :            : 
    1875                 :            :         /* TODO: consider to only swap the RA after the last pre_handler fired */
    1876                 :          0 :         hash = hash_ptr(current, KPROBE_HASH_BITS);
    1877                 :          0 :         raw_spin_lock_irqsave(&rp->lock, flags);
    1878         [ #  # ]:          0 :         if (!hlist_empty(&rp->free_instances)) {
    1879                 :          0 :                 ri = hlist_entry(rp->free_instances.first,
    1880                 :            :                                 struct kretprobe_instance, hlist);
    1881         [ #  # ]:          0 :                 hlist_del(&ri->hlist);
    1882                 :          0 :                 raw_spin_unlock_irqrestore(&rp->lock, flags);
    1883                 :            : 
    1884                 :          0 :                 ri->rp = rp;
    1885         [ #  # ]:          0 :                 ri->task = current;
    1886                 :            : 
    1887   [ #  #  #  # ]:          0 :                 if (rp->entry_handler && rp->entry_handler(ri, regs)) {
    1888                 :          0 :                         raw_spin_lock_irqsave(&rp->lock, flags);
    1889         [ #  # ]:          0 :                         hlist_add_head(&ri->hlist, &rp->free_instances);
    1890                 :          0 :                         raw_spin_unlock_irqrestore(&rp->lock, flags);
    1891                 :          0 :                         return 0;
    1892                 :            :                 }
    1893                 :            : 
    1894                 :          0 :                 arch_prepare_kretprobe(ri, regs);
    1895                 :            : 
    1896                 :            :                 /* XXX(hch): why is there no hlist_move_head? */
    1897                 :          0 :                 INIT_HLIST_NODE(&ri->hlist);
    1898                 :          0 :                 kretprobe_table_lock(hash, &flags);
    1899         [ #  # ]:          0 :                 hlist_add_head(&ri->hlist, &kretprobe_inst_table[hash]);
    1900                 :          0 :                 kretprobe_table_unlock(hash, &flags);
    1901                 :            :         } else {
    1902                 :          0 :                 rp->nmissed++;
    1903                 :          0 :                 raw_spin_unlock_irqrestore(&rp->lock, flags);
    1904                 :            :         }
    1905                 :            :         return 0;
    1906                 :            : }
    1907                 :            : NOKPROBE_SYMBOL(pre_handler_kretprobe);
    1908                 :            : 
    1909                 :          0 : bool __weak arch_kprobe_on_func_entry(unsigned long offset)
    1910                 :            : {
    1911                 :          0 :         return !offset;
    1912                 :            : }
    1913                 :            : 
    1914                 :          0 : bool kprobe_on_func_entry(kprobe_opcode_t *addr, const char *sym, unsigned long offset)
    1915                 :            : {
    1916                 :          0 :         kprobe_opcode_t *kp_addr = _kprobe_addr(addr, sym, offset);
    1917                 :            : 
    1918         [ #  # ]:          0 :         if (IS_ERR(kp_addr))
    1919                 :            :                 return false;
    1920                 :            : 
    1921   [ #  #  #  # ]:          0 :         if (!kallsyms_lookup_size_offset((unsigned long)kp_addr, NULL, &offset) ||
    1922                 :          0 :                                                 !arch_kprobe_on_func_entry(offset))
    1923                 :          0 :                 return false;
    1924                 :            : 
    1925                 :            :         return true;
    1926                 :            : }
    1927                 :            : 
    1928                 :          0 : int register_kretprobe(struct kretprobe *rp)
    1929                 :            : {
    1930                 :          0 :         int ret = 0;
    1931                 :          0 :         struct kretprobe_instance *inst;
    1932                 :          0 :         int i;
    1933                 :          0 :         void *addr;
    1934                 :            : 
    1935         [ #  # ]:          0 :         if (!kprobe_on_func_entry(rp->kp.addr, rp->kp.symbol_name, rp->kp.offset))
    1936                 :            :                 return -EINVAL;
    1937                 :            : 
    1938         [ #  # ]:          0 :         if (kretprobe_blacklist_size) {
    1939                 :          0 :                 addr = kprobe_addr(&rp->kp);
    1940         [ #  # ]:          0 :                 if (IS_ERR(addr))
    1941                 :          0 :                         return PTR_ERR(addr);
    1942                 :            : 
    1943         [ #  # ]:          0 :                 for (i = 0; kretprobe_blacklist[i].name != NULL; i++) {
    1944         [ #  # ]:          0 :                         if (kretprobe_blacklist[i].addr == addr)
    1945                 :            :                                 return -EINVAL;
    1946                 :            :                 }
    1947                 :            :         }
    1948                 :            : 
    1949                 :          0 :         rp->kp.pre_handler = pre_handler_kretprobe;
    1950                 :          0 :         rp->kp.post_handler = NULL;
    1951                 :          0 :         rp->kp.fault_handler = NULL;
    1952                 :            : 
    1953                 :            :         /* Pre-allocate memory for max kretprobe instances */
    1954         [ #  # ]:          0 :         if (rp->maxactive <= 0) {
    1955                 :            : #ifdef CONFIG_PREEMPTION
    1956                 :            :                 rp->maxactive = max_t(unsigned int, 10, 2*num_possible_cpus());
    1957                 :            : #else
    1958                 :          0 :                 rp->maxactive = num_possible_cpus();
    1959                 :            : #endif
    1960                 :            :         }
    1961                 :          0 :         raw_spin_lock_init(&rp->lock);
    1962                 :          0 :         INIT_HLIST_HEAD(&rp->free_instances);
    1963         [ #  # ]:          0 :         for (i = 0; i < rp->maxactive; i++) {
    1964                 :          0 :                 inst = kmalloc(sizeof(struct kretprobe_instance) +
    1965         [ #  # ]:          0 :                                rp->data_size, GFP_KERNEL);
    1966         [ #  # ]:          0 :                 if (inst == NULL) {
    1967                 :          0 :                         free_rp_inst(rp);
    1968                 :          0 :                         return -ENOMEM;
    1969                 :            :                 }
    1970         [ #  # ]:          0 :                 INIT_HLIST_NODE(&inst->hlist);
    1971         [ #  # ]:          0 :                 hlist_add_head(&inst->hlist, &rp->free_instances);
    1972                 :            :         }
    1973                 :            : 
    1974                 :          0 :         rp->nmissed = 0;
    1975                 :            :         /* Establish function entry probe point */
    1976                 :          0 :         ret = register_kprobe(&rp->kp);
    1977         [ #  # ]:          0 :         if (ret != 0)
    1978                 :          0 :                 free_rp_inst(rp);
    1979                 :            :         return ret;
    1980                 :            : }
    1981                 :            : EXPORT_SYMBOL_GPL(register_kretprobe);
    1982                 :            : 
    1983                 :          0 : int register_kretprobes(struct kretprobe **rps, int num)
    1984                 :            : {
    1985                 :          0 :         int ret = 0, i;
    1986                 :            : 
    1987         [ #  # ]:          0 :         if (num <= 0)
    1988                 :            :                 return -EINVAL;
    1989         [ #  # ]:          0 :         for (i = 0; i < num; i++) {
    1990                 :          0 :                 ret = register_kretprobe(rps[i]);
    1991         [ #  # ]:          0 :                 if (ret < 0) {
    1992         [ #  # ]:          0 :                         if (i > 0)
    1993                 :          0 :                                 unregister_kretprobes(rps, i);
    1994                 :            :                         break;
    1995                 :            :                 }
    1996                 :            :         }
    1997                 :            :         return ret;
    1998                 :            : }
    1999                 :            : EXPORT_SYMBOL_GPL(register_kretprobes);
    2000                 :            : 
    2001                 :          0 : void unregister_kretprobe(struct kretprobe *rp)
    2002                 :            : {
    2003                 :          0 :         unregister_kretprobes(&rp, 1);
    2004                 :          0 : }
    2005                 :            : EXPORT_SYMBOL_GPL(unregister_kretprobe);
    2006                 :            : 
    2007                 :          0 : void unregister_kretprobes(struct kretprobe **rps, int num)
    2008                 :            : {
    2009                 :          0 :         int i;
    2010                 :            : 
    2011         [ #  # ]:          0 :         if (num <= 0)
    2012                 :            :                 return;
    2013                 :          0 :         mutex_lock(&kprobe_mutex);
    2014         [ #  # ]:          0 :         for (i = 0; i < num; i++)
    2015         [ #  # ]:          0 :                 if (__unregister_kprobe_top(&rps[i]->kp) < 0)
    2016                 :          0 :                         rps[i]->kp.addr = NULL;
    2017                 :          0 :         mutex_unlock(&kprobe_mutex);
    2018                 :            : 
    2019                 :          0 :         synchronize_rcu();
    2020         [ #  # ]:          0 :         for (i = 0; i < num; i++) {
    2021         [ #  # ]:          0 :                 if (rps[i]->kp.addr) {
    2022                 :          0 :                         __unregister_kprobe_bottom(&rps[i]->kp);
    2023                 :          0 :                         cleanup_rp_inst(rps[i]);
    2024                 :            :                 }
    2025                 :            :         }
    2026                 :            : }
    2027                 :            : EXPORT_SYMBOL_GPL(unregister_kretprobes);
    2028                 :            : 
    2029                 :            : #else /* CONFIG_KRETPROBES */
    2030                 :            : int register_kretprobe(struct kretprobe *rp)
    2031                 :            : {
    2032                 :            :         return -ENOSYS;
    2033                 :            : }
    2034                 :            : EXPORT_SYMBOL_GPL(register_kretprobe);
    2035                 :            : 
    2036                 :            : int register_kretprobes(struct kretprobe **rps, int num)
    2037                 :            : {
    2038                 :            :         return -ENOSYS;
    2039                 :            : }
    2040                 :            : EXPORT_SYMBOL_GPL(register_kretprobes);
    2041                 :            : 
    2042                 :            : void unregister_kretprobe(struct kretprobe *rp)
    2043                 :            : {
    2044                 :            : }
    2045                 :            : EXPORT_SYMBOL_GPL(unregister_kretprobe);
    2046                 :            : 
    2047                 :            : void unregister_kretprobes(struct kretprobe **rps, int num)
    2048                 :            : {
    2049                 :            : }
    2050                 :            : EXPORT_SYMBOL_GPL(unregister_kretprobes);
    2051                 :            : 
    2052                 :            : static int pre_handler_kretprobe(struct kprobe *p, struct pt_regs *regs)
    2053                 :            : {
    2054                 :            :         return 0;
    2055                 :            : }
    2056                 :            : NOKPROBE_SYMBOL(pre_handler_kretprobe);
    2057                 :            : 
    2058                 :            : #endif /* CONFIG_KRETPROBES */
    2059                 :            : 
    2060                 :            : /* Set the kprobe gone and remove its instruction buffer. */
    2061                 :          0 : static void kill_kprobe(struct kprobe *p)
    2062                 :            : {
    2063                 :          0 :         struct kprobe *kp;
    2064                 :            : 
    2065                 :          0 :         p->flags |= KPROBE_FLAG_GONE;
    2066         [ #  # ]:          0 :         if (kprobe_aggrprobe(p)) {
    2067                 :            :                 /*
    2068                 :            :                  * If this is an aggr_kprobe, we have to list all the
    2069                 :            :                  * chained probes and mark them GONE.
    2070                 :            :                  */
    2071         [ #  # ]:          0 :                 list_for_each_entry_rcu(kp, &p->list, list)
    2072                 :          0 :                         kp->flags |= KPROBE_FLAG_GONE;
    2073                 :          0 :                 p->post_handler = NULL;
    2074                 :          0 :                 kill_optimized_kprobe(p);
    2075                 :            :         }
    2076                 :            :         /*
    2077                 :            :          * Here, we can remove insn_slot safely, because no thread calls
    2078                 :            :          * the original probed function (which will be freed soon) any more.
    2079                 :            :          */
    2080                 :          0 :         arch_remove_kprobe(p);
    2081                 :          0 : }
    2082                 :            : 
    2083                 :            : /* Disable one kprobe */
    2084                 :          0 : int disable_kprobe(struct kprobe *kp)
    2085                 :            : {
    2086                 :          0 :         int ret = 0;
    2087                 :          0 :         struct kprobe *p;
    2088                 :            : 
    2089                 :          0 :         mutex_lock(&kprobe_mutex);
    2090                 :            : 
    2091                 :            :         /* Disable this kprobe */
    2092                 :          0 :         p = __disable_kprobe(kp);
    2093         [ #  # ]:          0 :         if (IS_ERR(p))
    2094                 :          0 :                 ret = PTR_ERR(p);
    2095                 :            : 
    2096                 :          0 :         mutex_unlock(&kprobe_mutex);
    2097                 :          0 :         return ret;
    2098                 :            : }
    2099                 :            : EXPORT_SYMBOL_GPL(disable_kprobe);
    2100                 :            : 
    2101                 :            : /* Enable one kprobe */
    2102                 :          0 : int enable_kprobe(struct kprobe *kp)
    2103                 :            : {
    2104                 :          0 :         int ret = 0;
    2105                 :          0 :         struct kprobe *p;
    2106                 :            : 
    2107                 :          0 :         mutex_lock(&kprobe_mutex);
    2108                 :            : 
    2109                 :            :         /* Check whether specified probe is valid. */
    2110                 :          0 :         p = __get_valid_kprobe(kp);
    2111         [ #  # ]:          0 :         if (unlikely(p == NULL)) {
    2112                 :          0 :                 ret = -EINVAL;
    2113                 :          0 :                 goto out;
    2114                 :            :         }
    2115                 :            : 
    2116         [ #  # ]:          0 :         if (kprobe_gone(kp)) {
    2117                 :            :                 /* This kprobe has gone, we couldn't enable it. */
    2118                 :          0 :                 ret = -EINVAL;
    2119                 :          0 :                 goto out;
    2120                 :            :         }
    2121                 :            : 
    2122         [ #  # ]:          0 :         if (p != kp)
    2123                 :          0 :                 kp->flags &= ~KPROBE_FLAG_DISABLED;
    2124                 :            : 
    2125   [ #  #  #  # ]:          0 :         if (!kprobes_all_disarmed && kprobe_disabled(p)) {
    2126                 :          0 :                 p->flags &= ~KPROBE_FLAG_DISABLED;
    2127                 :          0 :                 ret = arm_kprobe(p);
    2128         [ #  # ]:          0 :                 if (ret)
    2129                 :          0 :                         p->flags |= KPROBE_FLAG_DISABLED;
    2130                 :            :         }
    2131                 :          0 : out:
    2132                 :          0 :         mutex_unlock(&kprobe_mutex);
    2133                 :          0 :         return ret;
    2134                 :            : }
    2135                 :            : EXPORT_SYMBOL_GPL(enable_kprobe);
    2136                 :            : 
    2137                 :            : /* Caller must NOT call this in usual path. This is only for critical case */
    2138                 :          0 : void dump_kprobe(struct kprobe *kp)
    2139                 :            : {
    2140                 :          0 :         pr_err("Dumping kprobe:\n");
    2141                 :          0 :         pr_err("Name: %s\nOffset: %x\nAddress: %pS\n",
    2142                 :            :                kp->symbol_name, kp->offset, kp->addr);
    2143                 :          0 : }
    2144                 :            : NOKPROBE_SYMBOL(dump_kprobe);
    2145                 :            : 
    2146                 :      17472 : int kprobe_add_ksym_blacklist(unsigned long entry)
    2147                 :            : {
    2148                 :      17472 :         struct kprobe_blacklist_entry *ent;
    2149                 :      17472 :         unsigned long offset = 0, size = 0;
    2150                 :            : 
    2151   [ +  -  -  + ]:      34944 :         if (!kernel_text_address(entry) ||
    2152                 :      17472 :             !kallsyms_lookup_size_offset(entry, &size, &offset))
    2153                 :          0 :                 return -EINVAL;
    2154                 :            : 
    2155                 :      17472 :         ent = kmalloc(sizeof(*ent), GFP_KERNEL);
    2156         [ +  - ]:      17472 :         if (!ent)
    2157                 :            :                 return -ENOMEM;
    2158                 :      17472 :         ent->start_addr = entry;
    2159                 :      17472 :         ent->end_addr = entry + size;
    2160                 :      17472 :         INIT_LIST_HEAD(&ent->list);
    2161                 :      17472 :         list_add_tail(&ent->list, &kprobe_blacklist);
    2162                 :            : 
    2163                 :      17472 :         return (int)size;
    2164                 :            : }
    2165                 :            : 
    2166                 :            : /* Add all symbols in given area into kprobe blacklist */
    2167                 :        234 : int kprobe_add_area_blacklist(unsigned long start, unsigned long end)
    2168                 :            : {
    2169                 :        234 :         unsigned long entry;
    2170                 :        234 :         int ret = 0;
    2171                 :            : 
    2172   [ -  +  +  + ]:       7176 :         for (entry = start; entry < end; entry += ret) {
    2173                 :       6942 :                 ret = kprobe_add_ksym_blacklist(entry);
    2174   [ -  -  -  + ]:       6942 :                 if (ret < 0)
    2175                 :          0 :                         return ret;
    2176   [ -  -  -  + ]:       6942 :                 if (ret == 0)   /* In case of alias symbol */
    2177                 :          0 :                         ret = 1;
    2178                 :            :         }
    2179                 :            :         return 0;
    2180                 :            : }
    2181                 :            : 
    2182                 :          0 : int __init __weak arch_populate_kprobe_blacklist(void)
    2183                 :            : {
    2184                 :          0 :         return 0;
    2185                 :            : }
    2186                 :            : 
    2187                 :            : /*
    2188                 :            :  * Lookup and populate the kprobe_blacklist.
    2189                 :            :  *
    2190                 :            :  * Unlike the kretprobe blacklist, we'll need to determine
    2191                 :            :  * the range of addresses that belong to the said functions,
    2192                 :            :  * since a kprobe need not necessarily be at the beginning
    2193                 :            :  * of a function.
    2194                 :            :  */
    2195                 :         78 : static int __init populate_kprobe_blacklist(unsigned long *start,
    2196                 :            :                                              unsigned long *end)
    2197                 :            : {
    2198                 :         78 :         unsigned long entry;
    2199                 :         78 :         unsigned long *iter;
    2200                 :         78 :         int ret;
    2201                 :            : 
    2202         [ +  + ]:      10608 :         for (iter = start; iter < end; iter++) {
    2203                 :      10530 :                 entry = arch_deref_entry_point((void *)*iter);
    2204                 :      10530 :                 ret = kprobe_add_ksym_blacklist(entry);
    2205         [ -  + ]:      10530 :                 if (ret == -EINVAL)
    2206                 :          0 :                         continue;
    2207         [ -  + ]:      10530 :                 if (ret < 0)
    2208                 :          0 :                         return ret;
    2209                 :            :         }
    2210                 :            : 
    2211                 :            :         /* Symbols in __kprobes_text are blacklisted */
    2212                 :         78 :         ret = kprobe_add_area_blacklist((unsigned long)__kprobes_text_start,
    2213                 :            :                                         (unsigned long)__kprobes_text_end);
    2214                 :            : 
    2215         [ +  - ]:         78 :         return ret ? : arch_populate_kprobe_blacklist();
    2216                 :            : }
    2217                 :            : 
    2218                 :            : /* Module notifier call back, checking kprobes on the module */
    2219                 :        156 : static int kprobes_module_callback(struct notifier_block *nb,
    2220                 :            :                                    unsigned long val, void *data)
    2221                 :            : {
    2222                 :        156 :         struct module *mod = data;
    2223                 :        156 :         struct hlist_head *head;
    2224                 :        156 :         struct kprobe *p;
    2225                 :        156 :         unsigned int i;
    2226                 :        156 :         int checkcore = (val == MODULE_STATE_GOING);
    2227                 :            : 
    2228         [ +  + ]:        156 :         if (val != MODULE_STATE_GOING && val != MODULE_STATE_LIVE)
    2229                 :            :                 return NOTIFY_DONE;
    2230                 :            : 
    2231                 :            :         /*
    2232                 :            :          * When MODULE_STATE_GOING was notified, both of module .text and
    2233                 :            :          * .init.text sections would be freed. When MODULE_STATE_LIVE was
    2234                 :            :          * notified, only .init.text section would be freed. We need to
    2235                 :            :          * disable kprobes which have been inserted in the sections.
    2236                 :            :          */
    2237                 :         78 :         mutex_lock(&kprobe_mutex);
    2238         [ +  + ]:       5148 :         for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
    2239                 :       4992 :                 head = &kprobe_table[i];
    2240   [ +  -  -  -  :       9984 :                 hlist_for_each_entry_rcu(p, head, hlist)
                   -  + ]
    2241   [ #  #  #  #  :          0 :                         if (within_module_init((unsigned long)p->addr, mod) ||
                   #  # ]
    2242         [ #  # ]:          0 :                             (checkcore &&
    2243         [ #  # ]:          0 :                              within_module_core((unsigned long)p->addr, mod))) {
    2244                 :            :                                 /*
    2245                 :            :                                  * The vaddr this probe is installed will soon
    2246                 :            :                                  * be vfreed buy not synced to disk. Hence,
    2247                 :            :                                  * disarming the breakpoint isn't needed.
    2248                 :            :                                  *
    2249                 :            :                                  * Note, this will also move any optimized probes
    2250                 :            :                                  * that are pending to be removed from their
    2251                 :            :                                  * corresponding lists to the freeing_list and
    2252                 :            :                                  * will not be touched by the delayed
    2253                 :            :                                  * kprobe_optimizer work handler.
    2254                 :            :                                  */
    2255                 :          0 :                                 kill_kprobe(p);
    2256                 :            :                         }
    2257                 :            :         }
    2258                 :         78 :         mutex_unlock(&kprobe_mutex);
    2259                 :         78 :         return NOTIFY_DONE;
    2260                 :            : }
    2261                 :            : 
    2262                 :            : static struct notifier_block kprobe_module_nb = {
    2263                 :            :         .notifier_call = kprobes_module_callback,
    2264                 :            :         .priority = 0
    2265                 :            : };
    2266                 :            : 
    2267                 :            : /* Markers of _kprobe_blacklist section */
    2268                 :            : extern unsigned long __start_kprobe_blacklist[];
    2269                 :            : extern unsigned long __stop_kprobe_blacklist[];
    2270                 :            : 
    2271                 :         78 : static int __init init_kprobes(void)
    2272                 :            : {
    2273                 :         78 :         int i, err = 0;
    2274                 :            : 
    2275                 :            :         /* FIXME allocate the probe table, currently defined statically */
    2276                 :            :         /* initialize all list heads */
    2277         [ +  + ]:       5070 :         for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
    2278                 :       4992 :                 INIT_HLIST_HEAD(&kprobe_table[i]);
    2279                 :       4992 :                 INIT_HLIST_HEAD(&kretprobe_inst_table[i]);
    2280                 :       4992 :                 raw_spin_lock_init(&(kretprobe_table_locks[i].lock));
    2281                 :            :         }
    2282                 :            : 
    2283                 :         78 :         err = populate_kprobe_blacklist(__start_kprobe_blacklist,
    2284                 :            :                                         __stop_kprobe_blacklist);
    2285         [ -  + ]:         78 :         if (err) {
    2286                 :          0 :                 pr_err("kprobes: failed to populate blacklist: %d\n", err);
    2287                 :          0 :                 pr_err("Please take care of using kprobes.\n");
    2288                 :            :         }
    2289                 :            : 
    2290         [ +  - ]:         78 :         if (kretprobe_blacklist_size) {
    2291                 :            :                 /* lookup the function address from its name */
    2292         [ +  + ]:        156 :                 for (i = 0; kretprobe_blacklist[i].name != NULL; i++) {
    2293                 :        156 :                         kretprobe_blacklist[i].addr =
    2294                 :         78 :                                 kprobe_lookup_name(kretprobe_blacklist[i].name, 0);
    2295         [ -  + ]:         78 :                         if (!kretprobe_blacklist[i].addr)
    2296                 :          0 :                                 printk("kretprobe: lookup failed: %s\n",
    2297                 :            :                                        kretprobe_blacklist[i].name);
    2298                 :            :                 }
    2299                 :            :         }
    2300                 :            : 
    2301                 :            : #if defined(CONFIG_OPTPROBES)
    2302                 :            : #if defined(__ARCH_WANT_KPROBES_INSN_SLOT)
    2303                 :            :         /* Init kprobe_optinsn_slots */
    2304                 :         78 :         kprobe_optinsn_slots.insn_size = MAX_OPTINSN_SIZE;
    2305                 :            : #endif
    2306                 :            :         /* By default, kprobes can be optimized */
    2307                 :         78 :         kprobes_allow_optimization = true;
    2308                 :            : #endif
    2309                 :            : 
    2310                 :            :         /* By default, kprobes are armed */
    2311                 :         78 :         kprobes_all_disarmed = false;
    2312                 :            : 
    2313                 :         78 :         err = arch_init_kprobes();
    2314         [ +  - ]:         78 :         if (!err)
    2315                 :         78 :                 err = register_die_notifier(&kprobe_exceptions_nb);
    2316         [ +  - ]:         78 :         if (!err)
    2317                 :         78 :                 err = register_module_notifier(&kprobe_module_nb);
    2318                 :            : 
    2319                 :         78 :         kprobes_initialized = (err == 0);
    2320                 :            : 
    2321                 :         78 :         if (!err)
    2322                 :            :                 init_test_probes();
    2323                 :         78 :         return err;
    2324                 :            : }
    2325                 :            : subsys_initcall(init_kprobes);
    2326                 :            : 
    2327                 :            : #ifdef CONFIG_DEBUG_FS
    2328                 :          0 : static void report_probe(struct seq_file *pi, struct kprobe *p,
    2329                 :            :                 const char *sym, int offset, char *modname, struct kprobe *pp)
    2330                 :            : {
    2331                 :          0 :         char *kprobe_type;
    2332                 :          0 :         void *addr = p->addr;
    2333                 :            : 
    2334         [ #  # ]:          0 :         if (p->pre_handler == pre_handler_kretprobe)
    2335                 :            :                 kprobe_type = "r";
    2336                 :            :         else
    2337                 :          0 :                 kprobe_type = "k";
    2338                 :            : 
    2339         [ #  # ]:          0 :         if (!kallsyms_show_value())
    2340                 :          0 :                 addr = NULL;
    2341                 :            : 
    2342         [ #  # ]:          0 :         if (sym)
    2343         [ #  # ]:          0 :                 seq_printf(pi, "%px  %s  %s+0x%x  %s ",
    2344                 :            :                         addr, kprobe_type, sym, offset,
    2345                 :            :                         (modname ? modname : " "));
    2346                 :            :         else    /* try to use %pS */
    2347                 :          0 :                 seq_printf(pi, "%px  %s  %pS ",
    2348                 :            :                         addr, kprobe_type, p->addr);
    2349                 :            : 
    2350         [ #  # ]:          0 :         if (!pp)
    2351                 :          0 :                 pp = p;
    2352   [ #  #  #  #  :          0 :         seq_printf(pi, "%s%s%s%s\n",
                   #  # ]
    2353                 :            :                 (kprobe_gone(p) ? "[GONE]" : ""),
    2354   [ #  #  #  # ]:          0 :                 ((kprobe_disabled(p) && !kprobe_gone(p)) ?  "[DISABLED]" : ""),
    2355                 :            :                 (kprobe_optimized(pp) ? "[OPTIMIZED]" : ""),
    2356         [ #  # ]:          0 :                 (kprobe_ftrace(pp) ? "[FTRACE]" : ""));
    2357                 :          0 : }
    2358                 :            : 
    2359                 :          0 : static void *kprobe_seq_start(struct seq_file *f, loff_t *pos)
    2360                 :            : {
    2361         [ #  # ]:          0 :         return (*pos < KPROBE_TABLE_SIZE) ? pos : NULL;
    2362                 :            : }
    2363                 :            : 
    2364                 :          0 : static void *kprobe_seq_next(struct seq_file *f, void *v, loff_t *pos)
    2365                 :            : {
    2366                 :          0 :         (*pos)++;
    2367         [ #  # ]:          0 :         if (*pos >= KPROBE_TABLE_SIZE)
    2368                 :          0 :                 return NULL;
    2369                 :            :         return pos;
    2370                 :            : }
    2371                 :            : 
    2372                 :          0 : static void kprobe_seq_stop(struct seq_file *f, void *v)
    2373                 :            : {
    2374                 :            :         /* Nothing to do */
    2375                 :          0 : }
    2376                 :            : 
    2377                 :          0 : static int show_kprobe_addr(struct seq_file *pi, void *v)
    2378                 :            : {
    2379                 :          0 :         struct hlist_head *head;
    2380                 :          0 :         struct kprobe *p, *kp;
    2381                 :          0 :         const char *sym = NULL;
    2382                 :          0 :         unsigned int i = *(loff_t *) v;
    2383                 :          0 :         unsigned long offset = 0;
    2384                 :          0 :         char *modname, namebuf[KSYM_NAME_LEN];
    2385                 :            : 
    2386                 :          0 :         head = &kprobe_table[i];
    2387                 :          0 :         preempt_disable();
    2388   [ #  #  #  #  :          0 :         hlist_for_each_entry_rcu(p, head, hlist) {
                   #  # ]
    2389                 :          0 :                 sym = kallsyms_lookup((unsigned long)p->addr, NULL,
    2390                 :            :                                         &offset, &modname, namebuf);
    2391         [ #  # ]:          0 :                 if (kprobe_aggrprobe(p)) {
    2392         [ #  # ]:          0 :                         list_for_each_entry_rcu(kp, &p->list, list)
    2393                 :          0 :                                 report_probe(pi, kp, sym, offset, modname, p);
    2394                 :            :                 } else
    2395                 :          0 :                         report_probe(pi, p, sym, offset, modname, NULL);
    2396                 :            :         }
    2397                 :          0 :         preempt_enable();
    2398                 :          0 :         return 0;
    2399                 :            : }
    2400                 :            : 
    2401                 :            : static const struct seq_operations kprobes_seq_ops = {
    2402                 :            :         .start = kprobe_seq_start,
    2403                 :            :         .next  = kprobe_seq_next,
    2404                 :            :         .stop  = kprobe_seq_stop,
    2405                 :            :         .show  = show_kprobe_addr
    2406                 :            : };
    2407                 :            : 
    2408                 :          0 : static int kprobes_open(struct inode *inode, struct file *filp)
    2409                 :            : {
    2410                 :          0 :         return seq_open(filp, &kprobes_seq_ops);
    2411                 :            : }
    2412                 :            : 
    2413                 :            : static const struct file_operations debugfs_kprobes_operations = {
    2414                 :            :         .open           = kprobes_open,
    2415                 :            :         .read           = seq_read,
    2416                 :            :         .llseek         = seq_lseek,
    2417                 :            :         .release        = seq_release,
    2418                 :            : };
    2419                 :            : 
    2420                 :            : /* kprobes/blacklist -- shows which functions can not be probed */
    2421                 :          0 : static void *kprobe_blacklist_seq_start(struct seq_file *m, loff_t *pos)
    2422                 :            : {
    2423                 :          0 :         return seq_list_start(&kprobe_blacklist, *pos);
    2424                 :            : }
    2425                 :            : 
    2426                 :          0 : static void *kprobe_blacklist_seq_next(struct seq_file *m, void *v, loff_t *pos)
    2427                 :            : {
    2428                 :          0 :         return seq_list_next(v, &kprobe_blacklist, pos);
    2429                 :            : }
    2430                 :            : 
    2431                 :          0 : static int kprobe_blacklist_seq_show(struct seq_file *m, void *v)
    2432                 :            : {
    2433                 :          0 :         struct kprobe_blacklist_entry *ent =
    2434                 :          0 :                 list_entry(v, struct kprobe_blacklist_entry, list);
    2435                 :            : 
    2436                 :            :         /*
    2437                 :            :          * If /proc/kallsyms is not showing kernel address, we won't
    2438                 :            :          * show them here either.
    2439                 :            :          */
    2440         [ #  # ]:          0 :         if (!kallsyms_show_value())
    2441                 :          0 :                 seq_printf(m, "0x%px-0x%px\t%ps\n", NULL, NULL,
    2442                 :          0 :                            (void *)ent->start_addr);
    2443                 :            :         else
    2444                 :          0 :                 seq_printf(m, "0x%px-0x%px\t%ps\n", (void *)ent->start_addr,
    2445                 :          0 :                            (void *)ent->end_addr, (void *)ent->start_addr);
    2446                 :          0 :         return 0;
    2447                 :            : }
    2448                 :            : 
    2449                 :            : static const struct seq_operations kprobe_blacklist_seq_ops = {
    2450                 :            :         .start = kprobe_blacklist_seq_start,
    2451                 :            :         .next  = kprobe_blacklist_seq_next,
    2452                 :            :         .stop  = kprobe_seq_stop,       /* Reuse void function */
    2453                 :            :         .show  = kprobe_blacklist_seq_show,
    2454                 :            : };
    2455                 :            : 
    2456                 :          0 : static int kprobe_blacklist_open(struct inode *inode, struct file *filp)
    2457                 :            : {
    2458                 :          0 :         return seq_open(filp, &kprobe_blacklist_seq_ops);
    2459                 :            : }
    2460                 :            : 
    2461                 :            : static const struct file_operations debugfs_kprobe_blacklist_ops = {
    2462                 :            :         .open           = kprobe_blacklist_open,
    2463                 :            :         .read           = seq_read,
    2464                 :            :         .llseek         = seq_lseek,
    2465                 :            :         .release        = seq_release,
    2466                 :            : };
    2467                 :            : 
    2468                 :          0 : static int arm_all_kprobes(void)
    2469                 :            : {
    2470                 :          0 :         struct hlist_head *head;
    2471                 :          0 :         struct kprobe *p;
    2472                 :          0 :         unsigned int i, total = 0, errors = 0;
    2473                 :          0 :         int err, ret = 0;
    2474                 :            : 
    2475                 :          0 :         mutex_lock(&kprobe_mutex);
    2476                 :            : 
    2477                 :            :         /* If kprobes are armed, just return */
    2478         [ #  # ]:          0 :         if (!kprobes_all_disarmed)
    2479                 :          0 :                 goto already_enabled;
    2480                 :            : 
    2481                 :            :         /*
    2482                 :            :          * optimize_kprobe() called by arm_kprobe() checks
    2483                 :            :          * kprobes_all_disarmed, so set kprobes_all_disarmed before
    2484                 :            :          * arm_kprobe.
    2485                 :            :          */
    2486                 :          0 :         kprobes_all_disarmed = false;
    2487                 :            :         /* Arming kprobes doesn't optimize kprobe itself */
    2488         [ #  # ]:          0 :         for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
    2489                 :          0 :                 head = &kprobe_table[i];
    2490                 :            :                 /* Arm all kprobes on a best-effort basis */
    2491   [ #  #  #  #  :          0 :                 hlist_for_each_entry_rcu(p, head, hlist) {
                   #  # ]
    2492         [ #  # ]:          0 :                         if (!kprobe_disabled(p)) {
    2493                 :          0 :                                 err = arm_kprobe(p);
    2494         [ #  # ]:          0 :                                 if (err)  {
    2495                 :          0 :                                         errors++;
    2496                 :          0 :                                         ret = err;
    2497                 :            :                                 }
    2498                 :          0 :                                 total++;
    2499                 :            :                         }
    2500                 :            :                 }
    2501                 :            :         }
    2502                 :            : 
    2503         [ #  # ]:          0 :         if (errors)
    2504                 :          0 :                 pr_warn("Kprobes globally enabled, but failed to arm %d out of %d probes\n",
    2505                 :            :                         errors, total);
    2506                 :            :         else
    2507                 :          0 :                 pr_info("Kprobes globally enabled\n");
    2508                 :            : 
    2509                 :          0 : already_enabled:
    2510                 :          0 :         mutex_unlock(&kprobe_mutex);
    2511                 :          0 :         return ret;
    2512                 :            : }
    2513                 :            : 
    2514                 :          0 : static int disarm_all_kprobes(void)
    2515                 :            : {
    2516                 :          0 :         struct hlist_head *head;
    2517                 :          0 :         struct kprobe *p;
    2518                 :          0 :         unsigned int i, total = 0, errors = 0;
    2519                 :          0 :         int err, ret = 0;
    2520                 :            : 
    2521                 :          0 :         mutex_lock(&kprobe_mutex);
    2522                 :            : 
    2523                 :            :         /* If kprobes are already disarmed, just return */
    2524         [ #  # ]:          0 :         if (kprobes_all_disarmed) {
    2525                 :          0 :                 mutex_unlock(&kprobe_mutex);
    2526                 :          0 :                 return 0;
    2527                 :            :         }
    2528                 :            : 
    2529                 :          0 :         kprobes_all_disarmed = true;
    2530                 :            : 
    2531         [ #  # ]:          0 :         for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
    2532                 :          0 :                 head = &kprobe_table[i];
    2533                 :            :                 /* Disarm all kprobes on a best-effort basis */
    2534   [ #  #  #  #  :          0 :                 hlist_for_each_entry_rcu(p, head, hlist) {
                   #  # ]
    2535   [ #  #  #  # ]:          0 :                         if (!arch_trampoline_kprobe(p) && !kprobe_disabled(p)) {
    2536                 :          0 :                                 err = disarm_kprobe(p, false);
    2537         [ #  # ]:          0 :                                 if (err) {
    2538                 :          0 :                                         errors++;
    2539                 :          0 :                                         ret = err;
    2540                 :            :                                 }
    2541                 :          0 :                                 total++;
    2542                 :            :                         }
    2543                 :            :                 }
    2544                 :            :         }
    2545                 :            : 
    2546         [ #  # ]:          0 :         if (errors)
    2547                 :          0 :                 pr_warn("Kprobes globally disabled, but failed to disarm %d out of %d probes\n",
    2548                 :            :                         errors, total);
    2549                 :            :         else
    2550                 :          0 :                 pr_info("Kprobes globally disabled\n");
    2551                 :            : 
    2552                 :          0 :         mutex_unlock(&kprobe_mutex);
    2553                 :            : 
    2554                 :            :         /* Wait for disarming all kprobes by optimizer */
    2555                 :          0 :         wait_for_kprobe_optimizer();
    2556                 :            : 
    2557                 :          0 :         return ret;
    2558                 :            : }
    2559                 :            : 
    2560                 :            : /*
    2561                 :            :  * XXX: The debugfs bool file interface doesn't allow for callbacks
    2562                 :            :  * when the bool state is switched. We can reuse that facility when
    2563                 :            :  * available
    2564                 :            :  */
    2565                 :          0 : static ssize_t read_enabled_file_bool(struct file *file,
    2566                 :            :                char __user *user_buf, size_t count, loff_t *ppos)
    2567                 :            : {
    2568                 :          0 :         char buf[3];
    2569                 :            : 
    2570         [ #  # ]:          0 :         if (!kprobes_all_disarmed)
    2571                 :          0 :                 buf[0] = '1';
    2572                 :            :         else
    2573                 :          0 :                 buf[0] = '0';
    2574                 :          0 :         buf[1] = '\n';
    2575                 :          0 :         buf[2] = 0x00;
    2576                 :          0 :         return simple_read_from_buffer(user_buf, count, ppos, buf, 2);
    2577                 :            : }
    2578                 :            : 
    2579                 :          0 : static ssize_t write_enabled_file_bool(struct file *file,
    2580                 :            :                const char __user *user_buf, size_t count, loff_t *ppos)
    2581                 :            : {
    2582                 :          0 :         char buf[32];
    2583                 :          0 :         size_t buf_size;
    2584                 :          0 :         int ret = 0;
    2585                 :            : 
    2586                 :          0 :         buf_size = min(count, (sizeof(buf)-1));
    2587         [ #  # ]:          0 :         if (copy_from_user(buf, user_buf, buf_size))
    2588                 :            :                 return -EFAULT;
    2589                 :            : 
    2590                 :          0 :         buf[buf_size] = '\0';
    2591      [ #  #  # ]:          0 :         switch (buf[0]) {
    2592                 :          0 :         case 'y':
    2593                 :            :         case 'Y':
    2594                 :            :         case '1':
    2595                 :          0 :                 ret = arm_all_kprobes();
    2596                 :          0 :                 break;
    2597                 :          0 :         case 'n':
    2598                 :            :         case 'N':
    2599                 :            :         case '0':
    2600                 :          0 :                 ret = disarm_all_kprobes();
    2601                 :          0 :                 break;
    2602                 :            :         default:
    2603                 :            :                 return -EINVAL;
    2604                 :            :         }
    2605                 :            : 
    2606         [ #  # ]:          0 :         if (ret)
    2607                 :          0 :                 return ret;
    2608                 :            : 
    2609                 :          0 :         return count;
    2610                 :            : }
    2611                 :            : 
    2612                 :            : static const struct file_operations fops_kp = {
    2613                 :            :         .read =         read_enabled_file_bool,
    2614                 :            :         .write =        write_enabled_file_bool,
    2615                 :            :         .llseek =       default_llseek,
    2616                 :            : };
    2617                 :            : 
    2618                 :         78 : static int __init debugfs_kprobe_init(void)
    2619                 :            : {
    2620                 :         78 :         struct dentry *dir;
    2621                 :         78 :         unsigned int value = 1;
    2622                 :            : 
    2623                 :         78 :         dir = debugfs_create_dir("kprobes", NULL);
    2624                 :            : 
    2625                 :         78 :         debugfs_create_file("list", 0400, dir, NULL,
    2626                 :            :                             &debugfs_kprobes_operations);
    2627                 :            : 
    2628                 :         78 :         debugfs_create_file("enabled", 0600, dir, &value, &fops_kp);
    2629                 :            : 
    2630                 :         78 :         debugfs_create_file("blacklist", 0400, dir, NULL,
    2631                 :            :                             &debugfs_kprobe_blacklist_ops);
    2632                 :            : 
    2633                 :         78 :         return 0;
    2634                 :            : }
    2635                 :            : 
    2636                 :            : late_initcall(debugfs_kprobe_init);
    2637                 :            : #endif /* CONFIG_DEBUG_FS */

Generated by: LCOV version 1.14