vmkdrivers/BLD/build/HEADERS/vmkapi-current-all-public/vmkernel64/release/base/vmkapi_module.h

/* **********************************************************
 * Copyright 1998 - 2009 VMware, Inc.  All rights reserved.
 * **********************************************************/

/*
 * @VMKAPIMOD_LICENSE@
 */

/*
 ***********************************************************************
 * Module                                                         */ /**
 * \defgroup Module Kernel Module Management
 *
 * @{
 ***********************************************************************
 */

#ifndef _VMKAPI_MODULE_H_
#define _VMKAPI_MODULE_H_

/** \cond never */
#ifndef VMK_HEADER_INCLUDED_FROM_VMKAPI_H
#error This vmkapi file should never be included directly but only via vmkapi.h
#endif
/** \endcond never */

#include "vmkapi_module_int.h"
#include "vmkapi_module_ns.h"

/**
 * \brief Module stack element.
 */
typedef struct vmk_ModInfoStack {
   /** \brief Module ID. */
   vmk_ModuleID modID;

   /** \brief Module function called. */
   void     *mod_fn;

   /** \brief Return address of caller. */
   void     *pushRA;

   /** \brief Next module stack element. */
   struct vmk_ModInfoStack *oldStack;
} vmk_ModInfoStack;

/**
 * \brief Guaranteed invalid module ID.
 */
#define VMK_INVALID_MODULE_ID    ((vmk_uint32)-1)

/**
 * \brief Module ID for vmkernel itself.
 */
#define VMK_VMKERNEL_MODULE_ID   0

/**
 * \brief VMware proprietary code
 */
#define VMK_MODULE_LICENSE_VMWARE	"VMware"
/**
 * \brief GPLv2
 */
#define VMK_MODULE_LICENSE_GPLV2	"GPLv2"
/**
 * \brief BSD compatibile license
 */
#define VMK_MODULE_LICENSE_BSD		"BSD"

/*
 ***********************************************************************
 * VMK_MODPARAM_NAMED --                                          */ /**
 *
 * \ingroup Module
 *
 * \brief Define a parameter set by the user during module load.
 *
 * \param[in] name   Name of the parameter.
 * \param[in] var    Name of variable to store parameter value.
 * \param[in] type   Type of the variable.
 * \param[in] desc   String describing the variable.
 *
 ***********************************************************************
 */
#define VMK_MODPARAM_NAMED(name, var, type, desc)	\
   __VMK_MODPARAM_NAMED(name, var, type);		\
   __VMK_MODPARAM_DESC(name, desc)

/*
 ***********************************************************************
 * VMK_MODPARAM --                                                */ /**
 *
 * \ingroup Module
 * \brief Define a parameter set by the user during module load.
 *
 * \note This macro relies on having a variable with the same name
 *       as the parameter.  If your variable has a different name
 *       than the parameter name, use VMK_MODPARAM_NAMED.
 *
 * \param[in] name   Name of the parameter and variable.
 * \param[in] type   Type of the variable.
 * \param[in] desc   String describing the variable.
 *
 ***********************************************************************
 */
#define VMK_MODPARAM(name, type, desc) \
   VMK_MODPARAM_NAMED(name, name, type, desc)

/*
 ***********************************************************************
 * VMK_MODPARAM_ARRAY_NAMED --                                    */ /**
 *
 * \ingroup Module
 *
 * \brief Define an array parameter that can be set by the user during
 *        module load.
 *
 * \param[in] name   Name of parameter.
 * \param[in] var    Name of array variable.
 * \param[in] type   Type of array elements.
 * \param[in] nump   Variable to store count of set elements.
 * \param[in] desc   String describing the variable.
 *
 ***********************************************************************
 */
#define VMK_MODPARAM_ARRAY_NAMED(name, var, type, nump, desc)	\
  __VMK_MODPARAM_ARRAY_NAMED(name, var, type, nump);	        \
  __VMK_MODPARAM_DESC(name, desc)

