License-: GPL2. *java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
ifndef_
#define _LINUX_STATIC_CALL_H#efine _

/*
 * Static callll_query(ame;
*
  *Static call support
 **
*with performance. This is especially   cases where
d /java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
 .
 *
 *
 * API EXPORT_SYMBOLSTATIC_CALL_TRAMPname)   java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 *
 *   java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 1
);
 *name java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 *   DEFINE_STATIC_CALL_NULL func) \
 *
 *   __static_call_return0;
 *
 _n,_,NULL)
 *
 *   static_call_update(#  ;   \
 *  n)
 *
 *   EXPORT_STATIC_CALL{, /
 
 * Usage example .func  _,  
 *
 *   # Start with the following functions (with identical 
2);
 (int ,int ;
 *
 ' java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 72
 WRITE_ONCE(-func);
 *
 *   # Call cpus_read_unlock)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
*static_call(y_name)a, )java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 *
 *   Update 'my_name' to point to func_b()
 *   static_call_update EXPORT_STATIC_CALLname)   \
 
 *   # Call func_b{    java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 *    EXPORT_SYMBOL_G( = _java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 33
 *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
 * Implementation _struct ,
 *
*This  
therwisejava.lang.StringIndexOutOfBoundsException: Range [41, 36) out of bounds for length 43
 
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
*Thejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 *name will 
 *
 *   If the arch has CONFIG_HAVE_STATIC_CALL_INLINE
  ,
 *   rather thane/ *java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 *compiler to   thestatic_call( sites  annotate 
 *   tes section.
 *
 *
 * Notes on NULL function pointers:
 *
 *   Static_call()s support _(,_unc,_)
 *    pointers .
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 *   Clearly calling  NULL    BAD',  toojava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 *   static_call()s (although when HAVE_STATIC_CALL it might not be immediately
 *   fatal). A NULL static_call can be the result of:
 *
 *     DECLARE_STATIC_CALL_NULL(my_static_call, void }
 *
    which is   with a
 *   typename:
 *
 *     void (*java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 2
 *
 *   or #efine n,* emitan    -java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 *   HAVE_STATIC_CALL void *func = READ_ONCE(STATIC_CALL_KEY.)  \
    instruction,instead  an immediate tail-call . HAVE_STATIC_CALL_INLINE
*architectures can  trampoline call   .
 *
 *   In all cases, any argument evaluation is unconditional. Unlike a java.lang.StringIndexOutOfBoundsException: Range [0, 77) out of bounds for length 29
 *   conditional function
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
      if  t))java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 45
 *         my_func_ptr(arg1)
 *
 *   where the argument evaludation also depends on the pointer value.
 
 *   When calling a static_call java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
 *     static_call_cond(
*
 *   which will #efine n)(STATIC_CALL_KEYname)
 *   dereferences.
 *
 *   To query which function is currently set to be called, use:
 *
 *   func = static_call_query(name);
 *
 *
 * DEFINE_STATIC_CALL_RET0 / __static_call_return0:
 *
 *   Just like how DEFINE_STATIC_CALL_NULL() / static_call_cond() optimize the
 *   conditional void function call, DEFINE_STATIC_CALL_RET0 /
 *   __static_call_return0 optimize the do nothing return 0 function.
 *
 *   This feature is strictly UB per the C standard (since it casts a function
 *   pointer to a different signature) and relies on the architecture ABI to
 *   make things work. In particular it relies on Caller Stack-cleanup and the
 *   whole return register being clobbered for short return values. All normal
 *   CDECL style ABIs conform.
 *
 *   In particular the x86_64 implementation replaces the 5 byte CALL
 *   instruction at the callsite with a 5 byte clear of the RAX register,
 *   completely eliding any function call overhead.
 *
 *   Notably argument setup is unconditional.
 *
 *
 * EXPORT_STATIC_CALL() vs EXPORT_STATIC_CALL_TRAMP():
 *
 *   The difference is that the _TRAMP variant tries to only export the
 *   trampoline with the result that a module can use static_call{,_cond}() but
 *   not static_call_update().
 *
 */

#include <linux/types.h>
#include <linux/cpu.h>
#include <linux/static_call_types.h>

