kvm/kernel/x86/external-module-compat.c

   1
   2 /*
   3  * smp_call_function_single() is not exported below 2.6.20.
   4  */
   5
   6 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
   7
   8 #undef smp_call_function_single
   9
  10 #include <linux/spinlock.h>
  11 #include <linux/smp.h>
  12
  13 struct scfs_thunk_info {
  14         int cpu;
  15         void (*func)(void *info);
  16         void *info;
  17 };
  18
  19 static void scfs_thunk(void *_thunk)
  20 {
  21         struct scfs_thunk_info *thunk = _thunk;
  22
  23         if (raw_smp_processor_id() == thunk->cpu)
  24                 thunk->func(thunk->info);
  25 }
  26
  27 int kvm_smp_call_function_single(int cpu, void (*func)(void *info),
  28                                  void *info, int wait)
  29 {
  30         int r, this_cpu;
  31         struct scfs_thunk_info thunk;
  32
  33         this_cpu = get_cpu();
  34         WARN_ON(irqs_disabled());
  35         if (cpu == this_cpu) {
  36                 r = 0;
  37                 local_irq_disable();
  38                 func(info);
  39                 local_irq_enable();
  40         } else {
  41                 thunk.cpu = cpu;
  42                 thunk.func = func;
  43                 thunk.info = info;
  44                 r = smp_call_function(scfs_thunk, &thunk, 0, 1);
  45         }
  46         put_cpu();
  47         return r;
  48 }
  49
  50 #define smp_call_function_single kvm_smp_call_function_single
  51
  52 #elif LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
  53 /*
  54  * pre 2.6.23 doesn't handle smp_call_function_single on current cpu
  55  */
  56
  57 #undef smp_call_function_single
  58
  59 #include <linux/smp.h>
  60
  61 int kvm_smp_call_function_single(int cpu, void (*func)(void *info),
  62                                  void *info, int wait)
  63 {
  64         int this_cpu, r;
  65
  66         this_cpu = get_cpu();
  67         WARN_ON(irqs_disabled());
  68         if (cpu == this_cpu) {
  69                 r = 0;
  70                 local_irq_disable();
  71                 func(info);
  72                 local_irq_enable();
  73         } else
  74                 r = smp_call_function_single(cpu, func, info, 0, wait);
  75         put_cpu();
  76         return r;
  77 }
  78
  79 #define smp_call_function_single kvm_smp_call_function_single
  80
  81 #elif LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27)
  82
  83 /* The 'nonatomic' argument was removed in 2.6.27. */
  84
  85 #undef smp_call_function_single
  86
  87 #include <linux/smp.h>
  88
  89 int kvm_smp_call_function_single(int cpu, void (*func)(void *info),
  90                                  void *info, int wait)
  91 {
  92         return smp_call_function_single(cpu, func, info, 0, wait);
  93 }
  94
  95 #define smp_call_function_single kvm_smp_call_function_single
  96
  97 #endif
  98
  99 /* div64_u64 is fairly new */
 100 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26)
 101
 102 #ifndef CONFIG_64BIT
 103
 104 /* 64bit divisor, dividend and result. dynamic precision */
 105 uint64_t div64_u64(uint64_t dividend, uint64_t divisor)
 106 {
 107         uint32_t high, d;
 108
 109         high = divisor >> 32;
 110         if (high) {
 111                 unsigned int shift = fls(high);
 112
 113                 d = divisor >> shift;
 114                 dividend >>= shift;
 115         } else
 116                 d = divisor;
 117
 118         do_div(dividend, d);
 119
 120         return dividend;
 121 }
 122
 123 #endif
 124
 125 #endif
 126
 127 /*
 128  * smp_call_function_mask() is not defined/exported below 2.6.24
 129  */
 130
 131 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 132
 133 #include <linux/smp.h>
 134
 135 struct kvm_call_data_struct {
 136         void (*func) (void *info);
 137         void *info;
 138         atomic_t started;
 139         atomic_t finished;
 140         int wait;
 141 };
 142
 143 static void kvm_ack_smp_call(void *_data)
 144 {
 145         struct kvm_call_data_struct *data = _data;
 146         /* if wait == 0, data can be out of scope
 147          * after atomic_inc(info->started)
 148          */
 149         void (*func) (void *info) = data->func;
 150         void *info = data->info;
 151         int wait = data->wait;
 152
 153         smp_mb();
 154         atomic_inc(&data->started);
 155         (*func)(info);
 156         if (wait) {
 157                 smp_mb();
 158                 atomic_inc(&data->finished);
 159         }
 160 }
 161
 162 int kvm_smp_call_function_mask(cpumask_t mask,
 163                                void (*func) (void *info), void *info, int wait)
 164 {
 165         struct kvm_call_data_struct data;
 166         cpumask_t allbutself;
 167         int cpus;
 168         int cpu;
 169         int me;
 170
 171         me = get_cpu();
 172         WARN_ON(irqs_disabled());
 173         allbutself = cpu_online_map;
 174         cpu_clear(me, allbutself);
 175
 176         cpus_and(mask, mask, allbutself);
 177         cpus = cpus_weight(mask);
 178
 179         if (!cpus)
 180                 goto out;
 181
 182         data.func = func;
 183         data.info = info;
 184         atomic_set(&data.started, 0);
 185         data.wait = wait;
 186         if (wait)
 187                 atomic_set(&data.finished, 0);
 188
 189         for (cpu = first_cpu(mask); cpu != NR_CPUS; cpu = next_cpu(cpu, mask))
 190                 smp_call_function_single(cpu, kvm_ack_smp_call, &data, 0);
 191
 192         while (atomic_read(&data.started) != cpus) {
 193                 cpu_relax();
 194                 barrier();
 195         }
 196
 197         if (!wait)
 198                 goto out;
 199
 200         while (atomic_read(&data.finished) != cpus) {
 201                 cpu_relax();
 202                 barrier();
 203         }
 204 out:
 205         put_cpu();
 206         return 0;
 207 }
 208
 209 #endif
 210
 211 /* manually export hrtimer_init/start/cancel */
 212 void (*hrtimer_init_p)(struct hrtimer *timer, clockid_t which_clock,
 213                        enum hrtimer_mode mode);
 214 int (*hrtimer_start_p)(struct hrtimer *timer, ktime_t tim,
 215                        const enum hrtimer_mode mode);
 216 int (*hrtimer_cancel_p)(struct hrtimer *timer);
 217
 218 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
 219
 220 static void kvm_set_normalized_timespec(struct timespec *ts, time_t sec,
 221                                         long nsec)
 222 {
 223         while (nsec >= NSEC_PER_SEC) {
 224                 nsec -= NSEC_PER_SEC;
 225                 ++sec;
 226         }
 227         while (nsec < 0) {
 228                 nsec += NSEC_PER_SEC;
 229                 --sec;
 230         }
 231         ts->tv_sec = sec;
 232         ts->tv_nsec = nsec;
 233 }
 234
 235 struct timespec kvm_ns_to_timespec(const s64 nsec)
 236 {
 237         struct timespec ts;
 238
 239         if (!nsec)
 240                 return (struct timespec) {0, 0};
 241
 242         ts.tv_sec = div_long_long_rem_signed(nsec, NSEC_PER_SEC, &ts.tv_nsec);
 243         if (unlikely(nsec < 0))
 244                 kvm_set_normalized_timespec(&ts, ts.tv_sec, ts.tv_nsec);
 245
 246         return ts;
 247 }
 248
 249 #endif
 250
 251 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
 252
 253 #include <linux/pci.h>
 254
 255 struct pci_dev *pci_get_bus_and_slot(unsigned int bus, unsigned int devfn)
 256 {
 257         struct pci_dev *dev = NULL;
 258
 259         while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
 260                 if (pci_domain_nr(dev->bus) == 0 &&
 261                     (dev->bus->number == bus && dev->devfn == devfn))
 262                         return dev;
 263         }
 264         return NULL;
 265 }
 266
 267 #endif