/*
 ***********************************************************************
 * VMK_MODPARAM_ARRAY --                                          */ /**
 *
 * \ingroup Module
 *
 * \brief Define an array parameter that can be set by the user during
 *        module load.
 *
 * \note This macro relies on having a variable with the same name
 *       as the parameter. If your variable has a different name
 *       than the parameter name, use VMK_MODPARAM_NAMED.
 *
 * \param[in] name   Name of parameter and variable.
 * \param[in] type   Type of array elements.
 * \param[in] nump   Variable to store count of set elements.
 * \param[in] desc   String describing the variable.
 *
 ***********************************************************************
 */
#define VMK_MODPARAM_ARRAY(name, type, nump, desc) \
     VMK_MODPARAM_ARRAY_NAMED(name, name, type, nump, desc)

/*
 ***********************************************************************
 * VMK_MODPARAM_STRING_NAMED --                                   */ /**
 *
 * \ingroup Module
 * \brief Define an string parameter that can be set by the user
 *        during module load.
 *
 * \note This creates a copy of the string; your variable must be an
 *       array of sufficient size to hold the copy.  If you do not
 *       need to modify the string consider using a charp type.
 *
 * \param[in] name      Name of parameter.
 * \param[in] string    Variable name for the string copy.
 * \param[in] len       Maximum length of string.
 * \param[in] desc      String describing the variable.
 *
 ***********************************************************************
 */
#define VMK_MODPARAM_STRING_NAMED(name, string, len, desc)	\
   __VMK_MODPARAM_STRING_NAMED(name, string, len);		\
   __VMK_MODPARAM_DESC(name, desc)

/*
 ***********************************************************************
 * VMK_MODPARAM_STRING --                                         */ /**
 *
 * \ingroup Module
 * \brief Define an string parameter that can be set by the user
 *        during module load.
 *
 * \note This creates a copy of the string; your variable must be an
 *       array of sufficient size to hold the copy.  If you do not
 *       need to modify the string consider using a charp type.
 *
 * \param[in] name   Name of parameter and char array variable.
 * \param[in] len    Maximum length of string.
 * \param[in] desc   String describing the variable.
 *
 ***********************************************************************
 */
#define VMK_MODPARAM_STRING(name, len, desc) \
   VMK_MODPARAM_STRING_NAMED(name, name, len, desc)

/*
 ***********************************************************************
 * VMK_VERSION_INFO --                                            */ /**
 *
 * \ingroup Module
 * \brief Free-form string parameter describing version, build,
 *        etc. information.
 *
 * \param[in] string    A string to be embedded as version information.
 *
 ***********************************************************************
 */
#define VMK_VERSION_INFO(string) \
   __VMK_VERSION_INFO(string)

/*
 ***********************************************************************
 * VMK_LICENSE_INFO --                                            */ /**
 *
 * \ingroup Module
 * \brief A predefined string describing the license this module is
 *        released under.
 *
 * This macro adds a license string to the module. The license string
 * determines symbol binding rules. For instance, a module released under
 * a non-GPL license can only bind to symbols exported by non-GPL modules,
 * but it can not bind to symbols provided by GPL modules. A module
 * released under a GPL license can bind to symbols exported by GPL and
 * non-GPL modules.
 *
 * \note This macro should only be used if you release your code under
 *       a license described by the predefined license strings such as
 *       VMK_MODULE_LICENSE_*, otherwise please use macro
 *       VMK_THIRD_PARTY_LICENSE_INFO.
 *
 * \param[in] string  A string to be embedded as the license type. Only
 *                    the predefined license strings such as
 *                    VMK_MODULE_LICENSE_* are acceptable. The use of
 *                    other license strings may cause the module to
 *                    fail to load.
 *
 ***********************************************************************
 */
#define VMK_LICENSE_INFO(string) \
   __VMK_LICENSE_INFO(string)