#ifdef CONFIG_HAVE_STATIC_CALL
#include <asm/static_call.h>

/*
 * Either @site or @tramp can be NULL.
 */
extern void arch_static_call_transform(void *site, void *tramp, void *func, bool tail);

#define STATIC_CALL_TRAMP_ADDR(name) &STATIC_CALL_TRAMP(name)

#else
#define STATIC_CALL_TRAMP_ADDR(name) NULL
#endif

#define static_call_update(name, func)     \
({         \
 typeof(&STATIC_CALL_TRAMP(name)) __F = (func);   \
 __static_call_update(&STATIC_CALL_KEY(name),   \
        STATIC_CALL_TRAMP_ADDR(name), __F); \
})

#define static_call_query(name) (READ_ONCE(STATIC_CALL_KEY(name).func))

#ifdef CONFIG_HAVE_STATIC_CALL_INLINE

extern int static_call_initialized;

extern int __init static_call_init(void);

extern void static_call_force_reinit(void);

struct static_call_mod {
 struct static_call_mod *next;
 struct module *mod; /* for vmlinux, mod == NULL */
 struct static_call_site *sites;
};

/* For finding the key associated with a trampoline */
struct static_call_tramp_key {
 s32 tramp;
 s32 key;
};

extern void __static_call_update(struct static_call_key *key, void *tramp, void *func);
extern int static_call_mod_init(struct module *mod);
extern int static_call_text_reserved(void *start, void *end);

extern long __static_call_return0(void);

#define DEFINE_STATIC_CALL(name, _func)     \
 DECLARE_STATIC_CALL(name, _func);    \
 struct static_call_key STATIC_CALL_KEY(name) = {  \
  .func = _func,      \
  .type = 1,      \
 };        \
 ARCH_DEFINE_STATIC_CALL_TRAMP(name, _func)

#define DEFINE_STATIC_CALL_NULL(name, _func)    \
 DECLARE_STATIC_CALL(name, _func);    \
 struct static_call_key STATIC_CALL_KEY(name) = {  \
  .func = NULL,      \
  .type = 1,      \
 };        \
 ARCH_DEFINE_STATIC_CALL_NULL_TRAMP(name)

#define DEFINE_STATIC_CALL_RET0(name, _func)    \
 DECLARE_STATIC_CALL(name, _func);    \
 struct static_call_key STATIC_CALL_KEY(name) = {  \
  .func = __static_call_return0,    \
  .type = 1,      \
 };        \
 ARCH_DEFINE_STATIC_CALL_RET0_TRAMP(name)

#define static_call_cond(name) (void)__static_call(name)

#define EXPORT_STATIC_CALL(name)     \
 EXPORT_SYMBOL(STATIC_CALL_KEY(name));    \
 EXPORT_SYMBOL(STATIC_CALL_TRAMP(name))
#define EXPORT_STATIC_CALL_GPL(name)     \
 EXPORT_SYMBOL_GPL(STATIC_CALL_KEY(name));   \
 EXPORT_SYMBOL_GPL(STATIC_CALL_TRAMP(name))

/* Leave the key unexported, so modules can't change static call targets: */
#define EXPORT_STATIC_CALL_TRAMP(name)     \
 EXPORT_SYMBOL(STATIC_CALL_TRAMP(name));    \
 ARCH_ADD_TRAMP_KEY(name)
#define EXPORT_STATIC_CALL_TRAMP_GPL(name)    \
 EXPORT_SYMBOL_GPL(STATIC_CALL_TRAMP(name));   \
 ARCH_ADD_TRAMP_KEY(name)

#elif defined(CONFIG_HAVE_STATIC_CALL)

#define static_call_initialized 0

static inline int static_call_init(void) { return 0; }

#define DEFINE_STATIC_CALL(name, _func)     \
 DECLARE_STATIC_CALL(name, _func);    \
 struct static_call_key STATIC_CALL_KEY(name) = {  \
  .func = _func,      \
 };        \
 ARCH_DEFINE_STATIC_CALL_TRAMP(name, _func)

