drivers/cpuidle/governors/haltpoll.c

   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
  23 static unsigned int guest_halt_poll_ns __read_mostly = 200000;
  24 module_param(guest_halt_poll_ns, uint, 0644);
  25
  26 /* division factor to shrink halt_poll_ns */
  27 static unsigned int guest_halt_poll_shrink __read_mostly = 2;
  28 module_param(guest_halt_poll_shrink, uint, 0644);
  29
  30 /* multiplication factor to grow per-cpu poll_limit_ns */
  31 static unsigned int guest_halt_poll_grow __read_mostly = 2;
  32 module_param(guest_halt_poll_grow, uint, 0644);
  33
  34 /* value in us to start growing per-cpu halt_poll_ns */
  35 static unsigned int guest_halt_poll_grow_start __read_mostly = 50000;
  36 module_param(guest_halt_poll_grow_start, uint, 0644);
  37
  38 /* allow shrinking guest halt poll */
  39 static bool guest_halt_poll_allow_shrink __read_mostly = true;
  40 module_param(guest_halt_poll_allow_shrink, bool, 0644);
  41
  42 /**
  43  * haltpoll_select - selects the next idle state to enter
  44  * @drv: cpuidle driver containing state data
  45  * @dev: the CPU
  46  * @stop_tick: indication on whether or not to stop the tick
  47  */
  48 static int haltpoll_select(struct cpuidle_driver *drv,
  49                            struct cpuidle_device *dev,
  50                            bool *stop_tick)
  51 {
  52         s64 latency_req = cpuidle_governor_latency_req(dev->cpu);
  53
  54         if (!drv->state_count || latency_req == 0) {
  55                 *stop_tick = false;
  56                 return 0;
  57         }
  58
  59         if (dev->poll_limit_ns == 0)
  60                 return 1;
  61
  62         /* Last state was poll? */
  63         if (dev->last_state_idx == 0) {
  64                 /* Halt if no event occurred on poll window */
  65                 if (dev->poll_time_limit == true)
  66                         return 1;
  67
  68                 *stop_tick = false;
  69                 /* Otherwise, poll again */
  70                 return 0;
  71         }
  72
  73         *stop_tick = false;
  74         /* Last state was halt: poll */
  75         return 0;
  76 }
  77
  78 static void adjust_poll_limit(struct cpuidle_device *dev, u64 block_ns)
  79 {
  80         unsigned int val;
  81
  82         /* Grow cpu_halt_poll_us if
  83          * cpu_halt_poll_us < block_ns < guest_halt_poll_us
  84          */
  85         if (block_ns > dev->poll_limit_ns && block_ns <= guest_halt_poll_ns) {
  86                 val = dev->poll_limit_ns * guest_halt_poll_grow;
  87
  88                 if (val < guest_halt_poll_grow_start)
  89                         val = guest_halt_poll_grow_start;
  90                 if (val > guest_halt_poll_ns)
  91                         val = guest_halt_poll_ns;
  92
  93                 dev->poll_limit_ns = val;
  94         } else if (block_ns > guest_halt_poll_ns &&
  95                    guest_halt_poll_allow_shrink) {
  96                 unsigned int shrink = guest_halt_poll_shrink;
  97
  98                 val = dev->poll_limit_ns;
  99                 if (shrink == 0)
 100                         val = 0;
 101                 else
 102                         val /= shrink;
 103                 dev->poll_limit_ns = val;
 104         }
 105 }
 106
 107 /**
 108  * haltpoll_reflect - update variables and update poll time
 109  * @dev: the CPU
 110  * @index: the index of actual entered state
 111  */
 112 static void haltpoll_reflect(struct cpuidle_device *dev, int index)
 113 {
 114         dev->last_state_idx = index;
 115
 116         if (index != 0)
 117                 adjust_poll_limit(dev, dev->last_residency_ns);
 118 }
 119
 120 /**
 121  * haltpoll_enable_device - scans a CPU's states and does setup
 122  * @drv: cpuidle driver
 123  * @dev: the CPU
 124  */
 125 static int haltpoll_enable_device(struct cpuidle_driver *drv,
 126                                   struct cpuidle_device *dev)
 127 {
 128         dev->poll_limit_ns = 0;
 129
 130         return 0;
 131 }
 132
 133 static struct cpuidle_governor haltpoll_governor = {
 134         .name =                 "haltpoll",
 135         .rating =               9,
 136         .enable =               haltpoll_enable_device,
 137         .select =               haltpoll_select,
 138         .reflect =              haltpoll_reflect,
 139 };
 140
 141 static int __init init_haltpoll(void)
 142 {
 143         if (kvm_para_available())
 144                 return cpuidle_register_governor(&haltpoll_governor);
 145
 146         return 0;
 147 }
 148
 149 postcore_initcall(init_haltpoll);