/*
 ***********************************************************************
 * VMK_THIRD_PARTY_LICENSE_INFO --                                */ /**
 *
 * \ingroup Module
 * \brief A string describing the license this module is released
 *        under.
 *
 * This macro adds a license string to the module. The license string
 * determines symbol binding rules. A module released under a third
 * party license can only bind to symbols exported by non-GPL modules.
 *
 * \note This macro should be used if you release your code under
 *       a license that is not covered by the predefined license strings
 *       such as VMK_MODULE_LICENSE_*, e.g., under your company's
 *       license.
 *
 * \note This macro accepts any provided string as a valid license
 *       string, in contrast to macro VMK_LICENSE_INFO which only
 *       accepts predefined license strings.
 *
 * \param[in] string  A string to be embedded as the license type. The
 *                    predefined license strings as VMK_MODULE_LICENSE_*
 *                    should not be used with this macro.
 *
 ***********************************************************************
 */
#define VMK_THIRD_PARTY_LICENSE_INFO(string) \
   __VMK_LICENSE_INFO(__VMK_MODULE_LICENSE_THIRD_PARTY ":" string)

/*
 ***********************************************************************
 * vmk_ModuleRegister --                                          */ /**
 *
 * \ingroup Module
 * \brief Register a module with the VMKernel
 *
 * \pre The module shall not call any VMKernel function before this
 *      function has been invoked and has returned.
 *
 * \note A module should make a successful call to this function only
 *       once inside its initalization function, else undefined
 *       behavior may occur.
 *
 * \note  This function may block.
 *
 * \param[out] id                The address of a variable to store
 *                               the module's module ID handle.
 * \param[in] vmkApiModRevision  The module version for compatability
 *                               checks.
 *
 ***********************************************************************
 */
VMK_ReturnStatus vmk_ModuleRegister(
   vmk_ModuleID *id,
   vmk_uint32 vmkApiModRevision);

/*
 ***********************************************************************
 * vmk_ModuleUnregister --                                        */ /**
 *
 * \ingroup Module
 * \brief Unregister a module with the VMKernel
 *
 * \pre The module shall not have any VMKernel call in progress at
 *      the time this function is invoked, nor initiate any VMKernel
 *      call after it has been invoked.
 *
 * \note The module ID handle will be invalid after the success of
 *       this call and should not be used again.
 *
 * \note  This function may block.
 *
 * \param[in] id  The module ID handle to unregister.
 *
 ***********************************************************************
 */
VMK_ReturnStatus vmk_ModuleUnregister(
   vmk_ModuleID id);

/*
 ***********************************************************************
 * vmk_ModuleSetHeapID --                                         */ /**
 *
 * \ingroup Module
 * \brief Set a module's default heap
 *
 * Any vmkapi call that does not take an explicit heap that also has
 * a side effect of allocating storage will use the heap passed to this
 * function.
 *
 * \note  This function will not block.
 *
 * \pre The default heap may only be assigned once.  Subsequent
 *      assignments will be ignored.
 *
 ***********************************************************************
 */
void vmk_ModuleSetHeapID(
   vmk_ModuleID module,
   vmk_HeapID heap);

/*
 ***********************************************************************
 * vmk_ModuleGetHeapID --                                         */ /**
 *
 * \ingroup Module
 * \brief Query a module's default heap
 *
 * \note  This function will not block.
 *
 * \return The calling module's current default heap.
 * \retval VMK_INVALID_HEAP_ID The module has no default heap.
 *
 ***********************************************************************
 */
vmk_HeapID vmk_ModuleGetHeapID(
   vmk_ModuleID module);

/*
 ***********************************************************************
 * vmk_ModuleGetID --                                             */ /**
 *
 * \ingroup Module
 * \brief Get the identifier of the VMKernel module
 *
 * \note  This function will not block.
 *
 * \param[in] moduleName   Name of the module to find.
 *
 * \return The module ID of the module with the specified name.
 * \retval VMK_INVALID_MODULE_ID    No module with the specified name
 *                                  was found.
 *
 ***********************************************************************
 */
vmk_ModuleID vmk_ModuleGetID(
   const char *moduleName);


