Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d56217b2 authored by Park Bumgyu's avatar Park Bumgyu Committed by Todd Kjos
Browse files

ANDROID: Add vendor hooks to the scheduler 



Add vendor hooks for vendor-specific scheduling.

  android_rvh_select_task_rq_rt:
    To perform vendor-specific RT task placement.

  android_rvh_select_fallback_rq:
    To restrict cpu usage.

  android_rvh_scheduler_tick:
    To collect periodic scheduling information and to schedule tasks.

  android_rvh_enqueue_tas/android_rvh_dequeue_task:
    For vendor to be aware of the task schedule in/out.

  android_rvh_can_migrate_task:
    To limit task migration based on vendor requirements.

  android_rvh_find_lowest_rq:
    To find the lowest rq for RT task with vendor-specific way.

Bug: 155241766

Change-Id: I926458b0a911d564e5932e200125b12406c2deee
Signed-off-by: default avatarPark Bumgyu <bumgyu.park@samsung.com>
Signed-off-by: default avatarJianMin Liu <jian-min.liu@mediatek.com>
parent 8ae87ad4

drivers/android/vendor_hooks.c

+7 −0
Original line number Diff line number Diff line
@@ -21,6 +21,13 @@ 
 * associated with them) to allow external modules to probe them.

 */

EXPORT_TRACEPOINT_SYMBOL_GPL(android_rvh_select_task_rq_fair);

EXPORT_TRACEPOINT_SYMBOL_GPL(android_rvh_select_task_rq_rt);

EXPORT_TRACEPOINT_SYMBOL_GPL(android_rvh_select_fallback_rq);

EXPORT_TRACEPOINT_SYMBOL_GPL(android_rvh_scheduler_tick);

EXPORT_TRACEPOINT_SYMBOL_GPL(android_rvh_enqueue_task);

EXPORT_TRACEPOINT_SYMBOL_GPL(android_rvh_dequeue_task);

EXPORT_TRACEPOINT_SYMBOL_GPL(android_rvh_can_migrate_task);

EXPORT_TRACEPOINT_SYMBOL_GPL(android_rvh_find_lowest_rq);

EXPORT_TRACEPOINT_SYMBOL_GPL(android_rvh_rtmutex_prepare_setprio);

EXPORT_TRACEPOINT_SYMBOL_GPL(android_rvh_prepare_prio_fork);

EXPORT_TRACEPOINT_SYMBOL_GPL(android_rvh_finish_prio_fork);

include/trace/hooks/sched.h

+37 −0
Original line number Diff line number Diff line
@@ -16,6 +16,36 @@ DECLARE_RESTRICTED_HOOK(android_rvh_select_task_rq_fair, 
	TP_PROTO(struct task_struct *p, int prev_cpu, int sd_flag, int wake_flags, int *new_cpu),

	TP_ARGS(p, prev_cpu, sd_flag, wake_flags, new_cpu), 1);



DECLARE_RESTRICTED_HOOK(android_rvh_select_task_rq_rt,

	TP_PROTO(struct task_struct *p, int prev_cpu, int sd_flag, int wake_flags, int *new_cpu),

	TP_ARGS(p, prev_cpu, sd_flag, wake_flags, new_cpu), 1);



DECLARE_RESTRICTED_HOOK(android_rvh_select_fallback_rq,

	TP_PROTO(int cpu, struct task_struct *p, int *new_cpu),

	TP_ARGS(cpu, p, new_cpu), 1);



struct rq;

DECLARE_RESTRICTED_HOOK(android_rvh_scheduler_tick,

	TP_PROTO(struct rq *rq),

	TP_ARGS(rq), 1);



DECLARE_RESTRICTED_HOOK(android_rvh_enqueue_task,

	TP_PROTO(struct rq *rq, struct task_struct *p),

	TP_ARGS(rq, p), 1);



DECLARE_RESTRICTED_HOOK(android_rvh_dequeue_task,

	TP_PROTO(struct rq *rq, struct task_struct *p),

	TP_ARGS(rq, p), 1);



DECLARE_RESTRICTED_HOOK(android_rvh_can_migrate_task,

	TP_PROTO(struct task_struct *p, int dst_cpu, int *can_migrate),

	TP_ARGS(p, dst_cpu, can_migrate), 1);



DECLARE_RESTRICTED_HOOK(android_rvh_find_lowest_rq,

	TP_PROTO(struct task_struct *p, struct cpumask *local_cpu_mask,

			int *lowest_cpu),

	TP_ARGS(p, local_cpu_mask, lowest_cpu), 1);



DECLARE_RESTRICTED_HOOK(android_rvh_prepare_prio_fork,

	TP_PROTO(struct task_struct *p),

	TP_ARGS(p), 1);
