LCOV - code coverage report
Current view: top level - include/linux - smp.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 1 1 100.0 %
Date: 2017-01-25 Functions: 0 0 -

          Line data    Source code
       1             : #ifndef __LINUX_SMP_H
       2             : #define __LINUX_SMP_H
       3             : 
       4             : /*
       5             :  *      Generic SMP support
       6             :  *              Alan Cox. <alan@redhat.com>
       7             :  */
       8             : 
       9             : #include <linux/errno.h>
      10             : #include <linux/types.h>
      11             : #include <linux/list.h>
      12             : #include <linux/cpumask.h>
      13             : 
      14             : extern void cpu_idle(void);
      15           1 : 
      16             : struct call_single_data {
      17             :         struct list_head list;
      18             :         void (*func) (void *info);
      19             :         void *info;
      20             :         u16 flags;
      21             :         u16 priv;
      22             : };
      23             : 
      24             : /* total number of cpus in this system (may exceed NR_CPUS) */
      25             : extern unsigned int total_cpus;
      26             : 
      27             : int smp_call_function_single(int cpuid, void (*func) (void *info), void *info,
      28             :                                 int wait);
      29             : 
      30             : #ifdef CONFIG_SMP
      31             : 
      32             : #include <linux/preempt.h>
      33             : #include <linux/kernel.h>
      34             : #include <linux/compiler.h>
      35             : #include <linux/thread_info.h>
      36             : #include <asm/smp.h>
      37             : 
      38             : /*
      39             :  * main cross-CPU interfaces, handles INIT, TLB flush, STOP, etc.
      40             :  * (defined in asm header):
      41             :  */
      42             : 
      43             : /*
      44             :  * stops all CPUs but the current one:
      45             :  */
      46             : extern void smp_send_stop(void);
      47             : 
      48             : /*
      49             :  * sends a 'reschedule' event to another CPU:
      50             :  */
      51             : extern void smp_send_reschedule(int cpu);
      52             : 
      53             : 
      54             : /*
      55             :  * Prepare machine for booting other CPUs.
      56             :  */
      57             : extern void smp_prepare_cpus(unsigned int max_cpus);
      58             : 
      59             : /*
      60             :  * Bring a CPU up
      61             :  */
      62             : extern int __cpu_up(unsigned int cpunum);
      63             : 
      64             : /*
      65             :  * Final polishing of CPUs
      66             :  */
      67             : extern void smp_cpus_done(unsigned int max_cpus);
      68             : 
      69             : /*
      70             :  * Call a function on all other processors
      71             :  */
      72             : int smp_call_function(void(*func)(void *info), void *info, int wait);
      73             : void smp_call_function_many(const struct cpumask *mask,
      74             :                             void (*func)(void *info), void *info, bool wait);
      75             : 
      76             : void __smp_call_function_single(int cpuid, struct call_single_data *data,
      77             :                                 int wait);
      78             : 
      79             : int smp_call_function_any(const struct cpumask *mask,
      80             :                           void (*func)(void *info), void *info, int wait);
      81             : 
      82             : /*
      83             :  * Generic and arch helpers
      84             :  */
      85             : #ifdef CONFIG_USE_GENERIC_SMP_HELPERS
      86             : void generic_smp_call_function_single_interrupt(void);
      87             : void generic_smp_call_function_interrupt(void);
      88             : void ipi_call_lock(void);
      89             : void ipi_call_unlock(void);
      90             : void ipi_call_lock_irq(void);
      91             : void ipi_call_unlock_irq(void);
      92             : #endif
      93             : 
      94             : /*
      95             :  * Call a function on all processors
      96             :  */
      97             : int on_each_cpu(void (*func) (void *info), void *info, int wait);
      98             : 
      99             : #define MSG_ALL_BUT_SELF        0x8000  /* Assume <32768 CPU's */
     100             : #define MSG_ALL                 0x8001
     101             : 
     102             : #define MSG_INVALIDATE_TLB      0x0001  /* Remote processor TLB invalidate */
     103             : #define MSG_STOP_CPU            0x0002  /* Sent to shut down slave CPU's
     104             :                                          * when rebooting
     105             :                                          */
     106             : #define MSG_RESCHEDULE          0x0003  /* Reschedule request from master CPU*/
     107             : #define MSG_CALL_FUNCTION       0x0004  /* Call function on all other CPUs */
     108             : 
     109             : /*
     110             :  * Mark the boot cpu "online" so that it can call console drivers in
     111             :  * printk() and can access its per-cpu storage.
     112             :  */
     113             : void smp_prepare_boot_cpu(void);
     114             : 
     115             : extern unsigned int setup_max_cpus;
     116             : 
     117             : #else /* !SMP */
     118             : 
     119             : static inline void smp_send_stop(void) { }
     120             : 
     121             : /*
     122             :  *      These macros fold the SMP functionality into a single CPU system
     123             :  */
     124             : #define raw_smp_processor_id()                  0
     125             : static inline int up_smp_call_function(void (*func)(void *), void *info)
     126             : {
     127             :         return 0;
     128             : }
     129             : #define smp_call_function(func, info, wait) \
     130             :                         (up_smp_call_function(func, info))
     131             : #define on_each_cpu(func,info,wait)             \
     132             :         ({                                      \
     133             :                 local_irq_disable();            \
     134             :                 func(info);                     \
     135             :                 local_irq_enable();             \
     136             :                 0;                              \
     137             :         })
     138             : static inline void smp_send_reschedule(int cpu) { }
     139             : #define num_booting_cpus()                      1
     140             : #define smp_prepare_boot_cpu()                  do {} while (0)
     141             : #define smp_call_function_many(mask, func, info, wait) \
     142             :                         (up_smp_call_function(func, info))
     143             : static inline void init_call_single_data(void) { }
     144             : 
     145             : static inline int
     146             : smp_call_function_any(const struct cpumask *mask, void (*func)(void *info),
     147             :                       void *info, int wait)
     148             : {
     149             :         return smp_call_function_single(0, func, info, wait);
     150             : }
     151             : 
     152             : #endif /* !SMP */
     153             : 
     154             : /*
     155             :  * smp_processor_id(): get the current CPU ID.
     156             :  *
     157             :  * if DEBUG_PREEMPT is enabled the we check whether it is
     158             :  * used in a preemption-safe way. (smp_processor_id() is safe
     159             :  * if it's used in a preemption-off critical section, or in
     160             :  * a thread that is bound to the current CPU.)
     161             :  *
     162             :  * NOTE: raw_smp_processor_id() is for internal use only
     163             :  * (smp_processor_id() is the preferred variant), but in rare
     164             :  * instances it might also be used to turn off false positives
     165             :  * (i.e. smp_processor_id() use that the debugging code reports but
     166             :  * which use for some reason is legal). Don't use this to hack around
     167             :  * the warning message, as your code might not work under PREEMPT.
     168             :  */
     169             : #ifdef CONFIG_DEBUG_PREEMPT
     170             :   extern unsigned int debug_smp_processor_id(void);
     171             : # define smp_processor_id() debug_smp_processor_id()
     172             : #else
     173             : # define smp_processor_id() raw_smp_processor_id()
     174             : #endif
     175             : 
     176             : #define get_cpu()               ({ preempt_disable(); smp_processor_id(); })
     177             : #define put_cpu()               preempt_enable()
     178             : 
     179             : /*
     180             :  * Callback to arch code if there's nosmp or maxcpus=0 on the
     181             :  * boot command line:
     182             :  */
     183             : extern void arch_disable_smp_support(void);
     184             : 
     185             : void smp_setup_processor_id(void);
     186             : 
     187             : #endif /* __LINUX_SMP_H */

Generated by: LCOV version 1.10