/*
 ***********************************************************************
 * vmk_ModuleGetName --                                           */ /**
 *
 * \ingroup Module
 * \brief Get the name associated with a module.
 *
 * \note  This function will not block.
 *
 * \note This call will return an error when called to retrieve the
 *       name of a module that has not yet returned from the module
 *       init function.
 *
 * \param[in]  module      The module ID to query.
 * \param[out] moduleName  A character buffer large enough to hold the
 *                         module name including the terminating nul.
 * \param[in]  len         The length of the character buffer in bytes.
 *
 * \retval VMK_NOT_FOUND   The module ID was not found.
 * \retval VMK_BAD_PARAM   The buffer isn't large enough to hold
 *                         the module's string name.
 *
 ***********************************************************************
 */
VMK_ReturnStatus vmk_ModuleGetName(
   vmk_ModuleID module,
   char *moduleName,
   vmk_ByteCountSmall len);

/*
 ***********************************************************************
 * vmk_ModuleGetDebugID --                                        */ /**
 *
 * \ingroup Module
 * \brief Convert a vmk_ModuleID to a 64-bit integer representation.
 *        This should not be used be used for anything other than a
 *        short-hand in debugging output.
 *
 * \note  This function will not block.
 *
 * \param[in] module    The module id.
 *
 ***********************************************************************
 */
vmk_uint64 vmk_ModuleGetDebugID(vmk_ModuleID module);

/*
 ***********************************************************************
 * vmk_ModuleIncUseCount --                                       */ /**
 *
 * \ingroup Module
 * \brief Increment a module's reference count
 *
 * \note  This function will not block.
 *
 * Any attempt to remove the module with \c vmkload_mod -u will fail
 * while the module's reference count is non nul.
 *
 * \param[in] module    Module to increment the reference count for.
 *
 * \retval VMK_OK                   The reference count was successfully
 *                                  incremented
 * \retval VMK_NOT_FOUND            The module doesn't exist
 * \retval VMK_MODULE_NOT_LOADED    The module is being unloaded
 *
 ***********************************************************************
 */
VMK_ReturnStatus vmk_ModuleIncUseCount(
   vmk_ModuleID module);

/*
 ***********************************************************************
 * vmk_ModuleDecUseCount --                                       */ /**
 *
 * \ingroup Module
 * \brief Decrement a module's reference count.
 *
 * \note  This function will not block.
 *
 * \param[in] module    Module to decrement the reference count for.
 *
 * \retval VMK_OK                   The reference count was successfully
 *                                  decremented.
 * \retval VMK_NOT_FOUND            The module doesn't exist.
 * \retval VMK_MODULE_NOT_LOADED    The module is being unloaded.
 *
 ***********************************************************************
 */
VMK_ReturnStatus vmk_ModuleDecUseCount(
   vmk_ModuleID module);

/*
 ***********************************************************************
 * vmk_ModulePushId --                                            */ /**
 *
 * \ingroup Module
 * \brief Push moduleID onto module tracking stack before an
 *        inter-module call.
 *
 * \note  This function will not block.
 *
 * \deprecated This call should no longer be called directly as it is
 *             likely to go away in a future release.
 *
 * \param[in] moduleID     Module ID from which the inter-module call
 *                         is to be made.
 * \param[in] function     Address of the inter-module function call
 * \param[in] modStack     Pointer to a vmk_ModInfoStack struct,
 *                         preferrably on the stack.
 *
 * \retval VMK_OK                   The moduleID was sucessfully pushed
 *                                  onto the module stack
 * \retval VMK_MODULE_NOT_LOADED    Module was not found
 *
 ***********************************************************************
 */
VMK_ReturnStatus vmk_ModulePushId(
    vmk_ModuleID moduleID,
    void *function,
    vmk_ModInfoStack *modStack);

/*
 ***********************************************************************
 * vmk_ModulePopId --                                             */ /**
 *
 * \ingroup Module
 * \brief Pop moduleID off of module tracking stack after an
 *        inter-module call.
 *
 * \note  This function will not block.
 *
 * \deprecated This call should no longer be called directly as it is
 *             likely to go away in a future release.
 *
 ***********************************************************************
 */
