1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * haltpoll.c - haltpoll idle governor
4  *
5  * Copyright 2019 Red Hat, Inc. and/or its affiliates.
6  *
7  * This work is licensed under the terms of the GNU GPL, version 2.  See
8  * the COPYING file in the top-level directory.
9  *
10  * Authors: Marcelo Tosatti <mtosatti@redhat.com>
11  */
12 
13 #include <linux/kernel.h>
14 #include <linux/cpuidle.h>
15 #include <linux/time.h>
16 #include <linux/ktime.h>
17 #include <linux/hrtimer.h>
18 #include <linux/tick.h>
19 #include <linux/sched.h>
20 #include <linux/module.h>
21 #include <linux/kvm_para.h>
22 #include <trace/events/power.h>
23 
24 static unsigned int guest_halt_poll_ns __read_mostly = 200000;
25 module_param(guest_halt_poll_ns, uint, 0644);
26 
27 /* division factor to shrink halt_poll_ns */
28 static unsigned int guest_halt_poll_shrink __read_mostly = 2;
29 module_param(guest_halt_poll_shrink, uint, 0644);
30 
31 /* multiplication factor to grow per-cpu poll_limit_ns */
32 static unsigned int guest_halt_poll_grow __read_mostly = 2;
33 module_param(guest_halt_poll_grow, uint, 0644);
34 
35 /* value in us to start growing per-cpu halt_poll_ns */
36 static unsigned int guest_halt_poll_grow_start __read_mostly = 50000;
37 module_param(guest_halt_poll_grow_start, uint, 0644);
38 
39 /* allow shrinking guest halt poll */
40 static bool guest_halt_poll_allow_shrink __read_mostly = true;
41 module_param(guest_halt_poll_allow_shrink, bool, 0644);
42 
43 /**
44  * haltpoll_select - selects the next idle state to enter
45  * @drv: cpuidle driver containing state data
46  * @dev: the CPU
47  * @stop_tick: indication on whether or not to stop the tick
48  */
49 static int haltpoll_select(struct cpuidle_driver *drv,
50 			   struct cpuidle_device *dev,
51 			   bool *stop_tick)
52 {
53 	s64 latency_req = cpuidle_governor_latency_req(dev->cpu);
54 
55 	if (!drv->state_count || latency_req == 0) {
56 		*stop_tick = false;
57 		return 0;
58 	}
59 
60 	if (dev->poll_limit_ns == 0)
61 		return 1;
62 
63 	/* Last state was poll? */
64 	if (dev->last_state_idx == 0) {
65 		/* Halt if no event occurred on poll window */
66 		if (dev->poll_time_limit == true)
67 			return 1;
68 
69 		*stop_tick = false;
70 		/* Otherwise, poll again */
71 		return 0;
72 	}
73 
74 	*stop_tick = false;
75 	/* Last state was halt: poll */
76 	return 0;
77 }
78 
79 static void adjust_poll_limit(struct cpuidle_device *dev, u64 block_ns)
80 {
81 	unsigned int val;
82 
83 	/* Grow cpu_halt_poll_us if
84 	 * cpu_halt_poll_us < block_ns < guest_halt_poll_us
85 	 */
86 	if (block_ns > dev->poll_limit_ns && block_ns <= guest_halt_poll_ns) {
87 		val = dev->poll_limit_ns * guest_halt_poll_grow;
88 
89 		if (val < guest_halt_poll_grow_start)
90 			val = guest_halt_poll_grow_start;
91 		if (val > guest_halt_poll_ns)
92 			val = guest_halt_poll_ns;
93 
94 		trace_guest_halt_poll_ns_grow(val, dev->poll_limit_ns);
95 		dev->poll_limit_ns = val;
96 	} else if (block_ns > guest_halt_poll_ns &&
97 		   guest_halt_poll_allow_shrink) {
98 		unsigned int shrink = guest_halt_poll_shrink;
99 
100 		val = dev->poll_limit_ns;
101 		if (shrink == 0)
102 			val = 0;
103 		else
104 			val /= shrink;
105 		trace_guest_halt_poll_ns_shrink(val, dev->poll_limit_ns);
106 		dev->poll_limit_ns = val;
107 	}
108 }
109 
110 /**
111  * haltpoll_reflect - update variables and update poll time
112  * @dev: the CPU
113  * @index: the index of actual entered state
114  */
115 static void haltpoll_reflect(struct cpuidle_device *dev, int index)
116 {
117 	dev->last_state_idx = index;
118 
119 	if (index != 0)
120 		adjust_poll_limit(dev, dev->last_residency_ns);
121 }
122 
123 /**
124  * haltpoll_enable_device - scans a CPU's states and does setup
125  * @drv: cpuidle driver
126  * @dev: the CPU
127  */
128 static int haltpoll_enable_device(struct cpuidle_driver *drv,
129 				  struct cpuidle_device *dev)
130 {
131 	dev->poll_limit_ns = 0;
132 
133 	return 0;
134 }
135 
136 static struct cpuidle_governor haltpoll_governor = {
137 	.name =			"haltpoll",
138 	.rating =		9,
139 	.enable =		haltpoll_enable_device,
140 	.select =		haltpoll_select,
141 	.reflect =		haltpoll_reflect,
142 };
143 
144 static int __init init_haltpoll(void)
145 {
146 	if (kvm_para_available())
147 		return cpuidle_register_governor(&haltpoll_governor);
148 
149 	return 0;
150 }
151 
152 postcore_initcall(init_haltpoll);
153