cregit-Linux how code gets into the kernel

Release 4.14 include/linux/smp.h

Directory: include/linux
/* SPDX-License-Identifier: GPL-2.0 */
#ifndef __LINUX_SMP_H

#define __LINUX_SMP_H

/*
 *      Generic SMP support
 *              Alan Cox. <alan@redhat.com>
 */

#include <linux/errno.h>
#include <linux/types.h>
#include <linux/list.h>
#include <linux/cpumask.h>
#include <linux/init.h>
#include <linux/llist.h>


typedef void (*smp_call_func_t)(void *info);

struct __call_single_data {
	
struct llist_node llist;
	
smp_call_func_t func;
	
void *info;
	
unsigned int flags;
};

/* Use __aligned() to avoid to use 2 cache lines for 1 csd */
typedef struct __call_single_data call_single_data_t
	
__aligned(sizeof(struct __call_single_data));

/* total number of cpus in this system (may exceed NR_CPUS) */
extern unsigned int total_cpus;

int smp_call_function_single(int cpuid, smp_call_func_t func, void *info,
			     int wait);

/*
 * Call a function on all processors
 */
int on_each_cpu(smp_call_func_t func, void *info, int wait);

/*
 * Call a function on processors specified by mask, which might include
 * the local one.
 */
void on_each_cpu_mask(const struct cpumask *mask, smp_call_func_t func,
		void *info, bool wait);

/*
 * Call a function on each processor for which the supplied function
 * cond_func returns a positive value. This may include the local
 * processor.
 */
void on_each_cpu_cond(bool (*cond_func)(int cpu, void *info),
		smp_call_func_t func, void *info, bool wait,
		gfp_t gfp_flags);

int smp_call_function_single_async(int cpu, call_single_data_t *csd);

#ifdef CONFIG_SMP

#include <linux/preempt.h>
#include <linux/kernel.h>
#include <linux/compiler.h>
#include <linux/thread_info.h>
#include <asm/smp.h>

/*
 * main cross-CPU interfaces, handles INIT, TLB flush, STOP, etc.
 * (defined in asm header):
 */

/*
 * stops all CPUs but the current one:
 */
extern void smp_send_stop(void);

/*
 * sends a 'reschedule' event to another CPU:
 */
extern void smp_send_reschedule(int cpu);


/*
 * Prepare machine for booting other CPUs.
 */
extern void smp_prepare_cpus(unsigned int max_cpus);

/*
 * Bring a CPU up
 */
extern int __cpu_up(unsigned int cpunum, struct task_struct *tidle);

/*
 * Final polishing of CPUs
 */
extern void smp_cpus_done(unsigned int max_cpus);

/*
 * Call a function on all other processors
 */
int smp_call_function(smp_call_func_t func, void *info, int wait);
void smp_call_function_many(const struct cpumask *mask,
			    smp_call_func_t func, void *info, bool wait);

int smp_call_function_any(const struct cpumask *mask,
			  smp_call_func_t func, void *info, int wait);

void kick_all_cpus_sync(void);
void wake_up_all_idle_cpus(void);

/*
 * Generic and arch helpers
 */
void __init call_function_init(void);
void generic_smp_call_function_single_interrupt(void);

#define generic_smp_call_function_interrupt \
	generic_smp_call_function_single_interrupt

/*
 * Mark the boot cpu "online" so that it can call console drivers in
 * printk() and can access its per-cpu storage.
 */
void smp_prepare_boot_cpu(void);

extern unsigned int setup_max_cpus;
extern void __init setup_nr_cpu_ids(void);
extern void __init smp_init(void);

extern int __boot_cpu_id;


static inline int get_boot_cpu_id(void) { return __boot_cpu_id; }

Contributors

PersonTokensPropCommitsCommitProp
Peter Zijlstra12100.00%1100.00%
Total12100.00%1100.00%

#else /* !SMP */
static inline void smp_send_stop(void) { }

Contributors

PersonTokensPropCommitsCommitProp
Ingo Molnar8100.00%1100.00%
Total8100.00%1100.00%