void vmk_ModulePopId(void);

/*
 ***********************************************************************
 * vmk_ModuleStackTop --                                          */ /**
 *
 * \ingroup Module
 * \brief Get the latest moduleID pushed onto the module tracking stack.
 *
 * \note  This function will not block.
 *
 * \retval The moduleID at the top of the module tracking stack.
 *
 ***********************************************************************
 */
vmk_ModuleID vmk_ModuleStackTop(void);


/*
 ***********************************************************************
 * VMKAPI_MODULE_CALL --                                          */ /**
 *
 * \ingroup Module
 * \brief Macro wrapper for inter-module calls that return a value.
 *
 * This wrapper should always be used when calling into another module
 * so that vmkernel can properly track resources associated with
 * a call.
 *
 * \param[in]     moduleID       moduleID of the calling module.
 * \param[out]    returnValue    Variable to hold the return value from
 *                               the called function.
 * \param[in]     function       Inter-module function call to be
 *                               invoked.
 * \param[in,out] args           Arguments to pass to the inter-module
 *                               function call.
 *
 ***********************************************************************
 */
#define VMKAPI_MODULE_CALL(moduleID, returnValue, function, args...)    	\
do {                                                                    	\
    vmk_ModInfoStack modStack;						\
    vmk_ModulePushId(moduleID, function, &modStack) ;                   \
    VMK_DEBUG_ONLY(vmk_Bool intsEnabledOnEntry = vmk_CPUHasIntsEnabled();)      \
    returnValue = (function)(args);                                     	\
    VMK_DEBUG_ONLY(                                                             \
        if (intsEnabledOnEntry != vmk_CPUHasIntsEnabled()) {                    \
            vmk_Panic("Function %p in module %d %sabled interrupts",            \
                 function, moduleID, intsEnabledOnEntry ? "dis" : "en");        \
        }                                                                       \
    )                                                                           \
    vmk_ModulePopId();                                                  	\
} while(0)

/*
 ***********************************************************************
 * VMKAPI_MODULE_CALL_VOID --                                     */ /**
 *
 * \ingroup Module
 * \brief Macro wrapper for inter-module calls that do not return
 *        a value.
 *
 * This wrapper should always be used when calling into another module
 * so that vmkernel can properly track resources associated with
 * a call.
 *
 * \param[in]     moduleID    moduleID of the calling module
 * \param[in]     function    Inter-module function call to be invoked
 * \param[in,out] args        Arguments to pass to the inter-module
 *                            function call
 *
 ***********************************************************************
 */
#define VMKAPI_MODULE_CALL_VOID(moduleID, function, args...)    		\
do {                                                            		\
    vmk_ModInfoStack modStack;					\
    vmk_ModulePushId(moduleID, function, &modStack);            \
    VMK_DEBUG_ONLY(vmk_Bool intsEnabledOnEntry = vmk_CPUHasIntsEnabled();)      \
    (function)(args);                                           		\
    VMK_DEBUG_ONLY(                                                             \
        if (intsEnabledOnEntry != vmk_CPUHasIntsEnabled()) {                    \
            vmk_Panic("Function %p in module %d %sabled interrupts",            \
                 function, moduleID, intsEnabledOnEntry ? "dis" : "en");        \
        }                                                                       \
    )                                                                           \
    vmk_ModulePopId();                                          		\
} while(0)

/*
 ***********************************************************************
 * VMK_MODULE_EXPORT_SYMBOL --                                    */ /**
 *
 * \ingroup Module
 * \brief Mark a symbol as exported
 *
 * Mark the given symbol as exported (and hence available for other
 * modules to find/call) within the name-space and version of the
 * current module (as specified by VMK_NAMESPACE_PROVIDES())
 *
 * \note Although exported symbols are encapsulated within the modules
 * provided name-space, exported symbols are required to have a
 * globally unique name.  This is because there are no restrictions on
 * what combinations of name-spaces any given module may request,
 * leading to potential unresolvable collisions if a module requested
 * two name-spaces that provided the same symbol.
 *
 * \param[in] symname    The symbol to export.
 *
 ***********************************************************************
 */
