Linux 5.2-rc4
[sfrench/cifs-2.6.git] / kernel / up.c
1 /*
2  * Uniprocessor-only support functions.  The counterpart to kernel/smp.c
3  */
4
5 #include <linux/interrupt.h>
6 #include <linux/kernel.h>
7 #include <linux/export.h>
8 #include <linux/smp.h>
9 #include <linux/hypervisor.h>
10
11 int smp_call_function_single(int cpu, void (*func) (void *info), void *info,
12                                 int wait)
13 {
14         unsigned long flags;
15
16         WARN_ON(cpu != 0);
17
18         local_irq_save(flags);
19         func(info);
20         local_irq_restore(flags);
21
22         return 0;
23 }
24 EXPORT_SYMBOL(smp_call_function_single);
25
26 int smp_call_function_single_async(int cpu, call_single_data_t *csd)
27 {
28         unsigned long flags;
29
30         local_irq_save(flags);
31         csd->func(csd->info);
32         local_irq_restore(flags);
33         return 0;
34 }
35 EXPORT_SYMBOL(smp_call_function_single_async);
36
37 int on_each_cpu(smp_call_func_t func, void *info, int wait)
38 {
39         unsigned long flags;
40
41         local_irq_save(flags);
42         func(info);
43         local_irq_restore(flags);
44         return 0;
45 }
46 EXPORT_SYMBOL(on_each_cpu);
47
48 /*
49  * Note we still need to test the mask even for UP
50  * because we actually can get an empty mask from
51  * code that on SMP might call us without the local
52  * CPU in the mask.
53  */
54 void on_each_cpu_mask(const struct cpumask *mask,
55                       smp_call_func_t func, void *info, bool wait)
56 {
57         unsigned long flags;
58
59         if (cpumask_test_cpu(0, mask)) {
60                 local_irq_save(flags);
61                 func(info);
62                 local_irq_restore(flags);
63         }
64 }
65 EXPORT_SYMBOL(on_each_cpu_mask);
66
67 /*
68  * Preemption is disabled here to make sure the cond_func is called under the
69  * same condtions in UP and SMP.
70  */
71 void on_each_cpu_cond_mask(bool (*cond_func)(int cpu, void *info),
72                            smp_call_func_t func, void *info, bool wait,
73                            gfp_t gfp_flags, const struct cpumask *mask)
74 {
75         unsigned long flags;
76
77         preempt_disable();
78         if (cond_func(0, info)) {
79                 local_irq_save(flags);
80                 func(info);
81                 local_irq_restore(flags);
82         }
83         preempt_enable();
84 }
85 EXPORT_SYMBOL(on_each_cpu_cond_mask);
86
87 void on_each_cpu_cond(bool (*cond_func)(int cpu, void *info),
88                       smp_call_func_t func, void *info, bool wait,
89                       gfp_t gfp_flags)
90 {
91         on_each_cpu_cond_mask(cond_func, func, info, wait, gfp_flags, NULL);
92 }
93 EXPORT_SYMBOL(on_each_cpu_cond);
94
95 int smp_call_on_cpu(unsigned int cpu, int (*func)(void *), void *par, bool phys)
96 {
97         int ret;
98
99         if (cpu != 0)
100                 return -ENXIO;
101
102         if (phys)
103                 hypervisor_pin_vcpu(0);
104         ret = func(par);
105         if (phys)
106                 hypervisor_pin_vcpu(-1);
107
108         return ret;
109 }
110 EXPORT_SYMBOL_GPL(smp_call_on_cpu);