327 	 * If @sch is a sub-sched which is bypassing, its tasks should go into  in bypass_enq_target_dsq()
328 	 * the bypass DSQs of the nearest ancestor which is not bypassing. The  in bypass_enq_target_dsq()
329 	 * not-bypassing ancestor is responsible for scheduling all tasks from  in bypass_enq_target_dsq()
330 	 * bypassing sub-trees. If all ancestors including root are bypassing,  in bypass_enq_target_dsq()
333 	 * Whenever a sched starts bypassing, all runnable tasks in its subtree  in bypass_enq_target_dsq()
1088 	 * Allowing reenqueues doesn't make sense while bypassing. This also  in schedule_dsq_reenq()
2954 		 * See scx_disable_workfn() for the explanation on the bypassing  in dispatch_one()
3043 			 * can't have an infinite slice while bypassing.  in set_next_task_scx()
3471  * When neither applies, or the deciding scheduler is bypassing on either task's
3535 	bool bypassing;  in select_task_rq_scx()  local
3550 	bypassing = scx_bypassing(sch, task_cpu(p));  in select_task_rq_scx()
3551 	if (likely(SCX_HAS_OP(sch, select_cpu)) && !bypassing) {  in select_task_rq_scx()
3574 		 * While bypassing, the enqueue path routes @p to a bypass DSQ  in select_task_rq_scx()
3580 		if (bypassing) {  in select_task_rq_scx()
3728 			 * ancestor's bypass DSQ while the owner is bypassing.  in check_rq_for_timeouts()
5955 	 * the nearest non-bypassing ancestor or root. As enable_bypass_dsp() is  in enable_bypass_dsp()
5956 	 * called iff @sch is not already bypassed due to an ancestor bypassing,  in enable_bypass_dsp()
5957 	 * we can assume that the parent is not bypassing and thus will be the  in enable_bypass_dsp()
5961 	 * guarantees that the nearest non-bypassing ancestor or root has bypass  in enable_bypass_dsp()
5962 	 * dispatch enabled while a descendant is bypassing, which is all that's  in enable_bypass_dsp()
5966 	 * the bypass dispatch handling path from both bypassing and hosting  in enable_bypass_dsp()
6010  * bypassing. A cpu that goes idle during the bypass window and stays idle won't
6040  * Bypassing guarantees that all runnable tasks make forward progress without
6135 		 * while bypassing. Either we see enabled or the enable path  in scx_bypass()
6295 				scx_error(sch, "parent bypassing (%d)", -EBUSY);  in scx_link_sched()
9544 	 * While bypassing for PM ops, IRQ handling may not be online which can  in scx_kick_cpu()