#define VMK_MODULE_EXPORT_SYMBOL(symname)     \
   __VMK_MODULE_EXPORT_SYMBOL(symname)

/*
 ***********************************************************************
 * VMK_MODULE_EXPORT_SYMBOL_ALIASED --                            */ /**
 *
 * \ingroup Module
 * \brief Re-export a symbol under an aliased name
 *
 * Re-export the given original symbol "symname" as "alias" within the
 * name-space and version of the current module (as specified by
 * VMK_NAMESPACE_PROVIDES()).  "symname" must be either:
 *
 * - an internal global (i.e. not static) symbol of the current
 *   module, or
 * - be present by virtue of being exported by another module, and the
 *   current module must contain the correct VMK_NAMESPACE_REQUIRED()
 *   invocation such that the original symbol can be found.
 *
 * "alias" must be globally unqiue.
 *
 * \note Calls via this alias incur no overheads, as referencing the
 * alias results in the function address of the original symbol.
 *
 * \param[in] symname    The symbol to export.
 * \param[in] alias      The publicly exported name
 *
 ***********************************************************************
 */
#define VMK_MODULE_EXPORT_SYMBOL_ALIASED(symname, alias)    \
   __VMK_MODULE_EXPORT_SYMBOL_ALIASED(symname, alias)

/*
 ***********************************************************************
 * VMK_MODULE_EXPORT_ALIAS --                                     */ /**
 *
 * \ingroup Module
 * \brief Re-export an already exported symbol
 *
 * Re-export the given original symbol "symname" within the name-space
 * and version of the current module (as specified by
 * VMK_NAMESPACE_PROVIDES()).  The original symbol must be present by
 * virtue of being exported by another module, and the current module
 * must contain the correct VMK_NAMESPACE_REQUIRED() invocation such
 * that the original symbol can be found.
 *
 * \note Calls via this alias incur no overheads, as referencing the
 * alias results in the function address of the original symbol.
 *
 * \param[in] symname    The name of the original symbol to re-export
 *
 ***********************************************************************
 */
#define VMK_MODULE_EXPORT_ALIAS(symname) \
   __VMK_MODULE_EXPORT_SYMBOL_ALIASED(symname, symname)

/*
 ***********************************************************************
 * VMK_NAMESPACE_REQUIRED --                                      */ /**
 *
 * \ingroup Module
 * \brief Mark this module as requiring a name-space at a given version
 *
 * Mark the module as requiring a name-space "namespace" at "version".
 * There is no limit on the number of name-spaces a module may require.
 *
 * \note The namespace and version parameters may not contain the
 *       restricted character VMK_NS_VER_SEPARATOR. Including this
 *       character may cause the module to fail to load.
 *
 * \param[in] namespace  The name-space
 * \param[in] version    The version of this name-space
 *
 ***********************************************************************
 */
#define VMK_NAMESPACE_REQUIRED(namespace, version) \
   __VMK_NAMESPACE_REQUIRED(namespace, version)

/*
 ***********************************************************************
 * VMK_NAMESPACE_PROIVDES --                                      */ /**
 *
 * \ingroup Module
 * \brief Mark this module as providing a name-space at a given version
 *
 * Mark the module as providing a name-space "namespace" at "version".
 * Each module may provide only one name-space.
 *
 * \note The namespace and version parameters may not contain the
 *       restricted character VMK_NS_VER_SEPARATOR. Including this
 *       character may cause the module to fail to load.
 *
 * \param[in] namespace  The name-space
 * \param[in] version    The version of this name-space
 *
 ***********************************************************************
 */
#define VMK_NAMESPACE_PROVIDES(namespace, version) \
   __VMK_NAMESPACE_PROVIDES(namespace, version)

#endif /* _VMKAPI_MODULE_H_ */
/** @} */