/* * These macros fold the SMP functionality into a single CPU system */ #define raw_smp_processor_id() 0
static inline int up_smp_call_function(smp_call_func_t func, void *info) { return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Con Kolivas1164.71%133.33%
Ingo Molnar529.41%133.33%
David Howells15.88%133.33%
Total17100.00%3100.00%

#define smp_call_function(func, info, wait) \ (up_smp_call_function(func, info))
static inline void smp_send_reschedule(int cpu) { }

Contributors

PersonTokensPropCommitsCommitProp
Linus Torvalds9100.00%1100.00%
Total9100.00%1100.00%

#define smp_prepare_boot_cpu() do {} while (0) #define smp_call_function_many(mask, func, info, wait) \ (up_smp_call_function(func, info))
static inline void call_function_init(void) { }

Contributors

PersonTokensPropCommitsCommitProp
Jens Axboe787.50%150.00%
Takao Indoh112.50%150.00%
Total8100.00%2100.00%


static inline int smp_call_function_any(const struct cpumask *mask, smp_call_func_t func, void *info, int wait) { return smp_call_function_single(0, func, info, wait); }

Contributors

PersonTokensPropCommitsCommitProp
Rusty Russell3497.14%150.00%
David Howells12.86%150.00%
Total35100.00%2100.00%


static inline void kick_all_cpus_sync(void) { }

Contributors

PersonTokensPropCommitsCommitProp
Thomas Gleixner8100.00%1100.00%
Total8100.00%1100.00%


static inline void wake_up_all_idle_cpus(void) { }

Contributors

PersonTokensPropCommitsCommitProp
Chuansheng Liu8100.00%1100.00%
Total8100.00%1100.00%

#ifdef CONFIG_UP_LATE_INIT extern void __init up_late_init(void);
static inline void smp_init(void) { up_late_init(); }

Contributors

PersonTokensPropCommitsCommitProp
Thomas Gleixner12100.00%1100.00%
Total12100.00%1100.00%

#else
static inline void smp_init(void) { }

Contributors

PersonTokensPropCommitsCommitProp
Thomas Gleixner8100.00%1100.00%
Total8100.00%1100.00%

#endif
static inline int get_boot_cpu_id(void) { return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Peter Zijlstra12100.00%1100.00%
Total12100.00%1100.00%

#endif /* !SMP */ /* * smp_processor_id(): get the current CPU ID. * * if DEBUG_PREEMPT is enabled then we check whether it is * used in a preemption-safe way. (smp_processor_id() is safe * if it's used in a preemption-off critical section, or in * a thread that is bound to the current CPU.) * * NOTE: raw_smp_processor_id() is for internal use only * (smp_processor_id() is the preferred variant), but in rare * instances it might also be used to turn off false positives * (i.e. smp_processor_id() use that the debugging code reports but * which use for some reason is legal). Don't use this to hack around * the warning message, as your code might not work under PREEMPT. */ #ifdef CONFIG_DEBUG_PREEMPT extern unsigned int debug_smp_processor_id(void); # define smp_processor_id() debug_smp_processor_id() #else # define smp_processor_id() raw_smp_processor_id() #endif #define get_cpu() ({ preempt_disable(); smp_processor_id(); }) #define put_cpu() preempt_enable() /* * Callback to arch code if there's nosmp or maxcpus=0 on the * boot command line: */ extern void arch_disable_smp_support(void); extern void arch_enable_nonboot_cpus_begin(void); extern void arch_enable_nonboot_cpus_end(void); void smp_setup_processor_id(void); int smp_call_on_cpu(unsigned int cpu, int (*func)(void *), void *par, bool phys); /* SMP core functions */ int smpcfd_prepare_cpu(unsigned int cpu); int smpcfd_dead_cpu(unsigned int cpu); int smpcfd_dying_cpu(unsigned int cpu); #endif /* __LINUX_SMP_H */

Overall Contributors

PersonTokensPropCommitsCommitProp
Rusty Russell9414.03%58.93%
Linus Torvalds (pre-git)7611.34%712.50%
David Daney6810.15%23.57%
Thomas Gleixner548.06%35.36%
Ingo Molnar497.31%58.93%
Andrew Morton456.72%610.71%
Jens Axboe446.57%11.79%
Peter Zijlstra284.18%11.79%
Juergen Gross253.73%11.79%
Richard Weinberger253.73%11.79%
David Howells202.99%11.79%
Linus Torvalds172.54%47.14%
Américo Wang162.39%11.79%
Chuansheng Liu142.09%11.79%
Paul Gortmaker142.09%11.79%
Robert Love121.79%11.79%
Huang Ying111.64%11.79%
Con Kolivas111.64%11.79%
Takao Indoh81.19%11.79%
Christoph Hellwig71.04%11.79%
Mike Travis60.90%11.79%
Heiko Carstens60.90%23.57%
Andi Kleen50.75%11.79%
Shaohua Li40.60%11.79%
David S. Miller30.45%11.79%
Jan Kara30.45%11.79%
Paul Mackerras20.30%11.79%
Frédéric Weisbecker10.15%11.79%
Greg Kroah-Hartman10.15%11.79%
Rakib Mullick10.15%11.79%
Total670100.00%56100.00%
Directory: include/linux
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.