1 /* delayacct.h - per-task delay accounting 2 * 3 * Copyright (C) Shailabh Nagar, IBM Corp. 2006 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; either version 2 of the License, or 8 * (at your option) any later version. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See 13 * the GNU General Public License for more details. 14 * 15 */ 16 17 #ifndef _LINUX_DELAYACCT_H 18 #define _LINUX_DELAYACCT_H 19 20 #include <uapi/linux/taskstats.h> 21 22 /* 23 * Per-task flags relevant to delay accounting 24 * maintained privately to avoid exhausting similar flags in sched.h:PF_* 25 * Used to set current->delays->flags 26 */ 27 #define DELAYACCT_PF_SWAPIN 0x00000001 /* I am doing a swapin */ 28 #define DELAYACCT_PF_BLKIO 0x00000002 /* I am waiting on IO */ 29 30 #ifdef CONFIG_TASK_DELAY_ACCT 31 struct task_delay_info { 32 raw_spinlock_t lock; 33 unsigned int flags; /* Private per-task flags */ 34 35 /* For each stat XXX, add following, aligned appropriately 36 * 37 * struct timespec XXX_start, XXX_end; 38 * u64 XXX_delay; 39 * u32 XXX_count; 40 * 41 * Atomicity of updates to XXX_delay, XXX_count protected by 42 * single lock above (split into XXX_lock if contention is an issue). 43 */ 44 45 /* 46 * XXX_count is incremented on every XXX operation, the delay 47 * associated with the operation is added to XXX_delay. 48 * XXX_delay contains the accumulated delay time in nanoseconds. 49 */ 50 u64 blkio_start; /* Shared by blkio, swapin */ 51 u64 blkio_delay; /* wait for sync block io completion */ 52 u64 swapin_delay; /* wait for swapin block io completion */ 53 u32 blkio_count; /* total count of the number of sync block */ 54 /* io operations performed */ 55 u32 swapin_count; /* total count of the number of swapin block */ 56 /* io operations performed */ 57 58 u64 freepages_start; 59 u64 freepages_delay; /* wait for memory reclaim */ 60 u32 freepages_count; /* total count of memory reclaim */ 61 }; 62 #endif 63 64 #include <linux/sched.h> 65 #include <linux/slab.h> 66 67 #ifdef CONFIG_TASK_DELAY_ACCT 68 extern int delayacct_on; /* Delay accounting turned on/off */ 69 extern struct kmem_cache *delayacct_cache; 70 extern void delayacct_init(void); 71 extern void __delayacct_tsk_init(struct task_struct *); 72 extern void __delayacct_tsk_exit(struct task_struct *); 73 extern void __delayacct_blkio_start(void); 74 extern void __delayacct_blkio_end(struct task_struct *); 75 extern int __delayacct_add_tsk(struct taskstats *, struct task_struct *); 76 extern __u64 __delayacct_blkio_ticks(struct task_struct *); 77 extern void __delayacct_freepages_start(void); 78 extern void __delayacct_freepages_end(void); 79 80 static inline int delayacct_is_task_waiting_on_io(struct task_struct *p) 81 { 82 if (p->delays) 83 return (p->delays->flags & DELAYACCT_PF_BLKIO); 84 else 85 return 0; 86 } 87 88 static inline void delayacct_set_flag(int flag) 89 { 90 if (current->delays) 91 current->delays->flags |= flag; 92 } 93 94 static inline void delayacct_clear_flag(int flag) 95 { 96 if (current->delays) 97 current->delays->flags &= ~flag; 98 } 99 100 static inline void delayacct_tsk_init(struct task_struct *tsk) 101 { 102 /* reinitialize in case parent's non-null pointer was dup'ed*/ 103 tsk->delays = NULL; 104 if (delayacct_on) 105 __delayacct_tsk_init(tsk); 106 } 107 108 /* Free tsk->delays. Called from bad fork and __put_task_struct 109 * where there's no risk of tsk->delays being accessed elsewhere 110 */ 111 static inline void delayacct_tsk_free(struct task_struct *tsk) 112 { 113 if (tsk->delays) 114 kmem_cache_free(delayacct_cache, tsk->delays); 115 tsk->delays = NULL; 116 } 117 118 static inline void delayacct_blkio_start(void) 119 { 120 delayacct_set_flag(DELAYACCT_PF_BLKIO); 121 if (current->delays) 122 __delayacct_blkio_start(); 123 } 124 125 static inline void delayacct_blkio_end(struct task_struct *p) 126 { 127 if (p->delays) 128 __delayacct_blkio_end(p); 129 delayacct_clear_flag(DELAYACCT_PF_BLKIO); 130 } 131 132 static inline int delayacct_add_tsk(struct taskstats *d, 133 struct task_struct *tsk) 134 { 135 if (!delayacct_on || !tsk->delays) 136 return 0; 137 return __delayacct_add_tsk(d, tsk); 138 } 139 140 static inline __u64 delayacct_blkio_ticks(struct task_struct *tsk) 141 { 142 if (tsk->delays) 143 return __delayacct_blkio_ticks(tsk); 144 return 0; 145 } 146 147 static inline void delayacct_freepages_start(void) 148 { 149 if (current->delays) 150 __delayacct_freepages_start(); 151 } 152 153 static inline void delayacct_freepages_end(void) 154 { 155 if (current->delays) 156 __delayacct_freepages_end(); 157 } 158 159 #else 160 static inline void delayacct_set_flag(int flag) 161 {} 162 static inline void delayacct_clear_flag(int flag) 163 {} 164 static inline void delayacct_init(void) 165 {} 166 static inline void delayacct_tsk_init(struct task_struct *tsk) 167 {} 168 static inline void delayacct_tsk_free(struct task_struct *tsk) 169 {} 170 static inline void delayacct_blkio_start(void) 171 {} 172 static inline void delayacct_blkio_end(struct task_struct *p) 173 {} 174 static inline int delayacct_add_tsk(struct taskstats *d, 175 struct task_struct *tsk) 176 { return 0; } 177 static inline __u64 delayacct_blkio_ticks(struct task_struct *tsk) 178 { return 0; } 179 static inline int delayacct_is_task_waiting_on_io(struct task_struct *p) 180 { return 0; } 181 static inline void delayacct_freepages_start(void) 182 {} 183 static inline void delayacct_freepages_end(void) 184 {} 185 186 #endif /* CONFIG_TASK_DELAY_ACCT */ 187 188 #endif 189