# Copyright 1999-2022 Gentoo Authors
# Distributed under the terms of the GNU General Public License v2
# @ECLASS: linux-mod.eclass
# @MAINTAINER:
# kernel@gentoo.org
# @AUTHOR:
# John Mylchreest <johnm@gentoo.org>,
# Stefan Schweizer <genstef@gentoo.org>
# @SUPPORTED_EAPIS: 7 8
# @PROVIDES: linux-info
# @BLURB: It provides the functionality required to install external modules against a kernel source tree.
# @DESCRIPTION:
# This eclass is used to interface with linux-info.eclass in such a way
# to provide the functionality and initial functions
# required to install external modules against a kernel source
# tree.
# A Couple of env vars are available to effect usage of this eclass
# These are as follows:
# @ECLASS_VARIABLE: MODULES_OPTIONAL_USE
# @PRE_INHERIT
# @DEFAULT_UNSET
# @DESCRIPTION:
# A string containing the USE flag to use for making this eclass optional
# The recommended non-empty value is 'modules'
# @ECLASS_VARIABLE: MODULES_OPTIONAL_USE_IUSE_DEFAULT
# @PRE_INHERIT
# @DEFAULT_UNSET
# @DESCRIPTION:
# A boolean to control the IUSE default state for the MODULES_OPTIONAL_USE USE
# flag. Default value is unset (false). True represented by 1 or 'on', other
# values including unset treated as false.
# @ECLASS_VARIABLE: KERNEL_DIR
# @DESCRIPTION:
# A string containing the directory of the target kernel sources. The default value is
# "/usr/src/linux"
: ${ KERNEL_DIR : =/usr/src/linux }
# @ECLASS_VARIABLE: ECONF_PARAMS
# @DEFAULT_UNSET
# @DESCRIPTION:
# It's a string containing the parameters to pass to econf.
# If this is not set, then econf isn't run.
# @ECLASS_VARIABLE: BUILD_PARAMS
# @DEFAULT_UNSET
# @DESCRIPTION:
# It's a string with the parameters to pass to emake.
# @ECLASS_VARIABLE: BUILD_TARGETS
# @DESCRIPTION:
# It's a string with the build targets to pass to make. The default value is "clean module"
: ${ BUILD_TARGETS : =clean module }
# @ECLASS_VARIABLE: MODULE_NAMES
# @DEFAULT_UNSET
# @DESCRIPTION:
# It's a string containing the modules to be built automatically using the default
# src_compile/src_install. It will only make ${BUILD_TARGETS} once in any directory.
#
# The structure of each MODULE_NAMES entry is as follows:
#
# modulename(libdir:srcdir:objdir)
#
# where:
#
# modulename = name of the module file excluding the .ko
# libdir = place in system modules directory where module is installed (by default it's misc)
# srcdir = place for ebuild to cd to before running make (by default it's ${S})
# objdir = place the .ko and objects are located after make runs (by default it's set to srcdir)
#
# To get an idea of how these variables are used, here's a few lines
# of code from around line 540 in this eclass:
#
# einfo "Installing ${modulename} module"
# cd ${objdir} || die "${objdir} does not exist"
# insinto /lib/modules/${KV_FULL}/${libdir}
# doins ${modulename}.${KV_OBJ} || die "doins ${modulename}.${KV_OBJ} failed"
#
# For example:
# MODULE_NAMES="module_pci(pci:${S}/pci:${S}) module_usb(usb:${S}/usb:${S})"
#
# what this would do is
#
# cd "${S}"/pci
# make ${BUILD_PARAMS} ${BUILD_TARGETS}
# cd "${S}"
# insinto /lib/modules/${KV_FULL}/pci
# doins module_pci.${KV_OBJ}
#
# cd "${S}"/usb
# make ${BUILD_PARAMS} ${BUILD_TARGETS}
# cd "${S}"
# insinto /lib/modules/${KV_FULL}/usb
# doins module_usb.${KV_OBJ}
# There is also support for automated modprobe.d file generation.
# This can be explicitly enabled by setting any of the following variables.
# @ECLASS_VARIABLE: MODULESD_<modulename>_ENABLED
# @DEFAULT_UNSET
# @DESCRIPTION:
# This is used to disable the modprobe.d file generation otherwise the file will be
# always generated (unless no MODULESD_<modulename>_* variable is provided). Set to "no" to disable
# the generation of the file and the installation of the documentation.
# @ECLASS_VARIABLE: MODULESD_<modulename>_EXAMPLES
# @DEFAULT_UNSET
# @DESCRIPTION:
# This is a bash array containing a list of examples which should
# be used. If you want us to try and take a guess set this to "guess".
#
# For each array_component it's added an options line in the modprobe.d file
#
# options array_component
#
# where array_component is "<modulename> options" (see modprobe.conf(5))
# @ECLASS_VARIABLE: MODULESD_<modulename>_ALIASES
# @DEFAULT_UNSET
# @DESCRIPTION:
# This is a bash array containing a list of associated aliases.
#
# For each array_component it's added an alias line in the modprobe.d file
#
# alias array_component
#
# where array_component is "wildcard <modulename>" (see modprobe.conf(5))
# @ECLASS_VARIABLE: MODULESD_<modulename>_ADDITIONS
# @DEFAULT_UNSET
# @DESCRIPTION:
# This is a bash array containing a list of additional things to
# add to the bottom of the file. This can be absolutely anything.
# Each entry is a new line.
# @ECLASS_VARIABLE: MODULESD_<modulename>_DOCS
# @DEFAULT_UNSET
# @DESCRIPTION:
# This is a string list which contains the full path to any associated
# documents for <modulename>. These files are installed in the live tree.
# @ECLASS_VARIABLE: KV_OBJ
# @INTERNAL
# @DESCRIPTION:
# It's a read-only variable. It contains the extension of the kernel modules.
case ${ EAPI } in
7| 8) ; ;
*) die " ${ ECLASS } : EAPI ${ EAPI :- 0 } not supported " ; ;
esac
if [ [ -z ${ _LINUX_MOD_ECLASS } ] ] ; then
_LINUX_MOD_ECLASS = 1
# TODO: When adding support for future EAPIs, please audit this list
# for unused inherits and conditionalise them.
inherit linux-info multilib multiprocessing toolchain-funcs
case ${ MODULES_OPTIONAL_USE_IUSE_DEFAULT :- n } in
[ nNfF] *| [ oO] [ fF] *| 0| -) _modules_optional_use_iuse_default = '' ; ;
*) _modules_optional_use_iuse_default = '+' ; ;
esac
IUSE = " dist-kernel
${ MODULES_OPTIONAL_USE : + ${ _modules_optional_use_iuse_default } } ${ MODULES_OPTIONAL_USE } "
SLOT = "0"
RDEPEND = "
${ MODULES_OPTIONAL_USE } ${ MODULES_OPTIONAL_USE : +? ( }
kernel_linux? (
sys-apps/kmod[ tools]
dist-kernel? ( virtual/dist-kernel:= )
)
${ MODULES_OPTIONAL_USE : +) } "
DEPEND = " ${ RDEPEND }
${ MODULES_OPTIONAL_USE } ${ MODULES_OPTIONAL_USE : +? ( }
kernel_linux? ( virtual/linux-sources virtual/libelf )
${ MODULES_OPTIONAL_USE : +) } "
# eclass utilities
# ----------------------------------
# @FUNCTION: use_m
# @RETURN: true or false
# @DESCRIPTION:
# It checks if the kernel version is greater than 2.6.5.
use_m( ) {
debug-print-function ${ FUNCNAME } $*
# If we haven't determined the version yet, we need to.
get_version
# If the kernel version is greater than 2.6.6 then we should use
# M= instead of SUBDIRS=
[ [ ${ KV_MAJOR } -ge 3 ] ] && return 0
[ [ ${ KV_MAJOR } -eq 2 && ${ KV_MINOR } -gt 5 && ${ KV_PATCH } -gt 5 ] ]
}
# @FUNCTION: convert_to_m
# @USAGE: </path/to/the/file>
# @DESCRIPTION:
# It converts a file (e.g. a makefile) to use M= instead of SUBDIRS=
convert_to_m( ) {
debug-print-function ${ FUNCNAME } $*
if use_m; then
[ [ ! -f " ${ 1 } " ] ] && \
die "convert_to_m() requires a filename as an argument"
ebegin " Converting ${ 1 / ${ WORKDIR } \/ / } to use M= instead of SUBDIRS= "
sed -i 's:SUBDIRS=:M=:g' " ${ 1 } "
eend $?
fi
}
# @FUNCTION: update_depmod
# @INTERNAL
# @DESCRIPTION:
# Updates the modules.dep file for the current kernel.
update_depmod( ) {
debug-print-function ${ FUNCNAME } $*
# If we haven't determined the version yet, we need to.
get_version
ebegin " Updating module dependencies for ${ KV_FULL } "
if [ [ -r " ${ KV_OUT_DIR } " /System.map ] ] ; then
depmod -ae -F " ${ KV_OUT_DIR } " /System.map -b " ${ ROOT :- / } " ${ KV_FULL }
eend $?
else
ewarn
ewarn " ${ KV_OUT_DIR } /System.map not found. "
ewarn "You must manually update the kernel module dependencies using depmod."
eend 1
ewarn
fi
}
# @FUNCTION: move_old_moduledb
# @INTERNAL
# @DESCRIPTION:
# Updates the location of the database used by the module-rebuild utility.
move_old_moduledb( ) {
debug-print-function ${ FUNCNAME } $*
local OLDDIR = " ${ ROOT } " /usr/share/module-rebuild
local NEWDIR = " ${ ROOT } " /var/lib/module-rebuild
if [ [ -f " ${ OLDDIR } " /moduledb ] ] ; then
[ [ ! -d " ${ NEWDIR } " ] ] && mkdir -p " ${ NEWDIR } "
[ [ ! -f " ${ NEWDIR } " /moduledb ] ] && \
mv " ${ OLDDIR } " /moduledb " ${ NEWDIR } " /moduledb
rm -f " ${ OLDDIR } " /*
rmdir " ${ OLDDIR } "
fi
}
# @FUNCTION: update_moduledb
# @DESCRIPTION:
# Adds the package to the /var/lib/module-rebuild/moduledb database used by the module-rebuild utility.
update_moduledb( ) {
debug-print-function ${ FUNCNAME } $*
local MODULEDB_DIR = " ${ ROOT } " /var/lib/module-rebuild
move_old_moduledb
if [ [ ! -f " ${ MODULEDB_DIR } " /moduledb ] ] ; then
[ [ ! -d " ${ MODULEDB_DIR } " ] ] && mkdir -p " ${ MODULEDB_DIR } "
touch " ${ MODULEDB_DIR } " /moduledb
fi
if ! grep -qs ${ CATEGORY } /${ PN } -${ PVR } " ${ MODULEDB_DIR } " /moduledb ; then
einfo "Adding module to moduledb."
echo " a:1: ${ CATEGORY } / ${ PN } - ${ PVR } " >> " ${ MODULEDB_DIR } " /moduledb
fi
}
# @FUNCTION: remove_moduledb
# @DESCRIPTION:
# Removes the package from the /var/lib/module-rebuild/moduledb database used by
remove_moduledb( ) {
debug-print-function ${ FUNCNAME } $*
local MODULEDB_DIR = " ${ ROOT } " /var/lib/module-rebuild
move_old_moduledb
if grep -qs ${ CATEGORY } /${ PN } -${ PVR } " ${ MODULEDB_DIR } " /moduledb ; then
einfo " Removing ${ CATEGORY } / ${ PN } - ${ PVR } from moduledb. "
sed -i -e " /.* ${ CATEGORY } \/ ${ PN } - ${ PVR } .*/d " " ${ MODULEDB_DIR } " /moduledb
fi
}
# @FUNCTION: set_kvobj
# @DESCRIPTION:
# It sets the KV_OBJ variable.
set_kvobj( ) {
debug-print-function ${ FUNCNAME } $*
if kernel_is ge 2 6; then
KV_OBJ = "ko"
else
KV_OBJ = "o"
fi
# Do we really need to know this?
# Let's silence it.
#einfo "Using KV_OBJ=${KV_OBJ}"
}
# @FUNCTION: get-KERNEL_CC
# @RETURN: Name of the C compiler.
# @DESCRIPTION:
# Return name of the C compiler while honoring variables defined in ebuilds.
get-KERNEL_CC( ) {
debug-print-function ${ FUNCNAME } $*
if [ [ -n ${ KERNEL_CC } ] ] ; then
echo " ${ KERNEL_CC } "
return
fi
local kernel_cc
if [ [ -n " ${ KERNEL_ABI } " ] ] ; then
# In future, an arch might want to define CC_$ABI
#kernel_cc="$(get_abi_CC)"
#[ -z "${kernel_cc}" ] &&
kernel_cc = " $( tc-getCC $( ABI = ${ KERNEL_ABI } get_abi_CHOST) ) "
else
kernel_cc = $( tc-getCC)
fi
echo " ${ kernel_cc } "
}
# @FUNCTION: generate_modulesd
# @INTERNAL
# @USAGE: /path/to/the/modulename_without_extension
# @RETURN: A file in /etc/modprobe.d
# @DESCRIPTION:
# This function will generate and install the neccessary modprobe.d file from the
# information contained in the modules exported parms.
# (see the variables MODULESD_<modulename>_ENABLED, MODULESD_<modulename>_EXAMPLES,
# MODULESD_<modulename>_ALIASES, MODULESD_<modulename>_ADDITION and MODULESD_<modulename>_DOCS).
#
# At the end the documentation specified with MODULESD_<modulename>_DOCS is installed.
generate_modulesd( ) {
debug-print-function ${ FUNCNAME } $*
[ [ -n " ${ MODULES_OPTIONAL_USE } " ] ] && use !${ MODULES_OPTIONAL_USE } && return
local currm_path currm currm_t t myIFS myVAR
local module_docs module_enabled module_aliases \
module_additions module_examples module_modinfo module_opts
for currm_path in ${ @ } ; do
currm = ${ currm_path //* \/ }
currm = $( echo ${ currm } | tr '[:lower:]' '[:upper:]' )
currm_t = ${ currm }
while [ [ -z ${ currm_t //*-* } ] ] ; do
currm_t = ${ currm_t /-/_ }
done
module_docs = " $( eval echo \$ { MODULESD_${ currm_t } _DOCS} ) "
module_enabled = " $( eval echo \$ { MODULESD_${ currm_t } _ENABLED} ) "
module_aliases = " $( eval echo \$ { #MODULESD_${currm_t}_ALIASES[*]})"
module_additions = " $( eval echo \$ { #MODULESD_${currm_t}_ADDITIONS[*]})"
module_examples = " $( eval echo \$ { #MODULESD_${currm_t}_EXAMPLES[*]})"
[ [ ${ module_aliases } -eq 0 ] ] && unset module_aliases
[ [ ${ module_additions } -eq 0 ] ] && unset module_additions
[ [ ${ module_examples } -eq 0 ] ] && unset module_examples
# If we specify we dont want it, then lets exit, otherwise we assume
# that if its set, we do want it.
[ [ ${ module_enabled } = = no ] ] && return 0
# unset any unwanted variables.
for t in ${ !module_* } ; do
[ [ -z ${ !t } ] ] && unset ${ t }
done
[ [ -z ${ !module_* } ] ] && return 0
# OK so now if we have got this far, then we know we want to continue
# and generate the modprobe.d file.
module_modinfo = " $( modinfo -p ${ currm_path } .${ KV_OBJ } ) "
module_config = " ${ T } /modulesd- ${ currm } "
ebegin "Preparing file for modprobe.d"
#-----------------------------------------------------------------------
echo " # modprobe.d configuration file for ${ currm } " >> " ${ module_config } "
#-----------------------------------------------------------------------
[ [ -n ${ module_docs } ] ] && \
echo "# For more information please read:" >> " ${ module_config } "
for t in ${ module_docs }
do
echo " # ${ t //* \/ } " >> " ${ module_config } "
done
echo >> " ${ module_config } "
#-----------------------------------------------------------------------
if [ [ ${ module_aliases } -gt 0 ] ]
then
echo "# Internal Aliases - Do not edit" >> " ${ module_config } "
echo "# ------------------------------" >> " ${ module_config } "
for ( ( t = 0; t<${ module_aliases } ; t++) )
do
echo " alias $( eval echo \$ { MODULESD_${ currm_t } _ALIASES[ $t ] } ) " \
>> " ${ module_config } "
done
echo '' >> " ${ module_config } "
fi
#-----------------------------------------------------------------------
if [ [ -n ${ module_modinfo } ] ] ; then
echo >> " ${ module_config } "
echo "# Configurable module parameters" >> " ${ module_config } "
echo "# ------------------------------" >> " ${ module_config } "
myIFS = " ${ IFS } "
IFS = " $( echo -en "\n\b" ) "
for t in ${ module_modinfo } ; do
myVAR = " $( echo ${ t #* : } | grep -o "[^ ]*[0-9][ =][^ ]*" | tail -1 | grep -o "[0-9]" ) "
if [ [ -n ${ myVAR } ] ] ; then
module_opts = " ${ module_opts } ${ t %% : * } : ${ myVAR } "
fi
echo -e " # ${ t %% : * } :\t ${ t #* : } " >> " ${ module_config } "
done
IFS = " ${ myIFS } "
echo '' >> " ${ module_config } "
fi
#-----------------------------------------------------------------------
if [ [ $( eval echo \$ { MODULESD_${ currm_t } _ALIASES[ 0] } ) = = guess ] ] ; then
# So, let's do some guesswork, eh?
if [ [ -n ${ module_opts } ] ] ; then
echo "# For Example..." >> " ${ module_config } "
echo "# --------------" >> " ${ module_config } "
for t in ${ module_opts }
do
echo " # options ${ currm } ${ t // : * } = ${ t //* : } " >> " ${ module_config } "
done
echo '' >> " ${ module_config } "
fi
elif [ [ ${ module_examples } -gt 0 ] ] ; then
echo "# For Example..." >> " ${ module_config } "
echo "# --------------" >> " ${ module_config } "
for ( ( t = 0; t<${ module_examples } ; t++) ) ; do
echo " options $( eval echo \$ { MODULESD_${ currm_t } _EXAMPLES[ $t ] } ) " \
>> " ${ module_config } "
done
echo '' >> " ${ module_config } "
fi
#-----------------------------------------------------------------------
if [ [ ${ module_additions } -gt 0 ] ] ; then
for ( ( t = 0; t<${ module_additions } ; t++) ) ; do
echo " $( eval echo \$ { MODULESD_${ currm_t } _ADDITIONS[ $t ] } ) " \
>> " ${ module_config } "
done
echo '' >> " ${ module_config } "
fi
#-----------------------------------------------------------------------
# then we install it
insinto /etc/modprobe.d
newins " ${ module_config } " " ${ currm_path //* \/ } .conf "
# and install any documentation we might have.
[ [ -n ${ module_docs } ] ] && dodoc ${ module_docs }
done
eend 0
return 0
}
# @FUNCTION: find_module_params
# @USAGE: A string "NAME(LIBDIR:SRCDIR:OBJDIR)"
# @INTERNAL
# @RETURN: The string "modulename:NAME libdir:LIBDIR srcdir:SRCDIR objdir:OBJDIR"
# @DESCRIPTION:
# Analyze the specification NAME(LIBDIR:SRCDIR:OBJDIR) of one module as described in MODULE_NAMES.
find_module_params( ) {
debug-print-function ${ FUNCNAME } $*
local matched_offset = 0 matched_opts = 0 test = " ${ @ } " temp_var result
local i = 0 y = 0 z = 0
for ( ( i = 0; i<= ${# test } ; i++) ) ; do
case ${ test : ${ i } : 1 } in
\( ) matched_offset[ 0] = ${ i } ; ;
\: ) matched_opts = $(( ${ matched_opts } + 1 )) ;
matched_offset[ ${ matched_opts } ] = " ${ i } " ; ;
\) ) matched_opts = $(( ${ matched_opts } + 1 )) ;
matched_offset[ ${ matched_opts } ] = " ${ i } " ; ;
esac
done
for ( ( i = 0; i<= ${ matched_opts } ; i++) ) ; do
# i = offset were working on
# y = last offset
# z = current offset - last offset
# temp_var = temporary name
case ${ i } in
0) tempvar = ${ test : 0 : ${ matched_offset [0] } } ; ;
*) y = $(( ${ matched_offset [ $(( ${ i } - 1 )) ] } + 1 ))
z = $(( ${ matched_offset [ ${ i } ] } - ${ matched_offset [ $(( ${ i } - 1 )) ] } )) ;
z = $(( ${ z } - 1 ))
tempvar = ${ test : ${ y } : ${ z } } ; ;
esac
case ${ i } in
0) result = " ${ result } modulename: ${ tempvar } " ; ;
1) result = " ${ result } libdir: ${ tempvar } " ; ;
2) result = " ${ result } srcdir: ${ tempvar } " ; ;
3) result = " ${ result } objdir: ${ tempvar } " ; ;
esac
done
echo ${ result }
}
# default ebuild functions
# --------------------------------
# @FUNCTION: linux-mod_pkg_setup
# @DESCRIPTION:
# It checks the CONFIG_CHECK options (see linux-info.eclass(5)), verifies that the kernel is
# configured, verifies that the sources are prepared, verifies that the modules support is builtin
# in the kernel and sets the object extension KV_OBJ.
linux-mod_pkg_setup( ) {
debug-print-function ${ FUNCNAME } $*
[ [ -n " ${ MODULES_OPTIONAL_USE } " ] ] && use !${ MODULES_OPTIONAL_USE } && return
local is_bin = " ${ MERGE_TYPE } "
# If we are installing a binpkg, take a different path.
if [ [ ${ is_bin } = = binary ] ] ; then
linux-mod_pkg_setup_binary
return
fi
# External modules use kernel symbols (bug #591832)
CONFIG_CHECK += " !TRIM_UNUSED_KSYMS"
linux-info_pkg_setup
require_configured_kernel
check_kernel_built
strip_modulenames
[ [ -n ${ MODULE_NAMES } ] ] && check_modules_supported
set_kvobj
}
# @FUNCTION: linux-mod_pkg_setup_binary
# @DESCRIPTION:
# Perform all kernel option checks non-fatally, as the .config and
# /proc/config.gz might not be present. Do not do anything that requires kernel
# sources.
linux-mod_pkg_setup_binary( ) {
debug-print-function ${ FUNCNAME } $*
local new_CONFIG_CHECK
# ~ needs always to be quoted, else bash expands it.
for config in ${ CONFIG_CHECK } ; do
optional = '~'
[ [ ${ config : 0 : 1 } = = "~" ] ] && optional = ''
new_CONFIG_CHECK = " ${ new_CONFIG_CHECK } ${ optional } ${ config } "
done
CONFIG_CHECK = " ${ new_CONFIG_CHECK } "
linux-info_pkg_setup
}
# @FUNCTION: strip_modulenames
# @DESCRIPTION:
# Remove modules from being built automatically using the default src_compile/src_install
strip_modulenames( ) {
debug-print-function ${ FUNCNAME } $*
local i
for i in ${ MODULE_IGNORE } ; do
MODULE_NAMES = ${ MODULE_NAMES // ${ i } (* }
done
}
# @FUNCTION: linux-mod_src_compile
# @DESCRIPTION:
# It compiles all the modules specified in MODULE_NAMES. For each module the econf command is
# executed only if ECONF_PARAMS is defined, the name of the target is specified by BUILD_TARGETS
# while the options are in BUILD_PARAMS (all the modules share these variables). The compilation
# happens inside ${srcdir}.
#
# Look at the description of these variables for more details.
linux-mod_src_compile( ) {
debug-print-function ${ FUNCNAME } $*
[ [ -n " ${ MODULES_OPTIONAL_USE } " ] ] && use !${ MODULES_OPTIONAL_USE } && return
local modulename libdir srcdir objdir i n myABI = " ${ ABI } "
set_arch_to_kernel
ABI = " ${ KERNEL_ABI } "
[ [ -n ${ KERNEL_DIR } ] ] && addpredict " ${ KERNEL_DIR } /null.dwo "
# Set CROSS_COMPILE in the environment.
# This allows it to be overridden in local Makefiles.
# https://bugs.gentoo.org/550428
local -x CROSS_COMPILE = ${ CROSS_COMPILE - ${ CHOST } - }
BUILD_TARGETS = ${ BUILD_TARGETS :- clean module }
strip_modulenames
cd " ${ S } " || die
touch Module.symvers || die
for i in ${ MODULE_NAMES } ; do
unset libdir srcdir objdir
for n in $( find_module_params ${ i } ) ; do
eval ${ n / : * } = ${ n /* : / }
done
libdir = ${ libdir :- misc }
srcdir = ${ srcdir :- ${ S } }
objdir = ${ objdir :- ${ srcdir } }
if [ [ ! -f " ${ srcdir } /.built " ] ] ; then
cd " ${ srcdir } " || die
ln -s " ${ S } " /Module.symvers Module.symvers # no die for bug #888679
einfo " Preparing ${ modulename } module "
if [ [ -n ${ ECONF_PARAMS } ] ] ; then
eqawarn "This package relies on the deprecated functionality of econf being called in linux-mod_src_compile (ECONF_PARAMS), which will go away in 30 days (20230107) (https://bugs.gentoo.org/340597)"
econf ${ ECONF_PARAMS }
fi
# This looks messy, but it is needed to handle multiple variables
# being passed in the BUILD_* stuff where the variables also have
# spaces that must be preserved. If don't do this, then the stuff
# inside the variables gets used as targets for Make, which then
# fails.
eval " emake HOSTCC=\" $( tc-getBUILD_CC) \" \
LDFLAGS = \" $( get_abi_LDFLAGS) \" \
${ BUILD_FIXES } \
${ BUILD_PARAMS } \
${ BUILD_TARGETS } " \
|| die "Unable to emake HOSTCC=" $( tc-getBUILD_CC) " LDFLAGS=" $( get_abi_LDFLAGS) " ${ BUILD_FIXES } ${ BUILD_PARAMS } ${ BUILD_TARGETS } "
cd " ${ OLDPWD } " || die
touch " ${ srcdir } " /.built || die
fi
done
set_arch_to_pkgmgr
ABI = " ${ myABI } "
}
# @FUNCTION: linux-mod_src_install
# @DESCRIPTION:
# It install the modules specified in MODULE_NAMES. The modules should be inside the ${objdir}
# directory and they are installed inside /lib/modules/${KV_FULL}/${libdir}.
#
# The modprobe.d configuration file is automatically generated if the
# MODULESD_<modulename>_* variables are defined. The only way to stop this process is by
# setting MODULESD_<modulename>_ENABLED=no. At the end the documentation specified via
# MODULESD_<modulename>_DOCS is also installed.
#
# Look at the description of these variables for more details.
linux-mod_src_install( ) {
debug-print-function ${ FUNCNAME } $*
[ [ -n " ${ MODULES_OPTIONAL_USE } " ] ] && use !${ MODULES_OPTIONAL_USE } && return
local modulename libdir srcdir objdir i n
[ [ -n ${ KERNEL_DIR } ] ] && addpredict " ${ KERNEL_DIR } /null.dwo "
strip_modulenames
for i in ${ MODULE_NAMES } ; do
unset libdir srcdir objdir
for n in $( find_module_params ${ i } ) ; do
eval ${ n / : * } = ${ n /* : / }
done
libdir = ${ libdir :- misc }
srcdir = ${ srcdir :- ${ S } }
objdir = ${ objdir :- ${ srcdir } }
einfo " Installing ${ modulename } module "
cd " ${ objdir } " || die " ${ objdir } does not exist "
insinto " ${ INSTALL_MOD_PATH } " /lib/modules/${ KV_FULL } /${ libdir }
# check here for CONFIG_MODULE_COMPRESS_<compression option> (NONE, GZIP, XZ, ZSTD)
# and similarily compress the module being built if != NONE.
if linux_chkconfig_present MODULE_COMPRESS_XZ; then
xz -T$( makeopts_jobs) --memlimit-compress= 50% -q ${ modulename } .${ KV_OBJ } || die " Compressing ${ modulename } . ${ KV_OBJ } with xz failed "
doins ${ modulename } .${ KV_OBJ } .xz
elif linux_chkconfig_present MODULE_COMPRESS_GZIP; then
if type -P pigz & >/dev/null ; then
pigz -p$( makeopts_jobs) ${ modulename } .${ KV_OBJ } || die " Compressing ${ modulename } . ${ KV_OBJ } with pigz failed "
else
gzip ${ modulename } .${ KV_OBJ } || die " Compressing ${ modulename } . ${ KV_OBJ } with gzip failed "
fi
doins ${ modulename } .${ KV_OBJ } .gz
elif linux_chkconfig_present MODULE_COMPRESS_ZSTD; then
zstd -T$( makeopts_jobs) ${ modulename } .${ KV_OBJ } || " Compressing ${ modulename } . ${ KV_OBJ } with zstd failed "
doins ${ modulename } .${ KV_OBJ } .zst
else
doins ${ modulename } .${ KV_OBJ }
fi
cd " ${ OLDPWD } " || die " ${ OLDPWD } does not exist "
generate_modulesd " ${ objdir } / ${ modulename } "
done
}
# @FUNCTION: linux-mod_pkg_preinst
# @DESCRIPTION:
# It checks what to do after having merged the package.
linux-mod_pkg_preinst( ) {
debug-print-function ${ FUNCNAME } $*
[ [ -n ${ MODULES_OPTIONAL_USE } ] ] && use !${ MODULES_OPTIONAL_USE } && return
[ [ -d ${ D } /lib/modules ] ] && UPDATE_DEPMOD = true || UPDATE_DEPMOD = false
[ [ -d ${ D } /lib/modules ] ] && UPDATE_MODULEDB = true || UPDATE_MODULEDB = false
}
# @FUNCTION: linux-mod_pkg_postinst
# @DESCRIPTION:
# It executes /sbin/depmod and adds the package to the /var/lib/module-rebuild/moduledb
# database (if ${D}/lib/modules is created)
linux-mod_pkg_postinst( ) {
debug-print-function ${ FUNCNAME } $*
[ [ -n " ${ MODULES_OPTIONAL_USE } " ] ] && use !${ MODULES_OPTIONAL_USE } && return
${ UPDATE_DEPMOD } && update_depmod
${ UPDATE_MODULEDB } && update_moduledb
}
# @FUNCTION: linux-mod_pkg_postrm
# @DESCRIPTION:
# It removes the package from the /var/lib/module-rebuild/moduledb database but it doens't
# call /sbin/depmod because the modules are still installed.
linux-mod_pkg_postrm( ) {
debug-print-function ${ FUNCNAME } $*
[ [ -n " ${ MODULES_OPTIONAL_USE } " ] ] && use !${ MODULES_OPTIONAL_USE } && return
remove_moduledb
}
fi
EXPORT_FUNCTIONS pkg_setup src_compile src_install \
pkg_preinst pkg_postinst pkg_postrm