include/linux/delayacct.h

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /* delayacct.h - per-task delay accounting
   3  *
   4  * Copyright (C) Shailabh Nagar, IBM Corp. 2006
   5  */
   6
   7 #ifndef _LINUX_DELAYACCT_H
   8 #define _LINUX_DELAYACCT_H
   9
  10 #include <uapi/linux/taskstats.h>
  11
  12 #ifdef CONFIG_TASK_DELAY_ACCT
  13 struct task_delay_info {
  14         raw_spinlock_t  lock;
  15
  16         /* For each stat XXX, add following, aligned appropriately
  17          *
  18          * struct timespec XXX_start, XXX_end;
  19          * u64 XXX_delay;
  20          * u32 XXX_count;
  21          *
  22          * Atomicity of updates to XXX_delay, XXX_count protected by
  23          * single lock above (split into XXX_lock if contention is an issue).
  24          */
  25
  26         /*
  27          * XXX_count is incremented on every XXX operation, the delay
  28          * associated with the operation is added to XXX_delay.
  29          * XXX_delay contains the accumulated delay time in nanoseconds.
  30          */
  31         u64 blkio_start;
  32         u64 blkio_delay;        /* wait for sync block io completion */
  33         u64 swapin_start;
  34         u64 swapin_delay;       /* wait for swapin */
  35         u32 blkio_count;        /* total count of the number of sync block */
  36                                 /* io operations performed */
  37         u32 swapin_count;       /* total count of swapin */
  38
  39         u64 freepages_start;
  40         u64 freepages_delay;    /* wait for memory reclaim */
  41
  42         u64 thrashing_start;
  43         u64 thrashing_delay;    /* wait for thrashing page */
  44
  45         u64 compact_start;
  46         u64 compact_delay;      /* wait for memory compact */
  47
  48         u32 freepages_count;    /* total count of memory reclaim */
  49         u32 thrashing_count;    /* total count of thrash waits */
  50         u32 compact_count;      /* total count of memory compact */
  51 };
  52 #endif
  53
  54 #include <linux/sched.h>
  55 #include <linux/slab.h>
  56 #include <linux/jump_label.h>
  57
  58 #ifdef CONFIG_TASK_DELAY_ACCT
  59 DECLARE_STATIC_KEY_FALSE(delayacct_key);
  60 extern int delayacct_on;        /* Delay accounting turned on/off */
  61 extern struct kmem_cache *delayacct_cache;
  62 extern void delayacct_init(void);
  63
  64 extern int sysctl_delayacct(struct ctl_table *table, int write, void *buffer,
  65                             size_t *lenp, loff_t *ppos);
  66
  67 extern void __delayacct_tsk_init(struct task_struct *);
  68 extern void __delayacct_tsk_exit(struct task_struct *);
  69 extern void __delayacct_blkio_start(void);
  70 extern void __delayacct_blkio_end(struct task_struct *);
  71 extern int delayacct_add_tsk(struct taskstats *, struct task_struct *);
  72 extern __u64 __delayacct_blkio_ticks(struct task_struct *);
  73 extern void __delayacct_freepages_start(void);
  74 extern void __delayacct_freepages_end(void);
  75 extern void __delayacct_thrashing_start(void);
  76 extern void __delayacct_thrashing_end(void);
  77 extern void __delayacct_swapin_start(void);
  78 extern void __delayacct_swapin_end(void);
  79 extern void __delayacct_compact_start(void);
  80 extern void __delayacct_compact_end(void);
  81
  82 static inline void delayacct_tsk_init(struct task_struct *tsk)
  83 {
  84         /* reinitialize in case parent's non-null pointer was dup'ed*/
  85         tsk->delays = NULL;
  86         if (delayacct_on)
  87                 __delayacct_tsk_init(tsk);
  88 }
  89
  90 /* Free tsk->delays. Called from bad fork and __put_task_struct
  91  * where there's no risk of tsk->delays being accessed elsewhere
  92  */
  93 static inline void delayacct_tsk_free(struct task_struct *tsk)
  94 {
  95         if (tsk->delays)
  96                 kmem_cache_free(delayacct_cache, tsk->delays);
  97         tsk->delays = NULL;
  98 }
  99
 100 static inline void delayacct_blkio_start(void)
 101 {
 102         if (!static_branch_unlikely(&delayacct_key))
 103                 return;
 104
 105         if (current->delays)
 106                 __delayacct_blkio_start();
 107 }
 108
 109 static inline void delayacct_blkio_end(struct task_struct *p)
 110 {
 111         if (!static_branch_unlikely(&delayacct_key))
 112                 return;
 113
 114         if (p->delays)
 115                 __delayacct_blkio_end(p);
 116 }
 117
 118 static inline __u64 delayacct_blkio_ticks(struct task_struct *tsk)
 119 {
 120         if (tsk->delays)
 121                 return __delayacct_blkio_ticks(tsk);
 122         return 0;
 123 }
 124
 125 static inline void delayacct_freepages_start(void)
 126 {
 127         if (!static_branch_unlikely(&delayacct_key))
 128                 return;
 129
 130         if (current->delays)
 131                 __delayacct_freepages_start();
 132 }
 133
 134 static inline void delayacct_freepages_end(void)
 135 {
 136         if (!static_branch_unlikely(&delayacct_key))
 137                 return;
 138
 139         if (current->delays)
 140                 __delayacct_freepages_end();
 141 }
 142
 143 static inline void delayacct_thrashing_start(void)
 144 {
 145         if (!static_branch_unlikely(&delayacct_key))
 146                 return;
 147
 148         if (current->delays)
 149                 __delayacct_thrashing_start();
 150 }
 151
 152 static inline void delayacct_thrashing_end(void)
 153 {
 154         if (!static_branch_unlikely(&delayacct_key))
 155                 return;
 156
 157         if (current->delays)
 158                 __delayacct_thrashing_end();
 159 }
 160
 161 static inline void delayacct_swapin_start(void)
 162 {
 163         if (!static_branch_unlikely(&delayacct_key))
 164                 return;
 165
 166         if (current->delays)
 167                 __delayacct_swapin_start();
 168 }
 169
 170 static inline void delayacct_swapin_end(void)
 171 {
 172         if (!static_branch_unlikely(&delayacct_key))
 173                 return;
 174
 175         if (current->delays)
 176                 __delayacct_swapin_end();
 177 }
 178
 179 static inline void delayacct_compact_start(void)
 180 {
 181         if (!static_branch_unlikely(&delayacct_key))
 182                 return;
 183
 184         if (current->delays)
 185                 __delayacct_compact_start();
 186 }
 187
 188 static inline void delayacct_compact_end(void)
 189 {
 190         if (!static_branch_unlikely(&delayacct_key))
 191                 return;
 192
 193         if (current->delays)
 194                 __delayacct_compact_end();
 195 }
 196
 197 #else
 198 static inline void delayacct_init(void)
 199 {}
 200 static inline void delayacct_tsk_init(struct task_struct *tsk)
 201 {}
 202 static inline void delayacct_tsk_free(struct task_struct *tsk)
 203 {}
 204 static inline void delayacct_blkio_start(void)
 205 {}
 206 static inline void delayacct_blkio_end(struct task_struct *p)
 207 {}
 208 static inline int delayacct_add_tsk(struct taskstats *d,
 209                                         struct task_struct *tsk)
 210 { return 0; }
 211 static inline __u64 delayacct_blkio_ticks(struct task_struct *tsk)
 212 { return 0; }
 213 static inline int delayacct_is_task_waiting_on_io(struct task_struct *p)
 214 { return 0; }
 215 static inline void delayacct_freepages_start(void)
 216 {}
 217 static inline void delayacct_freepages_end(void)
 218 {}
 219 static inline void delayacct_thrashing_start(void)
 220 {}
 221 static inline void delayacct_thrashing_end(void)
 222 {}
 223 static inline void delayacct_swapin_start(void)
 224 {}
 225 static inline void delayacct_swapin_end(void)
 226 {}
 227 static inline void delayacct_compact_start(void)
 228 {}
 229 static inline void delayacct_compact_end(void)
 230 {}
 231
 232 #endif /* CONFIG_TASK_DELAY_ACCT */
 233
 234 #endif