Line data    Source code

       1             : /* SPDX-License-Identifier: GPL-2.0 */
       2             : #ifndef _LINUX_PROFILE_H
       3             : #define _LINUX_PROFILE_H
       4             : 
       5             : #include <linux/kernel.h>
       6             : #include <linux/init.h>
       7             : #include <linux/cpumask.h>
       8             : #include <linux/cache.h>
       9             : 
      10             : #include <asm/errno.h>
      11             : 
      12             : #define CPU_PROFILING   1
      13             : #define SCHED_PROFILING 2
      14             : #define SLEEP_PROFILING 3
      15             : #define KVM_PROFILING   4
      16             : 
      17             : struct proc_dir_entry;
      18             : struct pt_regs;
      19             : struct notifier_block;
      20             : 
      21             : #if defined(CONFIG_PROFILING) && defined(CONFIG_PROC_FS)
      22             : void create_prof_cpu_mask(void);
      23             : int create_proc_profile(void);
      24             : #else
      25             : static inline void create_prof_cpu_mask(void)
      26             : {
      27             : }
      28             : 
      29             : static inline int create_proc_profile(void)
      30             : {
      31             :         return 0;
      32             : }
      33             : #endif
      34             : 
      35             : enum profile_type {
      36             :         PROFILE_TASK_EXIT,
      37             :         PROFILE_MUNMAP
      38             : };
      39             : 
      40             : #ifdef CONFIG_PROFILING
      41             : 
      42             : extern int prof_on __read_mostly;
      43             : 
      44             : /* init basic kernel profiler */
      45             : int profile_init(void);
      46             : int profile_setup(char *str);
      47             : void profile_tick(int type);
      48             : int setup_profiling_timer(unsigned int multiplier);
      49             : 
      50             : /*
      51             :  * Add multiple profiler hits to a given address:
      52             :  */
      53             : void profile_hits(int type, void *ip, unsigned int nr_hits);
      54             : 
      55             : /*
      56             :  * Single profiler hit:
      57             :  */
      58             : static inline void profile_hit(int type, void *ip)
      59             : {
      60             :         /*
      61             :          * Speedup for the common (no profiling enabled) case:
      62             :          */
      63             :         if (unlikely(prof_on == type))
      64             :                 profile_hits(type, ip, 1);
      65             : }
      66             : 
      67             : struct task_struct;
      68             : struct mm_struct;
      69             : 
      70             : /* task is in do_exit() */
      71             : void profile_task_exit(struct task_struct * task);
      72             : 
      73             : /* task is dead, free task struct ? Returns 1 if
      74             :  * the task was taken, 0 if the task should be freed.
      75             :  */
      76             : int profile_handoff_task(struct task_struct * task);
      77             : 
      78             : /* sys_munmap */
      79             : void profile_munmap(unsigned long addr);
      80             : 
      81             : int task_handoff_register(struct notifier_block * n);
      82             : int task_handoff_unregister(struct notifier_block * n);
      83             : 
      84             : int profile_event_register(enum profile_type, struct notifier_block * n);
      85             : int profile_event_unregister(enum profile_type, struct notifier_block * n);
      86             : 
      87             : struct pt_regs;
      88             : 
      89             : #else
      90             : 
      91             : #define prof_on 0
      92             : 
      93             : static inline int profile_init(void)
      94             : {
      95             :         return 0;
      96             : }
      97             : 
      98       29713 : static inline void profile_tick(int type)
      99             : {
     100       29713 :         return;
     101             : }
     102             : 
     103             : static inline void profile_hits(int type, void *ip, unsigned int nr_hits)
     104             : {
     105             :         return;
     106             : }
     107             : 
     108       27967 : static inline void profile_hit(int type, void *ip)
     109             : {
     110       27967 :         return;
     111             : }
     112             : 
     113             : static inline int task_handoff_register(struct notifier_block * n)
     114             : {
     115             :         return -ENOSYS;
     116             : }
     117             : 
     118             : static inline int task_handoff_unregister(struct notifier_block * n)
     119             : {
     120             :         return -ENOSYS;
     121             : }
     122             : 
     123             : static inline int profile_event_register(enum profile_type t, struct notifier_block * n)
     124             : {
     125             :         return -ENOSYS;
     126             : }
     127             : 
     128             : static inline int profile_event_unregister(enum profile_type t, struct notifier_block * n)
     129             : {
     130             :         return -ENOSYS;
     131             : }
     132             : 
     133             : #define profile_task_exit(a) do { } while (0)
     134             : #define profile_handoff_task(a) (0)
     135             : #define profile_munmap(a) do { } while (0)
     136             : 
     137             : #endif /* CONFIG_PROFILING */
     138             : 
     139             : #endif /* _LINUX_PROFILE_H */