#define DEFINE_STATIC_CALL_NULL(name, _func)    \
 DECLARE_STATIC_CALL(name, _func);    \
 struct static_call_key STATIC_CALL_KEY(name) = {  \
  .func = NULL,      \
 };        \
 ARCH_DEFINE_STATIC_CALL_NULL_TRAMP(name)

#define DEFINE_STATIC_CALL_RET0(name, _func)    \
 DECLARE_STATIC_CALL(name, _func);    \
 struct static_call_key STATIC_CALL_KEY(name) = {  \
  .func = __static_call_return0,    \
 };        \
 ARCH_DEFINE_STATIC_CALL_RET0_TRAMP(name)

#define static_call_cond(name) (void)__static_call(name)

static inline
void __static_call_update(struct static_call_key *key, void *tramp, void *func)
{
 cpus_read_lock();
 WRITE_ONCE(key->func, func);
 arch_static_call_transform(NULL, tramp, func, false);
 cpus_read_unlock();
}

static inline int static_call_text_reserved(void *start, void *end)
{
 return 0;
}

extern long __static_call_return0(void);

#define EXPORT_STATIC_CALL(name)     \
 EXPORT_SYMBOL(STATIC_CALL_KEY(name));    \
 EXPORT_SYMBOL(STATIC_CALL_TRAMP(name))
#define EXPORT_STATIC_CALL_GPL(name)     \
 EXPORT_SYMBOL_GPL(STATIC_CALL_KEY(name));   \
 EXPORT_SYMBOL_GPL(STATIC_CALL_TRAMP(name))

/* Leave the key unexported, so modules can't change static call targets: */
#define EXPORT_STATIC_CALL_TRAMP(name)     \
 EXPORT_SYMBOL(STATIC_CALL_TRAMP(name))
#define EXPORT_STATIC_CALL_TRAMP_GPL(name)    \
 EXPORT_SYMBOL_GPL(STATIC_CALL_TRAMP(name))

#else /* Generic implementation */

#define static_call_initialized 0

static inline int static_call_init(void) { return 0; }

static inline long __static_call_return0(void)
{
 return 0;
}

#define __DEFINE_STATIC_CALL(name, _func, _func_init)   \
 DECLARE_STATIC_CALL(name, _func);    \
 struct static_call_key STATIC_CALL_KEY(name) = {  \
  .func = _func_init,     \
 }

#define DEFINE_STATIC_CALL(name, _func)     \
 __DEFINE_STATIC_CALL(name, _func, _func)

#define DEFINE_STATIC_CALL_NULL(name, _func)    \
 __DEFINE_STATIC_CALL(name, _func, NULL)

#define DEFINE_STATIC_CALL_RET0(name, _func)    \
 __DEFINE_STATIC_CALL(name, _func, __static_call_return0)

static inline void __static_call_nop(void) { }

/*
 * This horrific hack takes care of two things:
 *
 *  - it ensures the compiler will only load the function pointer ONCE,
 *    which avoids a reload race.
 *
 *  - it ensures the argument evaluation is unconditional, similar
 *    to the HAVE_STATIC_CALL variant.
 *
 * Sadly current GCC/Clang (10 for both) do not optimize this properly
 * and will emit an indirect call for the NULL case :-(
 */
#define __static_call_cond(name)     \
({         \
 void *func = READ_ONCE(STATIC_CALL_KEY(name).func);  \
 if (!func)       \
  func = &__static_call_nop;    \
 (typeof(STATIC_CALL_TRAMP(name))*)func;    \
})

#define static_call_cond(name) (void)__static_call_cond(name)

static inline
void __static_call_update(struct static_call_key *key, void *tramp, void *func)
{
 WRITE_ONCE(key->func, func);
}

static inline int static_call_text_reserved(void *start, void *end)
{
 return 0;
}

#define EXPORT_STATIC_CALL(name) EXPORT_SYMBOL(STATIC_CALL_KEY(name))
#define EXPORT_STATIC_CALL_GPL(name) EXPORT_SYMBOL_GPL(STATIC_CALL_KEY(name))

#endif /* CONFIG_HAVE_STATIC_CALL */

#endif /* _LINUX_STATIC_CALL_H */