Merge tag 'sched_urgent_for_v6.1_rc2' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

+12 -12

kernel/sched/core.c

··· 4823 4823 4824 4824 #ifdef CONFIG_SMP 4825 4825 4826 - static void do_balance_callbacks(struct rq *rq, struct callback_head *head) 4826 + static void do_balance_callbacks(struct rq *rq, struct balance_callback *head) 4827 4827 { 4828 4828 void (*func)(struct rq *rq); 4829 - struct callback_head *next; 4829 + struct balance_callback *next; 4830 4830 4831 4831 lockdep_assert_rq_held(rq); 4832 4832 ··· 4853 4853 * This abuse is tolerated because it places all the unlikely/odd cases behind 4854 4854 * a single test, namely: rq->balance_callback == NULL. 4855 4855 */ 4856 - struct callback_head balance_push_callback = { 4856 + struct balance_callback balance_push_callback = { 4857 4857 .next = NULL, 4858 - .func = (void (*)(struct callback_head *))balance_push, 4858 + .func = balance_push, 4859 4859 }; 4860 4860 4861 - static inline struct callback_head * 4861 + static inline struct balance_callback * 4862 4862 __splice_balance_callbacks(struct rq *rq, bool split) 4863 4863 { 4864 - struct callback_head *head = rq->balance_callback; 4864 + struct balance_callback *head = rq->balance_callback; 4865 4865 4866 4866 if (likely(!head)) 4867 4867 return NULL; ··· 4883 4883 return head; 4884 4884 } 4885 4885 4886 - static inline struct callback_head *splice_balance_callbacks(struct rq *rq) 4886 + static inline struct balance_callback *splice_balance_callbacks(struct rq *rq) 4887 4887 { 4888 4888 return __splice_balance_callbacks(rq, true); 4889 4889 } ··· 4893 4893 do_balance_callbacks(rq, __splice_balance_callbacks(rq, false)); 4894 4894 } 4895 4895 4896 - static inline void balance_callbacks(struct rq *rq, struct callback_head *head) 4896 + static inline void balance_callbacks(struct rq *rq, struct balance_callback *head) 4897 4897 { 4898 4898 unsigned long flags; 4899 4899 ··· 4910 4910 { 4911 4911 } 4912 4912 4913 - static inline struct callback_head *splice_balance_callbacks(struct rq *rq) 4913 + static inline struct balance_callback *splice_balance_callbacks(struct rq *rq) 4914 4914 { 4915 4915 return NULL; 4916 4916 } 4917 4917 4918 - static inline void balance_callbacks(struct rq *rq, struct callback_head *head) 4918 + static inline void balance_callbacks(struct rq *rq, struct balance_callback *head) 4919 4919 { 4920 4920 } 4921 4921 ··· 6188 6188 preempt_enable(); 6189 6189 } 6190 6190 6191 - static DEFINE_PER_CPU(struct callback_head, core_balance_head); 6191 + static DEFINE_PER_CPU(struct balance_callback, core_balance_head); 6192 6192 6193 6193 static void queue_core_balance(struct rq *rq) 6194 6194 { ··· 7419 7419 int oldpolicy = -1, policy = attr->sched_policy; 7420 7420 int retval, oldprio, newprio, queued, running; 7421 7421 const struct sched_class *prev_class; 7422 - struct callback_head *head; 7422 + struct balance_callback *head; 7423 7423 struct rq_flags rf; 7424 7424 int reset_on_fork; 7425 7425 int queue_flags = DEQUEUE_SAVE | DEQUEUE_MOVE | DEQUEUE_NOCLOCK;

+2 -2

kernel/sched/deadline.c

··· 644 644 return rq->online && dl_task(prev); 645 645 } 646 646 647 - static DEFINE_PER_CPU(struct callback_head, dl_push_head); 648 - static DEFINE_PER_CPU(struct callback_head, dl_pull_head); 647 + static DEFINE_PER_CPU(struct balance_callback, dl_push_head); 648 + static DEFINE_PER_CPU(struct balance_callback, dl_pull_head); 649 649 650 650 static void push_dl_tasks(struct rq *); 651 651 static void pull_dl_task(struct rq *);

+2 -2

kernel/sched/rt.c

