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 31struct task_delay_info { 32 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 68extern int delayacct_on; /* Delay accounting turned on/off */ 69extern struct kmem_cache *delayacct_cache; 70extern void delayacct_init(void); 71extern void __delayacct_tsk_init(struct task_struct *); 72extern void __delayacct_tsk_exit(struct task_struct *); 73extern void __delayacct_blkio_start(void); 74extern void __delayacct_blkio_end(void); 75extern int __delayacct_add_tsk(struct taskstats *, struct task_struct *); 76extern __u64 __delayacct_blkio_ticks(struct task_struct *); 77extern void __delayacct_freepages_start(void); 78extern void __delayacct_freepages_end(void); 79 80static 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 88static inline void delayacct_set_flag(int flag) 89{ 90 if (current->delays) 91 current->delays->flags |= flag; 92} 93 94static inline void delayacct_clear_flag(int flag) 95{ 96 if (current->delays) 97 current->delays->flags &= ~flag; 98} 99 100static 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 */ 111static 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 118static inline void delayacct_blkio_start(void) 119{ 120 delayacct_set_flag(DELAYACCT_PF_BLKIO); 121 if (current->delays) 122 __delayacct_blkio_start(); 123} 124 125static inline void delayacct_blkio_end(void) 126{ 127 if (current->delays) 128 __delayacct_blkio_end(); 129 delayacct_clear_flag(DELAYACCT_PF_BLKIO); 130} 131 132static 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 140static 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 147static inline void delayacct_freepages_start(void) 148{ 149 if (current->delays) 150 __delayacct_freepages_start(); 151} 152 153static inline void delayacct_freepages_end(void) 154{ 155 if (current->delays) 156 __delayacct_freepages_end(); 157} 158 159#else 160static inline void delayacct_set_flag(int flag) 161{} 162static inline void delayacct_clear_flag(int flag) 163{} 164static inline void delayacct_init(void) 165{} 166static inline void delayacct_tsk_init(struct task_struct *tsk) 167{} 168static inline void delayacct_tsk_free(struct task_struct *tsk) 169{} 170static inline void delayacct_blkio_start(void) 171{} 172static inline void delayacct_blkio_end(void) 173{} 174static inline int delayacct_add_tsk(struct taskstats *d, 175 struct task_struct *tsk) 176{ return 0; } 177static inline __u64 delayacct_blkio_ticks(struct task_struct *tsk) 178{ return 0; } 179static inline int delayacct_is_task_waiting_on_io(struct task_struct *p) 180{ return 0; } 181static inline void delayacct_freepages_start(void) 182{} 183static inline void delayacct_freepages_end(void) 184{} 185 186#endif /* CONFIG_TASK_DELAY_ACCT */ 187 188#endif 189