@@ -37,6 +67,13 @@ DECLARE_RESTRICTED_HOOK(android_rvh_setscheduler, 
	TP_ARGS(p), 1);

#else

#define trace_android_rvh_select_task_rq_fair(p, prev_cpu, sd_flag, wake_flags, new_cpu)

#define trace_android_rvh_select_task_rq_rt(p, prev_cpu, sd_flag, wake_flags, new_cpu)

#define trace_android_rvh_select_fallback_rq(cpu, p, dest_cpu)

#define trace_android_rvh_scheduler_tick(rq)

#define trace_android_rvh_enqueue_task(rq, p)

#define trace_android_rvh_dequeue_task(rq, p)

#define trace_android_rvh_can_migrate_task(p, dst_cpu, can_migrate)

#define trace_android_rvh_find_lowest_rq(p, local_cpu_mask, lowest_cpu)

#define trace_android_rvh_prepare_prio_fork(p)

#define trace_android_rvh_finish_prio_fork(p)

#define trace_android_rvh_rtmutex_prepare_setprio(p, pi_task)

kernel/sched/core.c

+11 −1
Original line number Diff line number Diff line
@@ -1312,6 +1312,8 @@ static inline void enqueue_task(struct rq *rq, struct task_struct *p, int flags) 


	uclamp_rq_inc(rq, p);

	p->sched_class->enqueue_task(rq, p, flags);



	trace_android_rvh_enqueue_task(rq, p);

}



static inline void dequeue_task(struct rq *rq, struct task_struct *p, int flags)
@@ -1326,6 +1328,8 @@ static inline void dequeue_task(struct rq *rq, struct task_struct *p, int flags) 


	uclamp_rq_dec(rq, p);

	p->sched_class->dequeue_task(rq, p, flags);



	trace_android_rvh_dequeue_task(rq, p);

}



void activate_task(struct rq *rq, struct task_struct *p, int flags)
@@ -2046,7 +2050,11 @@ static int select_fallback_rq(int cpu, struct task_struct *p) 
	int nid = cpu_to_node(cpu);

	const struct cpumask *nodemask = NULL;

	enum { cpuset, possible, fail } state = cpuset;

	int dest_cpu;

	int dest_cpu = -1;



	trace_android_rvh_select_fallback_rq(cpu, p, &dest_cpu);

	if (dest_cpu >= 0)

		return dest_cpu;



	/*

	 * If the node that the CPU is on has been offlined, cpu_to_node()
@@ -3628,6 +3636,8 @@ void scheduler_tick(void) 
	rq->idle_balance = idle_cpu(cpu);

	trigger_load_balance(rq);

#endif



	trace_android_rvh_scheduler_tick(rq);

}



#ifdef CONFIG_NO_HZ_FULL

kernel/sched/fair.c

+5 −0
Original line number Diff line number Diff line
@@ -7351,9 +7351,14 @@ static 
int can_migrate_task(struct task_struct *p, struct lb_env *env)

{

	int tsk_cache_hot;

	int can_migrate = 1;



	lockdep_assert_held(&env->src_rq->lock);



	trace_android_rvh_can_migrate_task(p, env->dst_cpu, &can_migrate);

	if (!can_migrate)

		return 0;



	/*

	 * We do not migrate tasks that are:

	 * 1) throttled_lb_pair, or

kernel/sched/rt.c

+13 −0
Original line number Diff line number Diff line
@@ -7,6 +7,8 @@ 


#include "pelt.h"



#include <trace/hooks/sched.h>



int sched_rr_timeslice = RR_TIMESLICE;

int sysctl_sched_rr_timeslice = (MSEC_PER_SEC / HZ) * RR_TIMESLICE;

/* More than 4 hours if BW_SHIFT equals 20. */
@@ -1433,6 +1435,12 @@ select_task_rq_rt(struct task_struct *p, int cpu, int sd_flag, int flags) 
	struct task_struct *curr;

	struct rq *rq;

	bool test;

	int target_cpu = -1;



	trace_android_rvh_select_task_rq_rt(p, cpu, sd_flag,

					flags, &target_cpu);

	if (target_cpu >= 0)

		return target_cpu;



	/* For anything but wake ups, just return the task_cpu */

	if (sd_flag != SD_BALANCE_WAKE && sd_flag != SD_BALANCE_FORK)
@@ -1696,6 +1704,11 @@ static int find_lowest_rq(struct task_struct *task) 
	int this_cpu = smp_processor_id();

	int cpu      = task_cpu(task);

	int ret;

	int lowest_cpu = -1;



	trace_android_rvh_find_lowest_rq(task, lowest_mask, &lowest_cpu);

	if (lowest_cpu >= 0)

		return lowest_cpu;



	/* Make sure the mask is initialized first */

	if (unlikely(!lowest_mask))