Green shading in the line number column means the source is part of the translation unit, red means it is conditionally excluded. Highlighted line numbers link to the translation unit page. Highlighted macros link to the macro page.
1: /* Freezer declarations */ 2: 3: #ifndef FREEZER_H_INCLUDED 4: #define FREEZER_H_INCLUDED 5: 6: #include <linux/debug_locks.h> 7: #include <linux/sched.h> 8: #include <linux/wait.h> 9: #include <linux/atomic.h> 10: 11: #ifdef CONFIG_FREEZER 12: extern atomic_t system_freezing_cnt; /* nr of freezing conds in effect */ 13: extern bool pm_freezing; /* PM freezing in effect */ 14: extern bool pm_nosig_freezing; /* PM nosig freezing in effect */ 15: 16: /* 17: * Timeout for stopping processes 18: */ 19: extern unsigned int freeze_timeout_msecs; 20: 21: /* 22: * Check if a process has been frozen 23: */ 24: static inline bool frozen(struct task_struct *p) 25: { 26: return p->flags & PF_FROZEN; 27: } 28: 29: extern bool freezing_slow_path(struct task_struct *p); 30: 31: /* 32: * Check if there is a request to freeze a process 33: */ 34: static inline bool freezing(struct task_struct *p) 35: { 36: if (likely(!atomic_read(&system_freezing_cnt))) 37: return false; 38: return freezing_slow_path(p); 39: } 40: 41: /* Takes and releases task alloc lock using task_lock() */ 42: extern void __thaw_task(struct task_struct *t); 43: 44: extern bool __refrigerator(bool check_kthr_stop); 45: extern int freeze_processes(void); 46: extern int freeze_kernel_threads(void); 47: extern void thaw_processes(void); 48: extern void thaw_kernel_threads(void); 49: 50: /* 51: * DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION 52: * If try_to_freeze causes a lockdep warning it means the caller may deadlock 53: */ 54: static inline bool try_to_freeze_unsafe(void) 55: { 56: might_sleep(); 57: if (likely(!freezing(current))) 58: return false; 59: return __refrigerator(false); 60: } 61: 62: static inline bool try_to_freeze(void) 63: { 64: if (!(current->flags & PF_NOFREEZE)) 65: debug_check_no_locks_held(); 66: return try_to_freeze_unsafe(); 67: } 68: 69: extern bool freeze_task(struct task_struct *p); 70: extern bool set_freezable(void); 71: 72: #ifdef CONFIG_CGROUP_FREEZER 73: extern bool cgroup_freezing(struct task_struct *task); 74: #else /* !CONFIG_CGROUP_FREEZER */ 75: static inline bool cgroup_freezing(struct task_struct *task) 76: { 77: return false; 78: } 79: #endif /* !CONFIG_CGROUP_FREEZER */ 80: 81: /* 82: * The PF_FREEZER_SKIP flag should be set by a vfork parent right before it 83: * calls wait_for_completion(&vfork) and reset right after it returns from this 84: * function. Next, the parent should call try_to_freeze() to freeze itself 85: * appropriately in case the child has exited before the freezing of tasks is 86: * complete. However, we don't want kernel threads to be frozen in unexpected 87: * places, so we allow them to block freeze_processes() instead or to set 88: * PF_NOFREEZE if needed. Fortunately, in the ____call_usermodehelper() case the 89: * parent won't really block freeze_processes(), since ____call_usermodehelper() 90: * (the child) does a little before exec/exit and it can't be frozen before 91: * waking up the parent. 92: */ 93: 94: 95: /** 96: * freezer_do_not_count - tell freezer to ignore %current 97: * 98: * Tell freezers to ignore the current task when determining whether the 99: * target frozen state is reached. IOW, the current task will be 100: * considered frozen enough by freezers. 101: * 102: * The caller shouldn't do anything which isn't allowed for a frozen task 103: * until freezer_cont() is called. Usually, freezer[_do_not]_count() pair 104: * wrap a scheduling operation and nothing much else. 105: */ 106: static inline void freezer_do_not_count(void) 107: { 108: current->flags |= PF_FREEZER_SKIP; 109: } 110: 111: /** 112: * freezer_count - tell freezer to stop ignoring %current 113: * 114: * Undo freezer_do_not_count(). It tells freezers that %current should be 115: * considered again and tries to freeze if freezing condition is already in 116: * effect. 117: */ 118: static inline void freezer_count(void) 119: { 120: current->flags &= ~PF_FREEZER_SKIP; 121: /* 122: * If freezing is in progress, the following paired with smp_mb() 123: * in freezer_should_skip() ensures that either we see %true 124: * freezing() or freezer_should_skip() sees !PF_FREEZER_SKIP. 125: */ 126: smp_mb(); 127: try_to_freeze(); 128: } 129: 130: /* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */ 131: static inline void freezer_count_unsafe(void) 132: { 133: current->flags &= ~PF_FREEZER_SKIP; 134: smp_mb(); 135: try_to_freeze_unsafe(); 136: } 137: 138: /** 139: * freezer_should_skip - whether to skip a task when determining frozen 140: * state is reached 141: * @p: task in quesion 142: * 143: * This function is used by freezers after establishing %true freezing() to 144: * test whether a task should be skipped when determining the target frozen 145: * state is reached. IOW, if this function returns %true, @p is considered 146: * frozen enough. 147: */ 148: static inline bool freezer_should_skip(struct task_struct *p) 149: { 150: /* 151: * The following smp_mb() paired with the one in freezer_count() 152: * ensures that either freezer_count() sees %true freezing() or we 153: * see cleared %PF_FREEZER_SKIP and return %false. This makes it 154: * impossible for a task to slip frozen state testing after 155: * clearing %PF_FREEZER_SKIP. 156: */ 157: smp_mb(); 158: return p->flags & PF_FREEZER_SKIP; 159: } 160: 161: /* 162: * These functions are intended to be used whenever you want allow a sleeping 163: * task to be frozen. Note that neither return any clear indication of 164: * whether a freeze event happened while in this function. 165: */ 166: 167: /* Like schedule(), but should not block the freezer. */ 168: static inline void freezable_schedule(void) 169: { 170: freezer_do_not_count(); 171: schedule(); 172: freezer_count(); 173: } 174: 175: /* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */ 176: static inline void freezable_schedule_unsafe(void) 177: { 178: freezer_do_not_count(); 179: schedule(); 180: freezer_count_unsafe(); 181: } 182: 183: /* 184: * Like freezable_schedule_timeout(), but should not block the freezer. Do not 185: * call this with locks held. 186: */ 187: static inline long freezable_schedule_timeout(long timeout) 188: { 189: long __retval; 190: freezer_do_not_count(); 191: __retval = schedule_timeout(timeout); 192: freezer_count(); 193: return __retval; 194: } 195: 196: /* 197: * Like schedule_timeout_interruptible(), but should not block the freezer. Do not 198: * call this with locks held. 199: */ 200: static inline long freezable_schedule_timeout_interruptible(long timeout) 201: { 202: long __retval; 203: freezer_do_not_count(); 204: __retval = schedule_timeout_interruptible(timeout); 205: freezer_count(); 206: return __retval; 207: } 208: 209: /* Like schedule_timeout_killable(), but should not block the freezer. */ 210: static inline long freezable_schedule_timeout_killable(long timeout) 211: { 212: long __retval; 213: freezer_do_not_count(); 214: __retval = schedule_timeout_killable(timeout); 215: freezer_count(); 216: return __retval; 217: } 218: 219: /* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */ 220: static inline long freezable_schedule_timeout_killable_unsafe(long timeout) 221: { 222: long __retval; 223: freezer_do_not_count(); 224: __retval = schedule_timeout_killable(timeout); 225: freezer_count_unsafe(); 226: return __retval; 227: } 228: 229: /* 230: * Like schedule_hrtimeout_range(), but should not block the freezer. Do not 231: * call this with locks held. 232: */ 233: static inline int freezable_schedule_hrtimeout_range(ktime_t *expires, 234: unsigned long delta, const enum hrtimer_mode mode) 235: { 236: int __retval; 237: freezer_do_not_count(); 238: __retval = schedule_hrtimeout_range(expires, delta, mode); 239: freezer_count(); 240: return __retval; 241: } 242: 243: /* 244: * Freezer-friendly wrappers around wait_event_interruptible(), 245: * wait_event_killable() and wait_event_interruptible_timeout(), originally 246: * defined in <linux/wait.h> 247: */ 248: 249: #define wait_event_freezekillable(wq, condition) \ 250: ({ \ 251: int __retval; \ 252: freezer_do_not_count(); \ 253: __retval = wait_event_killable(wq, (condition)); \ 254: freezer_count(); \ 255: __retval; \ 256: }) 257: 258: /* DO NOT ADD ANY NEW CALLERS OF THIS FUNCTION */ 259: #define wait_event_freezekillable_unsafe(wq, condition) \ 260: ({ \ 261: int __retval; \ 262: freezer_do_not_count(); \ 263: __retval = wait_event_killable(wq, (condition)); \ 264: freezer_count_unsafe(); \ 265: __retval; \ 266: }) 267: 268: #define wait_event_freezable(wq, condition) \ 269: ({ \ 270: int __retval; \ 271: freezer_do_not_count(); \ 272: __retval = wait_event_interruptible(wq, (condition)); \ 273: freezer_count(); \ 274: __retval; \ 275: }) 276: 277: #define wait_event_freezable_timeout(wq, condition, timeout) \ 278: ({ \ 279: long __retval = timeout; \ 280: freezer_do_not_count(); \ 281: __retval = wait_event_interruptible_timeout(wq, (condition), \ 282: __retval); \ 283: freezer_count(); \ 284: __retval; \ 285: }) 286: 287: #define wait_event_freezable_exclusive(wq, condition) \ 288: ({ \ 289: int __retval; \ 290: freezer_do_not_count(); \ 291: __retval = wait_event_interruptible_exclusive(wq, condition); \ 292: freezer_count(); \ 293: __retval; \ 294: }) 295: 296: 297: #else /* !CONFIG_FREEZER */ 298: static inline bool frozen(struct task_struct *p) { return false; } 299: static inline bool freezing(struct task_struct *p) { return false; } 300: static inline void __thaw_task(struct task_struct *t) {} 301: 302: static inline bool __refrigerator(bool check_kthr_stop) { return false; } 303: static inline int freeze_processes(void) { return -ENOSYS; } 304: static inline int freeze_kernel_threads(void) { return -ENOSYS; } 305: static inline void thaw_processes(void) {} 306: static inline void thaw_kernel_threads(void) {} 307: 308: static inline bool try_to_freeze_nowarn(void) { return false; } 309: static inline bool try_to_freeze(void) { return false; } 310: 311: static inline void freezer_do_not_count(void) {} 312: static inline void freezer_count(void) {} 313: static inline int freezer_should_skip(struct task_struct *p) { return 0; } 314: static inline void set_freezable(void) {} 315: 316: #define freezable_schedule() schedule() 317: 318: #define freezable_schedule_unsafe() schedule() 319: 320: #define freezable_schedule_timeout(timeout) schedule_timeout(timeout) 321: 322: #define freezable_schedule_timeout_interruptible(timeout) \ 323: schedule_timeout_interruptible(timeout) 324: 325: #define freezable_schedule_timeout_killable(timeout) \ 326: schedule_timeout_killable(timeout) 327: 328: #define freezable_schedule_timeout_killable_unsafe(timeout) \ 329: schedule_timeout_killable(timeout) 330: 331: #define freezable_schedule_hrtimeout_range(expires, delta, mode) \ 332: schedule_hrtimeout_range(expires, delta, mode) 333: 334: #define wait_event_freezable(wq, condition) \ 335: wait_event_interruptible(wq, condition) 336: 337: #define wait_event_freezable_timeout(wq, condition, timeout) \ 338: wait_event_interruptible_timeout(wq, condition, timeout) 339: 340: #define wait_event_freezable_exclusive(wq, condition) \ 341: wait_event_interruptible_exclusive(wq, condition) 342: 343: #define wait_event_freezekillable(wq, condition) \ 344: wait_event_killable(wq, condition) 345: 346: #define wait_event_freezekillable_unsafe(wq, condition) \ 347: wait_event_killable(wq, condition) 348: 349: #endif /* !CONFIG_FREEZER */ 350: 351: #endif /* FREEZER_H_INCLUDED */ 352: