Merge tag 'unicode-for-next-5.17-rc3' of git://git.kernel.org/pub/scm/linux/kernel...
[linux-2.6-microblaze.git] / 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