··· 410 410 return !plist_head_empty(&rq->rt.pushable_tasks); 411 411 } 412 412 413 - static DEFINE_PER_CPU(struct callback_head, rt_push_head); 414 - static DEFINE_PER_CPU(struct callback_head, rt_pull_head); 413 + static DEFINE_PER_CPU(struct balance_callback, rt_push_head); 414 + static DEFINE_PER_CPU(struct balance_callback, rt_pull_head); 415 415 416 416 static void push_rt_tasks(struct rq *); 417 417 static void pull_rt_task(struct rq *);

+19 -13

kernel/sched/sched.h

··· 938 938 DECLARE_STATIC_KEY_FALSE(sched_uclamp_used); 939 939 #endif /* CONFIG_UCLAMP_TASK */ 940 940 941 + struct rq; 942 + struct balance_callback { 943 + struct balance_callback *next; 944 + void (*func)(struct rq *rq); 945 + }; 946 + 941 947 /* 942 948 * This is the main, per-CPU runqueue data structure. 943 949 * ··· 1042 1036 unsigned long cpu_capacity; 1043 1037 unsigned long cpu_capacity_orig; 1044 1038 1045 - struct callback_head *balance_callback; 1039 + struct balance_callback *balance_callback; 1046 1040 1047 1041 unsigned char nohz_idle_balance; 1048 1042 unsigned char idle_balance; ··· 1188 1182 #endif 1189 1183 } 1190 1184 1185 + DECLARE_PER_CPU_SHARED_ALIGNED(struct rq, runqueues); 1186 + 1187 + #define cpu_rq(cpu) (&per_cpu(runqueues, (cpu))) 1188 + #define this_rq() this_cpu_ptr(&runqueues) 1189 + #define task_rq(p) cpu_rq(task_cpu(p)) 1190 + #define cpu_curr(cpu) (cpu_rq(cpu)->curr) 1191 + #define raw_rq() raw_cpu_ptr(&runqueues) 1192 + 1191 1193 struct sched_group; 1192 1194 #ifdef CONFIG_SCHED_CORE 1193 1195 static inline struct cpumask *sched_group_span(struct sched_group *sg); ··· 1283 1269 return true; 1284 1270 1285 1271 for_each_cpu_and(cpu, sched_group_span(group), p->cpus_ptr) { 1286 - if (sched_core_cookie_match(rq, p)) 1272 + if (sched_core_cookie_match(cpu_rq(cpu), p)) 1287 1273 return true; 1288 1274 } 1289 1275 return false; ··· 1397 1383 #else 1398 1384 static inline void update_idle_core(struct rq *rq) { } 1399 1385 #endif 1400 - 1401 - DECLARE_PER_CPU_SHARED_ALIGNED(struct rq, runqueues); 1402 - 1403 - #define cpu_rq(cpu) (&per_cpu(runqueues, (cpu))) 1404 - #define this_rq() this_cpu_ptr(&runqueues) 1405 - #define task_rq(p) cpu_rq(task_cpu(p)) 1406 - #define cpu_curr(cpu) (cpu_rq(cpu)->curr) 1407 - #define raw_rq() raw_cpu_ptr(&runqueues) 1408 1386 1409 1387 #ifdef CONFIG_FAIR_GROUP_SCHED 1410 1388 static inline struct task_struct *task_of(struct sched_entity *se) ··· 1550 1544 #endif 1551 1545 }; 1552 1546 1553 - extern struct callback_head balance_push_callback; 1547 + extern struct balance_callback balance_push_callback; 1554 1548 1555 1549 /* 1556 1550 * Lockdep annotation that avoids accidental unlocks; it's like a ··· 1730 1724 1731 1725 static inline void 1732 1726 queue_balance_callback(struct rq *rq, 1733 - struct callback_head *head, 1727 + struct balance_callback *head, 1734 1728 void (*func)(struct rq *rq)) 1735 1729 { 1736 1730 lockdep_assert_rq_held(rq); ··· 1743 1737 if (unlikely(head->next || rq->balance_callback == &balance_push_callback)) 1744 1738 return; 1745 1739 1746 - head->func = (void (*)(struct callback_head *))func; 1740 + head->func = func; 1747 1741 head->next = rq->balance_callback; 1748 1742 rq->balance_callback = head; 1749 1743 }

Configure Feed

Configure Feed