%PDF- %PDF-
Server IP : 79.170.40.229 / Your IP : 3.137.161.132 Web Server : Apache System : Linux web232.extendcp.co.uk 4.18.0-513.24.1.el8_9.x86_64 #1 SMP Mon Apr 8 11:23:13 EDT 2024 x86_64 User : 1stforcarhirealicante.com ( 296923) PHP Version : 5.6.40 Disable Function : NONE MySQL : ON | cURL : ON | WGET : ON | Perl : ON | Python : ON | Sudo : ON | Pkexec : ON Directory : /proc/thread-self/root/etc/rc3.d/ |
Upload File : |
#!/bin/sh ############################################################################### # # Dell Inc. PROPRIETARY INFORMATION # This software is supplied under the terms of a license agreement or # nondisclosure agreement with Dell Inc. and may not # be copied or disclosed except in accordance with the terms of that # agreement. # # Copyright (c) 2000-2011 Dell Inc. All Rights Reserved. # # Module Name: # # instsvcdrv # # Abstract/Purpose: # # Systems Management Device Drivers init script # # Environment: # # Linux # # Notes: # # dcdbas needs to remain started at runlevel 0 for host control. # dell_rbu needs to remain started at runlevel 6 for BIOS Update. # # Following two lines used by chkconfig utility: # chkconfig: 35 95 05 # description: Systems Management Device Drivers # ### BEGIN INIT INFO # Provides: instsvcdrv # Required-Start: $localfs $remotefs $syslog # Required-Stop: $localfs $remotefs $syslog # Default-Start: 0 3 5 6 # Default-Stop: 1 2 # Short-Description: Systems Management Device Drivers # Description: Systems Management Device Drivers ### END INIT INFO # ############################################################################### ISVCDD_PROD_NAME="Systems Management Device Drivers" ISVCDD_SCRIPT_NAME="instsvcdrv" ISVCDD_DEFAULT_INSTALL_DIR="/opt/dell/srvadmin" ISVCDD_DEFAULT_VARDATA_DIR="/opt/dell/srvadmin/var/lib/openmanage" # Flag to turn on verbose logging VERBOSE_LOGGING=false VERBOSE_TARGET=/dev/stderr # OS information OS_DEVICE_DIR="/dev" OS_INITSCRIPT_DIR="/etc/rc.d/init.d/" OS_MODULES_DIR="/lib/modules" OS_VARLOG_DIR="/opt/dell/srvadmin/var/log" OS_SCRIPT_FUNCTIONS_LSB="/lib/lsb/init-functions" OS_SCRIPT_FUNCTIONS_RH="/etc/init.d/functions" OS_SCRIPT_FUNCTIONS_NONE="none" # Check for supported OS script functions if [ -f ${OS_SCRIPT_FUNCTIONS_RH} ]; then OS_SCRIPT_FUNCTIONS=${OS_SCRIPT_FUNCTIONS_RH} elif [ -f ${OS_SCRIPT_FUNCTIONS_LSB} ]; then OS_SCRIPT_FUNCTIONS=${OS_SCRIPT_FUNCTIONS_LSB} else OS_SCRIPT_FUNCTIONS=${OS_SCRIPT_FUNCTIONS_NONE} fi # Include OS script functions if available if [ ${OS_SCRIPT_FUNCTIONS} != ${OS_SCRIPT_FUNCTIONS_NONE} ]; then . ${OS_SCRIPT_FUNCTIONS} fi # Make sure standard bin directories are in path PATH="${PATH}:/sbin:/usr/sbin:/bin:/usr/bin" # Make sure HOSTTYPE is set [ -z "${HOSTTYPE}" ] && HOSTTYPE=$(uname -m) # Get running kernel RUNNING_KERNEL=$(uname -r) # HAPI config file and variables HAPICFG_PATHFILENAME="/etc/hapi.cfg" HAPICFG_PROJECT_NAME_HAPI="hapi" HAPICFG_HAPI_LOADDRIVERS_KEY="${HAPICFG_PROJECT_NAME_HAPI}.loaddrivers" HAPICFG_HAPI_LOADDBAS_KEY="${HAPICFG_PROJECT_NAME_HAPI}.loaddbas" HAPICFG_HAPI_LOADDRBU_KEY="${HAPICFG_PROJECT_NAME_HAPI}.loaddrbu" HAPICFG_HAPI_FORCEKERMATCH_KEY="${HAPICFG_PROJECT_NAME_HAPI}.forcekernelmatch" HAPICFG_HAPI_OI_INITFAIL_OK_KEY="${HAPICFG_PROJECT_NAME_HAPI}.allow.user.mode" HAPICFG_HAPI_OI_LOAD="${HAPICFG_PROJECT_NAME_HAPI}.loadopenipmi" # Supported values for "loaddrivers" variable HAPICFG_HAPI_LOADDRIVERS_ACTIVE="active" HAPICFG_HAPI_LOADDRIVERS_ALL="all" HAPICFG_HAPI_LOADDRIVERS_BASEONLY="baseonly" HAPICFG_HAPI_LOADDRIVERS_NONE="none" HAPICFG_HAPI_LOADDRIVERS_SELECTED="selected" # omreg config file variables OMREG_PATHFILENAME="/opt/dell/srvadmin/etc/omreg.cfg" OMREG_PROJECT_NAME_HAPI="hapi" OMREG_HAPI_INSTALLPATH_KEY="${OMREG_PROJECT_NAME_HAPI}.installpath" OMREG_HAPI_INIPATH_KEY="${OMREG_PROJECT_NAME_HAPI}.inipath" OMREG_HAPI_VARDATAPATH_KEY="${OMREG_PROJECT_NAME_HAPI}.vardatapath" # OpenIPMI-specific variables OPENIPMI_SCRIPT="${OS_INITSCRIPT_DIR}/ipmi" if [ ! -f "${OPENIPMI_SCRIPT}" ]; then OPENIPMI_SCRIPT="${OS_INITSCRIPT_DIR}/dsm_sa_ipmi" if [ ! -f "${OPENIPMI_SCRIPT}" ]; then OPENIPMI_SCRIPT= fi fi OPENIPMI_DSM_SCRIPT="${OS_INITSCRIPT_DIR}/dsm_sa_ipmi" OPENIPMI_FILEVER="ipmi_msghandler" OPENIPMI_GETVER_MOD="modinfo ${OPENIPMI_FILEVER}" OPENIPMI_GETVER_FILE="/lib/modules/${RUNNING_KERNEL}/kernel/drivers/char/ipmi/${OPENIPMI_FILEVER}" OPENIPMI_DEVNODE="/dev/ipmi0" OPENIPMI_SI_MODULE="ipmi_si" OPENIPMI_FORCE_KIPMID_OPTION="force_kipmid" OPENIPMI_KIPMID_MAX_BUSY_US_OPTION="kipmid_max_busy_us" OPENIPMI_KIPMID_MAX_BUSY_US_OPTION_FILE="/sys/module/ipmi_si/parameters/kipmid_max_busy_us" DEV_IPMI_TIMEOUT=15 OPENIPMI_IPMI_STATS_FILE="/proc/ipmi/0/si_stats" OPENIPMI_DISPLAY_NAME="ipmi driver" OPENIPMI_INITFAIL_OK_MSG="(override enabled)" OPENIPMI_RHEL3_VERMAJ_DEFAULT=35 OPENIPMI_RHEL3_VERMIN_DEFAULT=12 OPENIPMI_RHEL4_VERMAJ_DEFAULT=33 OPENIPMI_RHEL4_VERMIN_DEFAULT=12 OPENIPMI_SLES9_VERMAJ_DEFAULT=36 OPENIPMI_SLES9_VERMIN_DEFAULT=7 OPENIPMI_KERNEL_VERMAJ_DEFAULT=2 OPENIPMI_KERNEL_VERMIN_DEFAULT=6 OPENIPMI_KERNEL_VERPCH_DEFAULT=15 OPENIPMI_RHEL3_VERMAJ_CONFIG_KEY="openmanage.openipmi.rhel3.ver_min_major" OPENIPMI_RHEL3_VERMIN_CONFIG_KEY="openmanage.openipmi.rhel3.ver_min_minor" OPENIPMI_RHEL4_VERMAJ_CONFIG_KEY="openmanage.openipmi.rhel4.ver_min_major" OPENIPMI_RHEL4_VERMIN_CONFIG_KEY="openmanage.openipmi.rhel4.ver_min_minor" OPENIPMI_SLES9_VERMAJ_CONFIG_KEY="openmanage.openipmi.sles9.ver_min_major" OPENIPMI_SLES9_VERMIN_CONFIG_KEY="openmanage.openipmi.sles9.ver_min_minor" OPENIPMI_KERNEL_VERMAJ_CONFIG_KEY="openmanage.openipmi.kernel.ver_min_major" OPENIPMI_KERNEL_VERMIN_CONFIG_KEY="openmanage.openipmi.kernel.ver_min_minor" OPENIPMI_KERNEL_VERPCH_CONFIG_KEY="openmanage.openipmi.kernel.ver_min_patch" # if omreg.cfg doesnt exist bug our fragment does, recreate it if [ ! -f ${OMREG_PATHFILENAME} -a -f /opt/dell/srvadmin/etc/omreg.d/omreg-hapi.cfg ] then cat /opt/dell/srvadmin/etc/omreg.d/*.cfg > /opt/dell/srvadmin/etc/omreg.cfg 2>/dev/null ||: fi # Determine install and variable data paths if [ -f ${OMREG_PATHFILENAME} ]; then # Get install path from omreg config file ISVCDD_INSTALLPATH=$( grep "^${OMREG_HAPI_INSTALLPATH_KEY}=" ${OMREG_PATHFILENAME} | sed "s/^${OMREG_HAPI_INSTALLPATH_KEY}=//") if [ -z "${ISVCDD_INSTALLPATH}" ]; then echo "Unable to get install path from file: ${OMREG_PATHFILENAME}" exit 1 fi # Get ini path from omreg config file ISVCDD_INIPATH=$( grep "^${OMREG_HAPI_INIPATH_KEY}=" ${OMREG_PATHFILENAME} | sed "s/^${OMREG_HAPI_INIPATH_KEY}=//") if [ -z "${ISVCDD_INIPATH}" ]; then # use install path when ini path not found ISVCDD_INIPATH=${ISVCDD_INSTALLPATH} fi # Get variable data path from omreg config file ISVCDD_VARDATAPATH=$( grep "^${OMREG_HAPI_VARDATAPATH_KEY}=" ${OMREG_PATHFILENAME} | sed "s/^${OMREG_HAPI_VARDATAPATH_KEY}=//") if [ -z "${ISVCDD_VARDATAPATH}" ]; then echo "Unable to get variable data path from file: ${OMREG_PATHFILENAME}" exit 2 fi else # Set defaults if not specified by user if [ -z "${INSTALL_DIR}" ]; then ISVCDD_INSTALLPATH="${ISVCDD_DEFAULT_INSTALL_DIR}" else ISVCDD_INSTALLPATH=${INSTALL_DIR} fi ISVCDD_INIPATH=${ISVCDD_INSTALLPATH} if [ -z "${VARDATA_DIR}" ]; then ISVCDD_VARDATAPATH="${ISVCDD_DEFAULT_VARDATA_DIR}" else ISVCDD_VARDATAPATH=${VARDATA_DIR} fi fi ISVCDD_SCRIPT_LOCKFILE="${ISVCDD_VARDATAPATH}/.ipc/${ISVCDD_SCRIPT_NAME}.lock" # Determine target processor architecture, and the bit size, for device drivers if [ ${HOSTTYPE} = "ia64" ]; then ISVCDD_PROC_ARCH="ia64" ISVCDD_DRV_BIT_SIZE="64" elif [ ${HOSTTYPE} = "x86_64" ]; then ISVCDD_PROC_ARCH="x86_64" ISVCDD_DRV_BIT_SIZE="64" else ISVCDD_PROC_ARCH="x86" ISVCDD_DRV_BIT_SIZE="32" fi # Install directories ISVCDD_BIN_DIR="/opt/dell/srvadmin/bin" ISVCDD_SBIN_DIR="/opt/dell/srvadmin/sbin" if [ -z "${ISVCDD_ROOT_DIR}" ]; then ISVCDD_DRIVERS_DIR="/opt/dell/srvadmin/src/srvadmin-hapi" else ISVCDD_DRIVERS_DIR="${ISVCDD_ROOT_DIR}" fi # Status directories ISVCDD_STATUS_DIR="${ISVCDD_VARDATAPATH}/drivers/status" if [ ! -d ${ISVCDD_STATUS_DIR} ]; then mkdir -p ${ISVCDD_STATUS_DIR} fi ISVCDD_STATUS_KERNEL_DIR="${ISVCDD_STATUS_DIR}/${RUNNING_KERNEL}" if [ ! -d ${ISVCDD_STATUS_KERNEL_DIR} ]; then mkdir -p ${ISVCDD_STATUS_KERNEL_DIR} fi # Application filenames ISVCDD_DCHCFG_EXE="dchcfg" # Device driver names ISVCDD_DRIVER_NAME_BASE="dcdbas" ISVCDD_DRIVER_NAME_RBU="dell_rbu" # Create list of device driver module names ISVCDD_DRIVER_LIST_ALL="" ISVCDD_DRIVER_LIST_ALL="${ISVCDD_DRIVER_LIST_ALL} ${ISVCDD_DRIVER_NAME_BASE}" ISVCDD_DRIVER_LIST_ALL="${ISVCDD_DRIVER_LIST_ALL} ${ISVCDD_DRIVER_NAME_RBU}" # Systems Management Data Engine information DENG_PROD_NAME="Systems Management Data Engine" DENG_SCRIPT="${OS_INITSCRIPT_DIR}/dataeng" DENG_WAS_RUNNING=0 # Standard status codes for commands other than "status" STATUS_NO_ERROR=0 STATUS_GENERIC_ERROR=1 STATUS_INVALID_ARG=2 STATUS_NOT_IMPLEMENTED=3 # Device Drivers status codes for commands other than "status" STATUS_SYSTEM_NOT_SUPPORTED=150 STATUS_NO_KERNEL_SOURCE=151 STATUS_DKS_COMPILE_ERROR=152 STATUS_DKS_LINK_ERROR=153 STATUS_INSMOD_UNRESOLVED_SYMBOL=154 STATUS_INSMOD_ERROR=155 STATUS_RMMOD_ERROR=156 STATUS_DKS_FILES_NOT_FOUND=157 STATUS_GCC_NOT_FOUND=158 STATUS_BUILTIN_KERNEL=159 STATUS_FORCE_THREAD_NOT_SUPPORTED=160 STATUS_IPMI_DRIVER_STOPPED=161 STATUS_FORCE_THREAD_OPTION_FOUND=162 STATUS_TUNE_THREAD_OPTION_FOUND=163 STATUS_TUNE_THREAD_NOT_SUPPORTED=164 STATUS_OPTION_SUPERSEDED=165 STATUS_OPTION_NOT_SUPPORTED=166 STATUS_OPTION_SUPPORTED_BUT_NOT_SET=167 STATUS_OPTION_SUPPORTED_AND_SET=168 STATUS_INTERRUPTS_SUPPORTED=169 STATUS_INTERRUPTS_NOT_SUPPORTED=170 # Standard status codes for "status" command STATUS_RUNNING=0 STATUS_NOT_RUNNING=3 # Device Drivers status codes for "status" command STATUS_INVALID_STATUS_ARG=180 # Driver types DRV_TYPE_MODULE=1 DRV_TYPE_BUILTIN=2 # System types SYS_TYPE_NONE=0 SYS_TYPE_TVM=1 SYS_TYPE_ESM=2 SYS_TYPE_IPMI=4 # Flag to force start of all users FORCE_START_USERS=0 # Flag to control the support in this script for forcing thread # and tuning thread FORCE_THREAD_FEATURE_SUPPORTED=1 TUNE_THREAD_FEATURE_SUPPORTED=1 # OpenIPMI to HAPI configuration OIHAPICFG_PATHFILENAME="${ISVCDD_INIPATH}/ini/dchipm.ini" OIHAPICFG_KEYPREFIX="${HAPICFG_PROJECT_NAME_HAPI}.openipmi" OIHAPICFG_KEY_DRIVERSTARTED="${OIHAPICFG_KEYPREFIX}.driverstarted" OIHAPICFG_KEY_ISSUPPORTEDVERSION="${OIHAPICFG_KEYPREFIX}.issupportedversion" OIHAPICFG_KEY_ISPOWEROFFCAPABLE="${OIHAPICFG_KEYPREFIX}.ispoweroffcapable" OIHAPICFG_KEY_POWERCYCLECOMMAND="${OIHAPICFG_KEYPREFIX}.powercyclecommand" OIHAPICFG_KEY_POWEROFFMODULE="${OIHAPICFG_KEYPREFIX}.poweroffmodule" OIHAPICFG_KEY_POWERCYCLEMODULE="${OIHAPICFG_KEYPREFIX}.powercyclemodule" OIHAPICFG_KEY_BASEDRIVERPREFIX="${OIHAPICFG_KEYPREFIX}.basedriverprefix" OIHAPICFG_KEY_DRIVERPATTERN="${OIHAPICFG_KEYPREFIX}.driverpattern" OIHAPICFG_KEY_DEVICENODENAME="${OIHAPICFG_KEYPREFIX}.devicenodename" OIHAPICFG_KEY_ALLOWUSERMODE="${HAPICFG_HAPI_OI_INITFAIL_OK_KEY}" OIHAPICFG_HEADER="\ # Automatically generated file: please don't edit\n\ # Copyright (c) 1995-2011 Dell Inc. - All Rights Reserved\n\ # This file is in config (not INI) format\ " ############################################################################### # Function: debugprint # Description: Print debugging messages # Returns: none ############################################################################### debugprint() { if [ `echo ${VERBOSE_LOGGING} | grep -Ec "(0|no|NO|No|false|False|FALSE)"` -eq 0 ]; then echo $1 >${VERBOSE_TARGET} 2>&1 fi } ############################################################################### # Function: openipmi_check_version # Description: Check for minimum version of OpenIPMI supported # Returns: LSB status codes # STATUS_NO_ERROR on success # STATUS_GENERIC_ERROR on failure ############################################################################### openipmi_check_version() { local l_fname="CheckOpenIPMIVersion" local l_os_supported local l_ver_min_major l_ver_min_minor l_ver_min_patch local l_modext l_major l_minor l_patch local l_maj_ckey l_maj_dflt local l_min_ckey l_min_dflt local l_pat_ckey l_path_dflt ## get supported operating systems l_os_supported=1 ## check if operating system is RHEL3 if [ ! "`grep 'Taroon' /etc/redhat-release 2>/dev/null`" = "" ]; then debugprint "${l_fname}: OS is RHEL3" l_maj_ckey=${OPENIPMI_RHEL3_VERMAJ_CONFIG_KEY} l_maj_dflt=${OPENIPMI_RHEL3_VERMAJ_DEFAULT} l_min_ckey=${OPENIPMI_RHEL3_VERMIN_CONFIG_KEY} l_min_dflt=${OPENIPMI_RHEL3_VERMIN_DEFAULT} l_modext=".o" ## check if operating system is RHEL4 elif [ ! "`grep 'Nahant' /etc/redhat-release 2>/dev/null`" = "" ]; then debugprint "${l_fname}: OS is RHEL4" l_maj_ckey=${OPENIPMI_RHEL4_VERMAJ_CONFIG_KEY} l_maj_dflt=${OPENIPMI_RHEL4_VERMAJ_DEFAULT} l_min_ckey=${OPENIPMI_RHEL4_VERMIN_CONFIG_KEY} l_min_dflt=${OPENIPMI_RHEL4_VERMIN_DEFAULT} l_modext=".ko" ## check if operating system is SLES9 elif [ "`grep 'VERSION' /etc/SuSE-release 2>/dev/null | sed 's#[^0-9]##g'`" = "9" ]; then debugprint "${l_fname}: OS is SLES9" l_maj_ckey=${OPENIPMI_SLES9_VERMAJ_CONFIG_KEY} l_maj_dflt=${OPENIPMI_SLES9_VERMAJ_DEFAULT} l_min_ckey=${OPENIPMI_SLES9_VERMIN_CONFIG_KEY} l_min_dflt=${OPENIPMI_SLES9_VERMIN_DEFAULT} l_modext=".ko" else debugprint "${l_fname}: FAILED to determine OS" l_maj_ckey=${OPENIPMI_KERNEL_VERMAJ_CONFIG_KEY} l_maj_dflt=${OPENIPMI_KERNEL_VERMAJ_DEFAULT} l_min_ckey=${OPENIPMI_KERNEL_VERMIN_CONFIG_KEY} l_min_dflt=${OPENIPMI_KERNEL_VERMIN_DEFAULT} l_pat_ckey=${OPENIPMI_KERNEL_VERPCH_CONFIG_KEY} l_pat_dflt=${OPENIPMI_KERNEL_VERPCH_DEFAULT} l_os_supported=0 fi ## extract major version base value l_ver_min_major=$(grep "${l_maj_ckey}" ${OMREG_PATHFILENAME} \ | cut -d= -f2 | sed 's/[\t ]*//g') [ -z "${l_ver_min_major}" ] && l_ver_min_major=${l_maj_dflt} ## extract minor version base value l_ver_min_minor=$(grep "${l_min_ckey}" ${OMREG_PATHFILENAME} \ | cut -d= -f2 | sed 's/[\t ]*//g') [ -z "${l_ver_min_minor}" ] && l_ver_min_minor=${l_min_dflt} ## check if a supported operating system is found if [ ${l_os_supported} -eq 0 ]; then ## check if kernel version otherwise meets a minimum kernel ## version (if so, then it is assumed that the system should ## have an OpenIPMI driver installed that meets or exceeds the ## minimum version of OpenIPMI required by Systems Management) ## extract patch version base value l_ver_min_patch=$(grep "${l_pat_ckey}" ${OMREG_PATHFILENAME} \ | cut -d= -f2 | sed 's/[\t ]*//g') [ -z "${l_ver_min_patch}" ] && l_ver_min_patch=${l_pat_dflt} debugprint "${l_fname}: kernel version minimum is: ${l_ver_min_major}.${l_ver_min_minor}.${l_ver_min_patch}" debugprint "${l_fname}: running kernel version is: ${RUNNING_KERNEL}" ## now check if running kernel version meets the minimum kernel version l_major=$(echo ${RUNNING_KERNEL} | cut -d. -f1) if [ ${l_major} -gt ${l_ver_min_major} ]; then debugprint "${l_fname}: kernel major version > minimum" ## good at this point return ${STATUS_NO_ERROR} elif [ ${l_major} -eq ${l_ver_min_major} ]; then l_minor=$(echo ${RUNNING_KERNEL} | cut -d. -f2) if [ ${l_minor} -gt ${l_ver_min_minor} ]; then debugprint "${l_fname}: kernel minor version > minimum" ## good at this point return ${STATUS_NO_ERROR} elif [ ${l_minor} -eq ${l_ver_min_minor} ]; then l_patch=$(echo ${RUNNING_KERNEL} | cut -d. -f3 | cut -d- -f1) if [ ${l_patch} -gt ${l_ver_min_patch} ]; then debugprint "${l_fname}: kernel patch version > minimum" ## good at this point return ${STATUS_NO_ERROR} elif [ ${l_patch} -eq ${l_ver_min_patch} ]; then debugprint "${l_fname}: kernel version == minimum" ## good at this point return ${STATUS_NO_ERROR} else debugprint "${l_fname}: failed: kernel patch version < minimum" return ${STATUS_GENERIC_ERROR} fi else debugprint "${l_fname}: failed: kernel minor version < minimum" return ${STATUS_GENERIC_ERROR} fi else debugprint "${l_fname}: failed: kernel major version < minimum" return ${STATUS_GENERIC_ERROR} fi fi ## check version using modprobe debugprint "${l_fname}: minimum version is ${l_ver_min_major}.${l_ver_min_minor}" l_minor=0 l_major=$(${OPENIPMI_GETVER_MOD} 2>/dev/null \ | grep '^version:' | awk -F'version:' '{ print $2 }' \ | cut -d. -f1 | sed -e 's/[ \t]*//g' -e 's/v//g') [ -z "${l_major}" ] && l_major=0 if [ ${l_major} -eq ${l_ver_min_major} ]; then ## major version == minimum l_minor=$(${OPENIPMI_GETVER_MOD} 2>/dev/null \ | grep '^version:' | awk -F'version:' '{ print $2 }' \ | awk -F'.' '{ print $2 }' | sed -e 's/\([0-9]*\).*/\1/') [ -z "${l_minor}" ] && l_minor=0 if [ ${l_minor} -ge ${l_ver_min_minor} ]; then debugprint "${l_fname}: version >= minimum" ## good at this point return ${STATUS_NO_ERROR} fi else if [ ${l_major} -gt ${l_ver_min_major} ]; then debugprint "${l_fname}: major version > minimum" ## good at this point return ${STATUS_NO_ERROR} fi fi ## form the path file name l_modext="${OPENIPMI_GETVER_FILE}${l_modext}" ## check version using strings in the kernel module file debugprint "${l_fname}: failed version check using modinfo" debugprint "${l_fname}: trying ${l_modext}" l_minor=0 l_major=$(grep -a ' version ' ${l_modext} 2>/dev/null \ | awk -F' version ' '{ print $2 }' \ | cut -d. -f1 | sed -e 's/[ \t]*//g' -e 's/v//g') [ -z "${l_major}" ] && l_major=0 if [ ${l_major} -eq ${l_ver_min_major} ]; then ## major version == minimum l_minor=$(grep -a ' version ' ${l_modext} 2>/dev/null \ | awk -F' version ' '{ print $2 }' \ | awk -F'.' '{ print $2 }' | sed -e 's/\([0-9]*\).*/\1/') [ -z "${l_minor}" ] && l_minor=0 if [ ${l_minor} -ge ${l_ver_min_minor} ]; then debugprint "${l_fname}: version >= minimum" ## good at this point return ${STATUS_NO_ERROR} fi else if [ ${l_major} -gt ${l_ver_min_major} ]; then debugprint "${l_fname}: major version > minimum" ## good at this point return ${STATUS_NO_ERROR} fi fi debugprint "${l_fname}: failed: found version: ${l_major}.${l_minor}" return ${STATUS_GENERIC_ERROR} } # openipmi_check_version ############################################################################### # Function: instsvcdrv_openipmi_getdrvtype # Description: Get OpenIPMI driver type # Returns: Driver type ############################################################################### instsvcdrv_openipmi_getdrvtype() { local drv_type ## check if ESX 4 or later if instsvcdrv_supt_esx4orlater; then drv_type=${DRV_TYPE_BUILTIN} else drv_type=${DRV_TYPE_MODULE} fi return ${drv_type} } # instsvcdrv_openipmi_getdrvtype ############################################################################### # Function: instsvcdrv_initfailok_openipmi # Description: Check configuration settings for init fail override # Returns: LSB status codes # STATUS_NO_ERROR if init failure is not allowed # STATUS_GENERIC_ERROR if init failure is allowed ############################################################################### instsvcdrv_initfailok_openipmi() { local l_val ## check configuration file for overrides if [ -f "${HAPICFG_PATHFILENAME}" ]; then l_val=$(grep "^${HAPICFG_HAPI_OI_INITFAIL_OK_KEY}" \ ${HAPICFG_PATHFILENAME} | sed "s/^.*=//") if [ ! -z "${l_val}" ] && [ `echo ${l_val} | grep -Ec "(0|no|NO|No|false|False|FALSE)"` -eq 0 ]; then return ${STATUS_GENERIC_ERROR} fi fi return ${STATUS_NO_ERROR} } # instsvcdrv_initfailok_openipmi ############################################################################### # Function: instsvcdrv_oihapicfg_validate_addheader # Description: Check security state of OpenIPMI-HAPI configuration file # Returns: LSB status codes # STATUS_NO_ERROR on success # STATUS_GENERIC_ERROR on failure ############################################################################### instsvcdrv_oihapicfg_validate_addheader() { local l_fname="OItoHAPIconfig" debugprint "instsvcdrv_oihapicfg_validate_addheader()" ## check file security before making changes # [ ! -e "${OIHAPICFG_PATHFILENAME}" ] && # debugprint "${l_fname}: error: file does not exist" && # return ${STATUS_GENERIC_ERROR} if [ ! -e "${OIHAPICFG_PATHFILENAME}" ]; then if [ "`id -u`" = "0" ]; then ## create the path and file only if user root l_path=$(basename ${OIHAPICFG_PATHFILENAME}) l_path=$(echo ${OIHAPICFG_PATHFILENAME} | sed "s/\/${l_path}//") if [ ! -e "${l_path}" ]; then debugprint "${l_fname}: creating ${l_path}" mkdir ${l_path} >/dev/null chmod 700 ${l_path} >/dev/null fi debugprint "${l_fname}: creating ${OIHAPICFG_PATHFILENAME}" touch ${OIHAPICFG_PATHFILENAME} >/dev/null chmod 600 ${OIHAPICFG_PATHFILENAME} >/dev/null fi ## check again if [ ! -e "${OIHAPICFG_PATHFILENAME}" ]; then debugprint "${l_fname}: error: file does not exist" && return ${STATUS_GENERIC_ERROR} fi fi [ -h "${OIHAPICFG_PATHFILENAME}" ] && debugprint "${l_fname}: error: file is a symbolic link" && return ${STATUS_GENERIC_ERROR} [ ! "`id -u`" = "0" -o ! -O "${OIHAPICFG_PATHFILENAME}" ] && debugprint "${l_fname}: error: file is not owned by root" && return ${STATUS_GENERIC_ERROR} [ ! -w "${OIHAPICFG_PATHFILENAME}" ] && debugprint "${l_fname}: error: file is not writable" && return ${STATUS_GENERIC_ERROR} ## add standard header printf "%b\n" "#\n${OIHAPICFG_HEADER}" > ${OIHAPICFG_PATHFILENAME} printf "%b\n" "# Generated on `date`\n#" >> ${OIHAPICFG_PATHFILENAME} return ${STATUS_NO_ERROR} } # instsvcdrv_oihapicfg_validate_addheader ############################################################################### # Function: instsvcdrv_oihapicfg_started_openipmi # Description: Update OpenIPMI-HAPI configuration on successful OpenIPMI start # Returns: LSB status codes # STATUS_NO_ERROR on success # STATUS_GENERIC_ERROR on failure ############################################################################### instsvcdrv_oihapicfg_started_openipmi() { local drv_type=$1 ## check file security before making changes instsvcdrv_oihapicfg_validate_addheader [ $? -ne ${STATUS_NO_ERROR} ] && return ${STATUS_GENERIC_ERROR} printf "%b\n" "${OIHAPICFG_KEY_DRIVERSTARTED}=yes" >>${OIHAPICFG_PATHFILENAME} printf "%b\n" "${OIHAPICFG_KEY_ISSUPPORTEDVERSION}=yes" >>${OIHAPICFG_PATHFILENAME} printf "%b\n" "${OIHAPICFG_KEY_DRIVERPATTERN}=ipmi_" >>${OIHAPICFG_PATHFILENAME} printf "%b\n" "${OIHAPICFG_KEY_BASEDRIVERPREFIX}=ipmi_si" >>${OIHAPICFG_PATHFILENAME} ## check poweroff modinfo ipmi_poweroff >/dev/null 2>&1 if [ $? -eq 0 ]; then printf "%b\n" "${OIHAPICFG_KEY_ISPOWEROFFCAPABLE}=yes" >>${OIHAPICFG_PATHFILENAME} printf "%b\n" "${OIHAPICFG_KEY_POWEROFFMODULE}=ipmi_poweroff" >>${OIHAPICFG_PATHFILENAME} printf "%b\n" "${OIHAPICFG_KEY_POWERCYCLEMODULE}=ipmi_poweroff" >>${OIHAPICFG_PATHFILENAME} ## check powercycle modinfo ipmi_poweroff 2>/dev/null | grep poweroff_control >/dev/null 2>&1 && \ printf "%b\n" "${OIHAPICFG_KEY_POWERCYCLECOMMAND}=poweroff_control=2" >>${OIHAPICFG_PATHFILENAME} modinfo ipmi_poweroff 2>/dev/null | grep poweroff_powercycle >/dev/null 2>&1 && \ printf "%b\n" "${OIHAPICFG_KEY_POWERCYCLECOMMAND}=poweroff_powercycle=1" >>${OIHAPICFG_PATHFILENAME} else printf "%b\n" "${OIHAPICFG_KEY_ISPOWEROFFCAPABLE}=no" >>${OIHAPICFG_PATHFILENAME} fi printf "%b\n" "${OIHAPICFG_KEY_ALLOWUSERMODE}=no" >>${OIHAPICFG_PATHFILENAME} printf "%b\n" "" >>${OIHAPICFG_PATHFILENAME} return ${STATUS_NO_ERROR} } # instsvcdrv_oihapicfg_started_openipmi ############################################################################### # Function: instsvcdrv_oihapicfg_usermode # Description: Update OpenIPMI-HAPI configuration for user-mode # Returns: LSB status codes # STATUS_NO_ERROR on success # STATUS_GENERIC_ERROR on failure ############################################################################### instsvcdrv_oihapicfg_usermode() { ## check file security before making changes instsvcdrv_oihapicfg_validate_addheader [ $? -ne ${STATUS_NO_ERROR} ] && return ${STATUS_GENERIC_ERROR} printf "%b\n" "${OIHAPICFG_KEY_DRIVERSTARTED}=yes" >>${OIHAPICFG_PATHFILENAME} printf "%b\n" "${OIHAPICFG_KEY_ALLOWUSERMODE}=yes" >>${OIHAPICFG_PATHFILENAME} printf "%b\n" "" >>${OIHAPICFG_PATHFILENAME} return ${STATUS_NO_ERROR} } # instsvcdrv_oihapicfg_usermode ############################################################################### # Function: instsvcdrv_oihapicfg_stopped # Description: Update OpenIPMI-HAPI configuration on driver stop # Returns: LSB status codes # STATUS_NO_ERROR on success # STATUS_GENERIC_ERROR on failure ############################################################################### instsvcdrv_oihapicfg_stopped() { ## check file security before making changes instsvcdrv_oihapicfg_validate_addheader [ $? -ne ${STATUS_NO_ERROR} ] && return ${STATUS_GENERIC_ERROR} printf "%b\n" "${OIHAPICFG_KEY_DRIVERSTARTED}=no" >>${OIHAPICFG_PATHFILENAME} printf "%b\n" "" >>${OIHAPICFG_PATHFILENAME} return ${STATUS_NO_ERROR} } # instsvcdrv_oihapicfg_stopped ############################################################################### # Function: instsvcdrv_oihapicfg_unsupported # Description: Update OpenIPMI-HAPI configuration on unsupported driver version # Returns: LSB status codes # STATUS_NO_ERROR on success # STATUS_GENERIC_ERROR on failure ############################################################################### instsvcdrv_oihapicfg_unsupported() { ## check file security before making changes instsvcdrv_oihapicfg_validate_addheader [ $? -ne ${STATUS_NO_ERROR} ] && return ${STATUS_GENERIC_ERROR} printf "%b\n" "${OIHAPICFG_KEY_ISSUPPORTEDVERSION}=no" >>${OIHAPICFG_PATHFILENAME} printf "%b\n" "" >>${OIHAPICFG_PATHFILENAME} return ${STATUS_NO_ERROR} } # instsvcdrv_oihapicfg_unsupported ############################################################################### # Function: instsvcdrv_start_openipmi # Description: Start OpenIPMI driver # Returns: LSB status codes # STATUS_NO_ERROR on success # STATUS_GENERIC_ERROR on failure ############################################################################### instsvcdrv_start_openipmi() { local val local log_msg local drv_type local failure_msg local success_msg local startcmd_status local status=${STATUS_GENERIC_ERROR} ## check if system is IPMI instsvcdrv_get_sys_type if [ ${ISVCDD_SYS_TYPE} -ne ${SYS_TYPE_IPMI} ]; then return ${STATUS_NO_ERROR} fi ## check if IPMI driver load disabled in config file val=$(grep -E "^${HAPICFG_HAPI_OI_LOAD}=" ${HAPICFG_PATHFILENAME} \ 2>/dev/null | cut -d= -f2 | sed 's/[\t ]*//g') if [ `echo ${val} | grep -Ec "(0|no|NO|No|false|False|FALSE)"` -ne 0 ]; then return ${STATUS_NO_ERROR} fi ## display what is to be done printf "%b\n" "Starting ${OPENIPMI_DISPLAY_NAME}: " ## check IPMI driver version openipmi_check_version if [ $? -ne ${STATUS_NO_ERROR} ]; then instsvcdrv_oihapicfg_unsupported instsvcdrv_supt_logmessage "IPMI driver version not supported" instsvcdrv_supt_showfailure "Unsupported version" return ${STATUS_GENERIC_ERROR} fi ## get IPMI driver type instsvcdrv_openipmi_getdrvtype drv_type=$? ## check if IPMI driver started if [ ${drv_type} -eq ${DRV_TYPE_BUILTIN} ]; then ## check if IPMI device node exists if [ -c ${OPENIPMI_DEVNODE} ]; then success_msg="Already started" status=${STATUS_NO_ERROR} else failure_msg="No IPMI device" log_msg="IPMI device not found: ${OPENIPMI_DEVNODE}" instsvcdrv_supt_logmessage "${log_msg}" fi elif [ -f "${OPENIPMI_SCRIPT}" ]; then ## check if IPMI driver loaded and device node exists /sbin/lsmod | grep ipmi_devintf >/dev/null 2>&1 if [ $? -ne 0 -o ! -c ${OPENIPMI_DEVNODE} ]; then ## start IPMI driver ${OPENIPMI_SCRIPT} start >/dev/null 2>&1 startcmd_status=$? if [ ${startcmd_status} -eq 0 ]; then success_msg="" status=${STATUS_NO_ERROR} else failure_msg="" log_msg="${OPENIPMI_SCRIPT} start command failed with status ${startcmd_status}" instsvcdrv_supt_logmessage "${log_msg}" fi else success_msg="Already started" status=${STATUS_NO_ERROR} fi else log_msg="IPMI driver init script not found" instsvcdrv_supt_logmessage "${log_msg}" ## check if IPMI driver loaded /sbin/lsmod | grep ipmi_ >/dev/null 2>&1 if [ $? -eq 0 ]; then success_msg="Already started" status=${STATUS_NO_ERROR} else failure_msg="No IPMI script" fi fi ## check if IPMI driver started if [ ${status} -eq ${STATUS_NO_ERROR} ]; then instsvcdrv_oihapicfg_started_openipmi ${drv_type} instsvcdrv_supt_showsuccess "${success_msg}" else ## check configuration file for override ## to run without IPMI driver started instsvcdrv_initfailok_openipmi if [ $? -ne ${STATUS_NO_ERROR} ]; then instsvcdrv_oihapicfg_usermode [ -z "${failure_msg}" ] && failure_msg="Failed" instsvcdrv_supt_showwarning "${failure_msg} (override enabled)" status=${STATUS_NO_ERROR} else instsvcdrv_supt_showfailure "${failure_msg}" status=${STATUS_GENERIC_ERROR} fi fi return ${status} } # instsvcdrv_start_openipmi ############################################################################### # Function: instsvcdrv_status_openipmi # Description: Status OpenIPMI driver through its init script # Parameter1: "quiet" will suppress messages to standard out # Returns: LSB status codes # STATUS_NO_ERROR on success # STATUS_GENERIC_ERROR on failure ############################################################################### instsvcdrv_status_openipmi() { local arg1=$1 local status ## check if system is IPMI instsvcdrv_get_sys_type if [ ${ISVCDD_SYS_TYPE} -ne ${SYS_TYPE_IPMI} ]; then return ${STATUS_NO_ERROR} fi ## start override from configuration file? l_val=$(grep "^${HAPICFG_HAPI_OI_LOAD}=" ${HAPICFG_PATHFILENAME} \ 2>/dev/null | cut -d= -f2 | sed 's/[\t ]*//g') if [ `echo ${l_val} | grep -Ec "(0|no|NO|No|false|False|FALSE)"` -ne 0 ]; then return ${STATUS_NO_ERROR} fi ## display what is to be done [ "${arg1}" != "quiet" ] && echo -n "${OPENIPMI_DISPLAY_NAME} is " ## set to "not running" status=${STATUS_GENERIC_ERROR} ## determine if running instsvcdrv_openipmi_getdrvtype if [ $? -eq ${DRV_TYPE_BUILTIN} ]; then if [ -c ${OPENIPMI_DEVNODE} ]; then status=${STATUS_NO_ERROR} fi else if [ -c ${OPENIPMI_DEVNODE} -a "`lsmod | grep ipmi_devintf`" ]; then status=${STATUS_NO_ERROR} fi fi ## is it alive? if [ ${status} -eq ${STATUS_NO_ERROR} ]; then [ "${arg1}" != "quiet" ] && echo "running" else ## update OpenIPMI-HAPI configuration file instsvcdrv_oihapicfg_stopped ## check configuration file for override instsvcdrv_initfailok_openipmi if [ $? -eq ${STATUS_NO_ERROR} ]; then [ "${arg1}" != "quiet" ] && echo "stopped" ## not running so error status=${STATUS_GENERIC_ERROR} else [ "${arg1}" != "quiet" ] && echo "stopped ${OPENIPMI_INITFAIL_OK_MSG}" ## not running but ignore status=${STATUS_NO_ERROR} fi fi return ${status} } # instsvcdrv_status_openipmi ############################################################################### # Function: instsvcdrv_stop_users_before_start_openipmi # Description: Stop users when it is currently running and openipmi is not # Returns: none ############################################################################### instsvcdrv_stop_users_before_start_openipmi() { instsvcdrv_status_openipmi quiet if [ $? -ne ${STATUS_NO_ERROR} ]; then ## ipmi driver is not running and we are about to start it ## make sure that users are stopped since if they are currently ## running it must be in user-mode instsvcdrv_stop_users fi return } # instsvcdrv_stop_users_before_start_openipmi ############################################################################### # Function: instsvcdrv_start # Description: Start device drivers # Returns: LSB status codes ############################################################################### instsvcdrv_start() { local driver_name driver_status status ipmistatus echo "Starting ${ISVCDD_PROD_NAME}:" status=${STATUS_NO_ERROR} instsvcdrv_get_driver_list if [ ! -z "${ISVCDD_LIST}" ]; then for driver_name in ${ISVCDD_LIST}; do instsvcdrv_start_driver ${driver_name} driver_status=$? if [ ${driver_status} != ${STATUS_NO_ERROR} ]; then status=${driver_status} fi done fi if [ -f /etc/SuSE-release ]; then suse_version=`cat /etc/SuSE-release | grep "VERSION" | awk '{ print $3 }'` if [ $suse_version -ge 12 ]; then if [ "`systemctl is-enabled ipmi.service`" == "enabled" ]; then if [ "`systemctl is-active ipmi.service`" != "active" ]; then systemctl start ipmi.service >/dev/null fi else systemctl enable ipmi.service >/dev/null systemctl start ipmi.service >/dev/null fi fi fi instsvcdrv_start_openipmi ipmistatus=$? status=$((status | ipmistatus)) return ${status} } # instsvcdrv_start ############################################################################### # Function: instsvcdrv_start_driver <driver> # Description: Start specified device driver # Returns: LSB status codes ############################################################################### instsvcdrv_start_driver() { local driver_name status driver_name="$1" status=${STATUS_NO_ERROR} instsvcdrv_check_driver_name ${driver_name} if [ $? != ${STATUS_NO_ERROR} ]; then return ${STATUS_INVALID_ARG} fi instsvcdrv_status_driver_quiet ${driver_name} case $? in ${STATUS_NOT_RUNNING}) instsvcdrv_load_driver ${driver_name} status=$? ;; ${STATUS_RUNNING}) echo -n "Starting ${driver_name}: " echo -n "Already started" instsvcdrv_supt_showsuccess "" ;; ${STATUS_BUILTIN_KERNEL}) echo "${driver_name} is built into the kernel" ;; esac return ${status} } # instsvcdrv_start_driver ############################################################################### # Function: instsvcdrv_stop # Description: Stop device drivers # Returns: LSB status codes ############################################################################### instsvcdrv_stop() { local driver_name driver_status status echo "Stopping ${ISVCDD_PROD_NAME}:" status=${STATUS_NO_ERROR} instsvcdrv_get_driver_list if [ ! -z "${ISVCDD_LIST}" ]; then for driver_name in ${ISVCDD_LIST}; do instsvcdrv_stop_driver ${driver_name} driver_status=$? if [ ${driver_status} != ${STATUS_NO_ERROR} ]; then status=${driver_status} fi done fi return ${status} } # instsvcdrv_stop ############################################################################### # Function: instsvcdrv_stop_driver <driver> # Description: Stop specified device driver # Returns: LSB status codes ############################################################################### instsvcdrv_stop_driver() { local driver_name status driver_name="$1" status=${STATUS_NO_ERROR} instsvcdrv_check_driver_name ${driver_name} if [ $? != ${STATUS_NO_ERROR} ]; then return ${STATUS_INVALID_ARG} fi instsvcdrv_status_driver_quiet ${driver_name} case $? in ${STATUS_RUNNING}) instsvcdrv_unload_driver ${driver_name} status=$? ;; ${STATUS_BUILTIN_KERNEL}) echo "${driver_name} is built into the kernel" ;; ${STATUS_NOT_RUNNING}) echo -n "Stopping ${driver_name}: " echo -n "Not started" instsvcdrv_supt_showsuccess "" ;; esac return ${status} } # instsvcdrv_stop_driver ############################################################################### # Function: instsvcdrv_status # Description: Print and return status of device drivers # Returns: LSB status codes ############################################################################### instsvcdrv_status() { local driver_name status ipmistatus status=${STATUS_RUNNING} instsvcdrv_get_driver_list if [ ! -z "${ISVCDD_LIST}" ]; then for driver_name in ${ISVCDD_LIST}; do instsvcdrv_status_driver ${driver_name} case $? in ${STATUS_NOT_RUNNING}) status=${STATUS_NOT_RUNNING} ;; esac done fi instsvcdrv_status_openipmi ipmistatus=$? status=$((status | ipmistatus)) return ${status} } # instsvcdrv_status ############################################################################### # Function: instsvcdrv_status_driver <driver module name> # Description: Print and return status of specified device driver # Returns: LSB status codes ############################################################################### instsvcdrv_status_driver() { local driver_name status driver_name="$1" instsvcdrv_check_driver_name ${driver_name} if [ $? != ${STATUS_NO_ERROR} ]; then return ${STATUS_INVALID_STATUS_ARG} fi instsvcdrv_status_driver_quiet ${driver_name} status=$? case ${status} in ${STATUS_RUNNING}) echo "${driver_name} (module) is running" ;; ${STATUS_BUILTIN_KERNEL}) echo "${driver_name} is built into the kernel" ;; ${STATUS_NOT_RUNNING}) echo "${driver_name} (module) is stopped" ;; esac return ${status} } # instsvcdrv_status_driver ############################################################################### # Function: instsvcdrv_status_quiet # Description: Return status of device drivers # Returns: LSB status codes ############################################################################### instsvcdrv_status_quiet() { local driver_name status ipmistatus status=${STATUS_RUNNING} instsvcdrv_get_driver_list if [ ! -z "${ISVCDD_LIST}" ]; then for driver_name in ${ISVCDD_LIST}; do instsvcdrv_status_driver_quiet ${driver_name} case $? in ${STATUS_NOT_RUNNING}) status=${STATUS_NOT_RUNNING} ;; esac done fi instsvcdrv_status_openipmi quiet ipmistatus=$? status=$((status | ipmistatus)) return ${status} } # instsvcdrv_status_quiet ############################################################################### # Function: instsvcdrv_status_driver_quiet <driver module name> # Description: Return status of specified device driver # Returns: LSB status codes ############################################################################### instsvcdrv_status_driver_quiet() { local status instsvcdrv_set_driver_vars $1 status=$? if [ ${status} != ${STATUS_NO_ERROR} ]; then return ${status} fi lsmod | grep -iq ${ISVCDD_MODULE_NAME} if [ $? = 0 ]; then return ${STATUS_RUNNING} elif [ ${ISVCDD_BUILTIN_KERNEL} = 1 ]; then return ${STATUS_BUILTIN_KERNEL} else return ${STATUS_NOT_RUNNING} fi } # instsvcdrv_status_driver_quiet ############################################################################### # Function: instsvcdrv_start_users # Description: Start users of device drivers # Returns: LSB status codes ############################################################################### instsvcdrv_start_users() { # See if Data Engine needs to be restarted if [ ${FORCE_START_USERS} != 0 ] || [ ${DENG_WAS_RUNNING} != 0 ]; then if [ -x ${DENG_SCRIPT} ]; then ${DENG_SCRIPT} start fi fi return ${STATUS_NO_ERROR} } # instsvcdrv_start_users ############################################################################### # Function: instsvcdrv_stop_users # Description: Stop users of device drivers # Returns: LSB status codes ############################################################################### instsvcdrv_stop_users() { # See if Data Engine is installed if [ -x ${DENG_SCRIPT} ]; then # # See if Data Engine is running # # First check if the return codes from the installed dataeng script # follow LSB standards (0=running, 1=stopped). # Prior to Data Engine version 5.1.1, the return codes from the # dataeng script did not follow LSB standards. Instead, it returned # 0=stopped and non-zero=running. ${DENG_SCRIPT} statusreturnlsb >/dev/null 2>&1 if [ $? = 0 ]; then # # Return codes follow LSB standards # # See if Data Engine is running ${DENG_SCRIPT} status-quiet if [ $? = ${STATUS_RUNNING} ]; then DENG_WAS_RUNNING=1 # Stop Data Engine ${DENG_SCRIPT} stop # Cleanup being done; wait a second sleep 1 # See if Data Engine stopped ${DENG_SCRIPT} status-quiet if [ $? = ${STATUS_RUNNING} ]; then echo "${DENG_PROD_NAME} failed to stop" echo "${ISVCDD_PROD_NAME} not stopped" return ${STATUS_GENERIC_ERROR} fi fi else # # Return codes do not follow LSB stndards # # See if Data Engine is running ${DENG_SCRIPT} status-quiet if [ $? != 0 ]; then DENG_WAS_RUNNING=1 # Stop Data Engine ${DENG_SCRIPT} stop # Cleanup being done; wait a second sleep 1 # See if Data Engine stopped ${DENG_SCRIPT} status-quiet if [ $? != 0 ]; then echo "${DENG_PROD_NAME} failed to stop" echo "${ISVCDD_PROD_NAME} not stopped" return ${STATUS_GENERIC_ERROR} fi fi fi fi return ${STATUS_NO_ERROR} } # instsvcdrv_stop_users ############################################################################### # Function: instsvcdrv_build # Description: Build device drivers # Returns: LSB status codes ############################################################################### instsvcdrv_build() { local driver_name # Check for build arguments to override defaults while [ ! -z "$1" ]; do case "$1" in --kernel) TARGET_KERNEL=$2 ;; --kernelsrcdir) KERNEL_SOURCE_DIR=$2 ;; --installdir) ISVCDD_INSTALLPATH=$2 ISVCDD_BIN_DIR="${ISVCDD_INSTALLPATH}/bin" ISVCDD_DRIVERS_DIR="${ISVCDD_INSTALLPATH}/drivers/${ISVCDD_PROC_ARCH}" ;; --vardatadir) ISVCDD_VARDATAPATH=$2 ;; --outputdir) OUTPUT_DIR=$2 ;; *) echo "Invalid argument: $1" return ${STATUS_INVALID_ARG} ;; esac if [ -z "$2" ]; then echo "No value for argument: $1" return ${STATUS_INVALID_ARG} fi shift; shift done # Set defaults if not specified by user if [ -z "${TARGET_KERNEL}" ]; then TARGET_KERNEL=${RUNNING_KERNEL} fi if [ -z "${KERNEL_SOURCE_DIR}" ]; then KERNEL_SOURCE_DIR="${OS_MODULES_DIR}/${TARGET_KERNEL}/build" fi if [ -z "${OUTPUT_DIR}" ]; then OUTPUT_DIR="${ISVCDD_VARDATAPATH}/drivers/${ISVCDD_PROC_ARCH}/${TARGET_KERNEL}" fi echo "" echo "Target kernel: ${TARGET_KERNEL}" echo "Kernel source: ${KERNEL_SOURCE_DIR}" echo "Output directory: ${OUTPUT_DIR}" echo "" # Set up output directory for device drivers if [ ! -d ${OUTPUT_DIR} ]; then mkdir -p ${OUTPUT_DIR} fi # Build device drivers in list for driver_name in ${ISVCDD_DRIVER_LIST_ALL}; do echo -n "Building ${driver_name}: " instsvcdrv_set_driver_vars ${driver_name} instsvcdrv_build_driver BUILD_STATUS=$? if [ ${BUILD_STATUS} = ${STATUS_NO_ERROR} ]; then echo "OK" cp -f ${ISVCDD} ${OUTPUT_DIR} else echo "FAILED" case ${BUILD_STATUS} in ${STATUS_DKS_FILES_NOT_FOUND} ) echo "DKS files not found." ;; ${STATUS_NO_KERNEL_SOURCE} ) echo "Kernel source not found." ;; ${STATUS_GCC_NOT_FOUND} ) echo "gcc not found." ;; * ) echo "Check ${DKS_MODULE_BUILD_LOGFILE} for build error." ;; esac echo "" return ${BUILD_STATUS} fi done echo "" return ${STATUS_NO_ERROR} } # instsvcdrv_build ############################################################################### # Function: instsvcdrv_preupgrade # Description: Prepare for upgrade # Returns: LSB status codes ############################################################################### instsvcdrv_preupgrade() { # upgrade needs same cleanup as uninstall instsvcdrv_preuninstall return $? } # instsvcdrv_preupgrade ############################################################################### # Function: instsvcdrv_preuninstall # Description: Prepare for uninstall # Returns: LSB status codes ############################################################################### instsvcdrv_preuninstall() { local driver_name # stop drivers if running instsvcdrv_status_quiet if [ $? = ${STATUS_RUNNING} ]; then instsvcdrv_stop_users instsvcdrv_stop fi # get list of kernel names in drivers status directory SUBDIR_LIST=$(ls ${ISVCDD_STATUS_DIR}) # remove device drivers from kernel module directory for driver_name in ${ISVCDD_DRIVER_LIST_ALL}; do instsvcdrv_set_driver_vars ${driver_name} for SUBDIR in ${SUBDIR_LIST}; do TMP=${ISVCDD_STATUS_DIR}/${SUBDIR}/${ISVCDD_MODULE_NAME}.installed if [ -f ${TMP} ]; then rm -f ${OS_MODULES_DIR}/${SUBDIR}/${ISVCDD_KERNEL_MODULE_SUBDIR}/${ISVCDD_MODULE_NAME}.o rm -f ${OS_MODULES_DIR}/${SUBDIR}/${ISVCDD_KERNEL_MODULE_SUBDIR}/${ISVCDD_MODULE_NAME}.ko rm -f ${TMP} fi done done depmod -a >/dev/null 2>&1 instsvcdrv_dks_cleanup if [ -d ${ISVCDD_STATUS_DIR} ]; then rm -rf ${ISVCDD_STATUS_DIR} fi rm -f ${ISVCDD_SCRIPT_LOCKFILE} return ${STATUS_NO_ERROR} } # instsvcdrv_preuninstall ############################################################################### # Function: instsvcdrv_restart_forcekernelmatch # Description: Restart drivers with "kernel match" load option enabled # Returns: LSB status codes ############################################################################### instsvcdrv_restart_forcekernelmatch() { local driver status # stop drivers instsvcdrv_stop_users instsvcdrv_stop status=$? if [ ${status} != ${STATUS_NO_ERROR} ]; then return ${status} fi # uninstall drivers that were installed by this script # for running kernel # (ISVCDD_LIST set up by instsvcdrv_stop) if [ ! -z "${ISVCDD_LIST}" ]; then for driver in ${ISVCDD_LIST}; do instsvcdrv_set_driver_vars ${driver} if [ -f ${ISVCDD_STATUSFILE_INSTALLED} ]; then rm -f ${ISVCDD_KERNEL_MODULE_DIR}/${ISVCDD_BINARY_FILENAME} rm -f ${ISVCDD_STATUSFILE_INSTALLED} fi done depmod -a >/dev/null 2>&1 fi # force DKS to be used if precompiled driver not found # in directory with name that matches running kernel ISVCDD_FORCE_KERNEL_MATCH=1 # start drivers instsvcdrv_start status=$? # note: ignore exit code from instsvcdrv_start_users instsvcdrv_start_users return ${status} } # instsvcdrv_restart_forcekernelmatch ############################################################################### # Function: instsvcdrv_get_sys_type # Description: Get system type # Returns: system type via ISVCDD_SYS_TYPE ############################################################################### instsvcdrv_get_sys_type() { ISVCDD_SYS_TYPE=${SYS_TYPE_NONE} if [ -x ${ISVCDD_SBIN_DIR}/${ISVCDD_DCHCFG_EXE} ]; then ${ISVCDD_SBIN_DIR}/${ISVCDD_DCHCFG_EXE} command=getsystype >/dev/null 2>&1 ISVCDD_SYS_TYPE=$? fi } # instsvcdrv_get_sys_type ############################################################################### # Function: instsvcdrv_get_forcekernelmatch # Description: Get "kernel match" option value for driver load # Returns: value via ISVCDD_FORCE_KERNEL_MATCH ############################################################################### instsvcdrv_get_forcekernelmatch() { local val # check if option already specified if [ -z "${ISVCDD_FORCE_KERNEL_MATCH}" ]; then # option not enabled by default for Red Hat if [ -f /etc/redhat-release ]; then ISVCDD_FORCE_KERNEL_MATCH=0 else ISVCDD_FORCE_KERNEL_MATCH=1 fi # check config file for option if [ -f ${HAPICFG_PATHFILENAME} ]; then val=$( grep "^${HAPICFG_HAPI_FORCEKERMATCH_KEY}=" ${HAPICFG_PATHFILENAME} | sed "s/^${HAPICFG_HAPI_FORCEKERMATCH_KEY}=//") case "${val}" in true|TRUE|1) ISVCDD_FORCE_KERNEL_MATCH=1 ;; false|FALSE|0) ISVCDD_FORCE_KERNEL_MATCH=0 ;; esac fi fi } # instsvcdrv_get_forcekernelmatch ############################################################################### # Function: instsvcdrv_check_driver_name <driver> # Description: Check specified device driver name # Returns: LSB status codes ############################################################################### instsvcdrv_check_driver_name() { local driver isvcdd_driver driver="$1" if [ -z ${driver} ]; then echo "${ISVCDD_SCRIPT_NAME}: driver not specified" return ${STATUS_INVALID_ARG} fi for isvcdd_driver in ${ISVCDD_DRIVER_LIST_ALL}; do if [ "${driver}" = "${isvcdd_driver}" ]; then return ${STATUS_NO_ERROR} fi done echo "${ISVCDD_SCRIPT_NAME}: driver name not valid" return ${STATUS_INVALID_ARG} } # instsvcdrv_check_driver_name ############################################################################### # Function: instsvcdrv_get_driver_list # Description: Get list of drivers configured for loading # Returns: LSB status codes # Driver list returned via ISVCDD_LIST ############################################################################### instsvcdrv_get_driver_list() { ISVCDD_LIST="" LOADDRIVERS="${HAPICFG_HAPI_LOADDRIVERS_ACTIVE}" if [ -f ${HAPICFG_PATHFILENAME} ]; then HAPICFG_LOADDRIVERS=$( grep "^${HAPICFG_HAPI_LOADDRIVERS_KEY}=" ${HAPICFG_PATHFILENAME} | sed "s/^${HAPICFG_HAPI_LOADDRIVERS_KEY}=//") if [ ! -z "${HAPICFG_LOADDRIVERS}" ]; then # validate value case "${HAPICFG_LOADDRIVERS}" in ${HAPICFG_HAPI_LOADDRIVERS_ACTIVE} | \ ${HAPICFG_HAPI_LOADDRIVERS_ALL} | \ ${HAPICFG_HAPI_LOADDRIVERS_BASEONLY} | \ ${HAPICFG_HAPI_LOADDRIVERS_SELECTED} | \ ${HAPICFG_HAPI_LOADDRIVERS_NONE}) LOADDRIVERS="${HAPICFG_LOADDRIVERS}" ;; *) echo "Ignoring invalid ${HAPICFG_HAPI_LOADDRIVERS_KEY} value in ${HAPICFG_PATHFILENAME}" ;; esac fi fi case "${LOADDRIVERS}" in ${HAPICFG_HAPI_LOADDRIVERS_ACTIVE}) instsvcdrv_get_sys_type if [ ${ISVCDD_SYS_TYPE} != ${SYS_TYPE_IPMI} ]; then ISVCDD_LIST="${ISVCDD_LIST} ${ISVCDD_DRIVER_NAME_BASE}" fi ISVCDD_LIST="${ISVCDD_LIST} ${ISVCDD_DRIVER_NAME_RBU}" ;; ${HAPICFG_HAPI_LOADDRIVERS_ALL}) ISVCDD_LIST="${ISVCDD_DRIVER_NAME_BASE} ${ISVCDD_DRIVER_NAME_RBU}" ;; ${HAPICFG_HAPI_LOADDRIVERS_BASEONLY}) ISVCDD_LIST="${ISVCDD_DRIVER_NAME_BASE}" ;; ${HAPICFG_HAPI_LOADDRIVERS_SELECTED}) LOADDBAS=$(grep "^${HAPICFG_HAPI_LOADDBAS_KEY}=" ${HAPICFG_PATHFILENAME} | sed "s/^${HAPICFG_HAPI_LOADDBAS_KEY}=//") if [ "${LOADDBAS}" = "yes" ]; then ISVCDD_LIST="${ISVCDD_LIST} ${ISVCDD_DRIVER_NAME_BASE}" fi LOADDRBU=$(grep "^${HAPICFG_HAPI_LOADDRBU_KEY}=" ${HAPICFG_PATHFILENAME} | sed "s/^${HAPICFG_HAPI_LOADDRBU_KEY}=//") if [ "${LOADDRBU}" = "yes" ]; then ISVCDD_LIST="${ISVCDD_LIST} ${ISVCDD_DRIVER_NAME_RBU}" fi ;; ${HAPICFG_HAPI_LOADDRIVERS_NONE}) ;; esac if [ -z "${ISVCDD_LIST}" ]; then echo "No drivers are selected for use in ${HAPICFG_PATHFILENAME}" fi return ${STATUS_NO_ERROR} } # instsvcdrv_get_driver_list ############################################################################### # Function: instsvcdrv_set_driver_vars <driver module name> # Description: Set variables for specified device driver # Returns: LSB status codes ############################################################################### instsvcdrv_set_driver_vars() { ISVCDD_MODULE_NAME=$1 ISVCDD_LOG_PFNAME="${OS_VARLOG_DIR}/${ISVCDD_MODULE_NAME}.log" ISVCDD_STATUSFILE_INSTALLED="${ISVCDD_STATUS_KERNEL_DIR}/${ISVCDD_MODULE_NAME}.installed" ISVCDD_BUILTIN_KERNEL=0 case ${ISVCDD_MODULE_NAME} in ${ISVCDD_DRIVER_NAME_BASE}) ISVCDD_KERNEL_MODULE_SUBDIR="kernel/drivers/firmware" ISVCDD_KERNEL_MODULE_DIR="${OS_MODULES_DIR}/${RUNNING_KERNEL}/${ISVCDD_KERNEL_MODULE_SUBDIR}" ISVCDD_DEVICE_NAME="EsmUMBASDev" ISVCDD_LOADED_DIR_NAME="/sys/devices/platform/dcdbas" ISVCDD_LOADING_PFNAME="" ;; ${ISVCDD_DRIVER_NAME_RBU}) ISVCDD_KERNEL_MODULE_SUBDIR="kernel/drivers/firmware" ISVCDD_KERNEL_MODULE_DIR="${OS_MODULES_DIR}/${RUNNING_KERNEL}/${ISVCDD_KERNEL_MODULE_SUBDIR}" ISVCDD_DEVICE_NAME="" ISVCDD_LOADED_DIR_NAME="/sys/devices/platform/dell_rbu" ISVCDD_LOADING_PFNAME="/sys/class/firmware/dell_rbu/loading" ISVCDD_LOADING_PFNAME_BIOS="/lib/firmware/dell_rbu" ;; *) echo "instsvcdrv_set_driver_vars: invalid module name: ${ISVCDD_MODULE_NAME}" return ${STATUS_GENERIC_ERROR} ;; esac if [ ! -z "${ISVCDD_DEVICE_NAME}" ]; then ISVCDD_DEVICE_PFNAME_1="${OS_DEVICE_DIR}/${ISVCDD_DEVICE_NAME}" ISVCDD_DEVICE_PFNAME_2="${OS_DEVICE_DIR}/${ISVCDD_DEVICE_NAME}0" fi # check if driver is built into kernel if [ ! -z "${ISVCDD_LOADED_DIR_NAME}" ] && [ -d "${ISVCDD_LOADED_DIR_NAME}" ]; then lsmod | grep -iq ${ISVCDD_MODULE_NAME} if [ $? != 0 ]; then ISVCDD_BUILTIN_KERNEL=1 fi fi if [ -z "${TARGET_KERNEL}" ]; then TARGET_KERNEL=${RUNNING_KERNEL} fi LOC_VERSION=$(echo ${TARGET_KERNEL} | sed "s/\..*//") LOC_PATCHLEVEL=$(echo ${TARGET_KERNEL} | sed "s/.\.//" | sed "s/\..*//") if [ ${LOC_VERSION} -gt 2 ] || [ ${LOC_VERSION} -eq 2 -a ${LOC_PATCHLEVEL} -gt 4 ]; then LOC_EXT="ko" else LOC_EXT="o" fi ISVCDD_BINARY_FILENAME="${ISVCDD_MODULE_NAME}.${LOC_EXT}" return ${STATUS_NO_ERROR} } # instsvcdrv_set_driver_vars ############################################################################### # Function: instsvcdrv_install_driver <driver binary pathfilename> # Description: Install device driver into kernel module directory # Returns: LSB status codes ############################################################################### instsvcdrv_install_driver() { local srcfile destfile srcfile=$1 destfile=${ISVCDD_KERNEL_MODULE_DIR}/${ISVCDD_BINARY_FILENAME} if [ ! -f ${srcfile} ]; then return ${STATUS_INVALID_ARG} fi if [ ! -d ${ISVCDD_KERNEL_MODULE_DIR} ]; then mkdir -p ${ISVCDD_KERNEL_MODULE_DIR} fi cp -f ${srcfile} ${destfile} chgrp root ${destfile} chmod 744 ${destfile} depmod >/dev/null 2>&1 modprobe ${ISVCDD_MODULE_NAME} >>${ISVCDD_LOG_PFNAME} 2>&1 if [ $? != 0 ]; then return ${STATUS_INSMOD_ERROR} fi # indicate this script installed driver touch ${ISVCDD_STATUSFILE_INSTALLED} return ${STATUS_NO_ERROR} } # instsvcdrv_install_driver ############################################################################### # Function: instsvcdrv_load_driver <driver module name> # Description: Load specified device driver # Returns: LSB status codes ############################################################################### instsvcdrv_load_driver() { local status instsvcdrv_set_driver_vars $1 status=$? if [ ${status} != ${STATUS_NO_ERROR} ]; then return ${status} fi # Make sure device driver support files are cleaned up instsvcdrv_clean_driver # Create device driver load log file touch ${ISVCDD_LOG_PFNAME} chmod 600 ${ISVCDD_LOG_PFNAME} # Find device driver that works with running kernel ISVCDD_FOUND=0 ISVCDD_DKS_COPY=0 ISVCDD_INSTALLED=0 # try loading any already-installed driver modprobe ${ISVCDD_MODULE_NAME} >>${ISVCDD_LOG_PFNAME} 2>&1 if [ $? = 0 ]; then ISVCDD_FOUND=1 fi if [ ${ISVCDD_FOUND} = 0 ]; then # check for match on kernel name in HAPI precompiled driver directory PFNAME="${ISVCDD_DRIVERS_DIR}/${RUNNING_KERNEL}/${ISVCDD_BINARY_FILENAME}" instsvcdrv_install_driver "${PFNAME}" if [ $? = ${STATUS_NO_ERROR} ]; then ISVCDD_FOUND=1 fi fi if [ ${ISVCDD_FOUND} = 0 ] then # get "kernel match" option value instsvcdrv_get_forcekernelmatch # check if exact kernel match needed if [ ${ISVCDD_FORCE_KERNEL_MATCH} = 0 ]; then # get running kernel version without extraversion RUNNING_KVER=$(echo ${RUNNING_KERNEL} | sed "s/-.*//") # get running kernel config RUNNING_KCFG="" KCFG_LIST="EL ELsmp ELhugemem ELBOOT" for KCFG in ${KCFG_LIST}; do echo ${RUNNING_KERNEL} | grep "${KCFG}$" >/dev/null if [ $? = 0 ]; then RUNNING_KCFG=${KCFG} break fi done # check each subdirectory for precompiled device driver # that works with running kernel SUBDIR_LIST=$(ls ${ISVCDD_DRIVERS_DIR}) for SUBDIR in ${SUBDIR_LIST}; do # get subdir kernel version without extraversion SUBDIR_KVER=$(echo ${SUBDIR} | sed "s/-.*//") # skip subdirectory if kernel version doesn't match if [ ${SUBDIR_KVER} != ${RUNNING_KVER} ]; then continue fi # skip subdirectory if kernel config doesn't match if [ ! -z "${RUNNING_KCFG}" ]; then echo ${SUBDIR} | grep "${RUNNING_KCFG}$" >/dev/null if [ $? != 0 ]; then continue fi fi # try to load precompiled device driver PFNAME="${ISVCDD_DRIVERS_DIR}/${SUBDIR}/${ISVCDD_BINARY_FILENAME}" instsvcdrv_install_driver "${PFNAME}" if [ $? = ${STATUS_NO_ERROR} ]; then ISVCDD_FOUND=1 break fi done fi fi if [ ${ISVCDD_FOUND} = 0 ]; then # look for device driver copied by user to DKS copy directory # The procedure for using this directory is documented in the # Server Administrator User's Guide. See section "Copying a # Dynamically Built Device Driver to Systems Running the Same Kernel". ISVCDD_DKS_USER_COPY_DIR="/var/omsa/dks/${RUNNING_KERNEL}" # try to load DKS copy device driver PFNAME="${ISVCDD_DKS_USER_COPY_DIR}/${ISVCDD_BINARY_FILENAME}" instsvcdrv_install_driver "${PFNAME}" if [ $? = ${STATUS_NO_ERROR} ]; then ISVCDD_FOUND=1 ISVCDD_DKS_COPY=1 fi fi if [ ${ISVCDD_FOUND} = 0 ]; then # build device driver using DKS echo -n "Building ${ISVCDD_MODULE_NAME} using DKS:" instsvcdrv_build_driver BUILD_STATUS=$? if [ ${BUILD_STATUS} = ${STATUS_NO_ERROR} ]; then # device driver built OK instsvcdrv_supt_showsuccess "" MSG_BLD_OK="${ISVCDD_MODULE_NAME} device driver built for kernel ${RUNNING_KERNEL}" instsvcdrv_supt_logmessage "${MSG_BLD_OK}" # ISVCDD is set by instsvcdrv_build_driver on success instsvcdrv_install_driver "${ISVCDD}" if [ $? = ${STATUS_NO_ERROR} ]; then ISVCDD_FOUND=1 fi else # device driver build failed instsvcdrv_supt_showfailure "" MSG_BLD_FAIL="${ISVCDD_MODULE_NAME} device driver build failed for kernel ${RUNNING_KERNEL}." if [ ${BUILD_STATUS} = ${STATUS_NO_KERNEL_SOURCE} ]; then # Kernel source not found MSG_FAILSRC="DKS failed to find kernel source at ${KERNEL_SOURCE_DIR}." MSG_NEEDSRC="DKS requires kernel source to build device drivers." # Display message echo ${MSG_FAILSRC} echo ${MSG_NEEDSRC} # Log message instsvcdrv_supt_logmessage "${MSG_BLD_FAIL} ${MSG_FAILSRC} ${MSG_NEEDSRC}" elif [ ${BUILD_STATUS} = ${STATUS_GCC_NOT_FOUND} ]; then # gcc not found MSG_FAILGCC="DKS failed to find gcc." MSG_NEEDGCC="DKS requires gcc to build device drivers." # Display message echo ${MSG_FAILGCC} echo ${MSG_NEEDGCC} # Log message instsvcdrv_supt_logmessage "${MSG_BLD_FAIL} ${MSG_FAILGCC} ${MSG_NEEDGCC}" else # Build error MSG_CHKLOG="Check ${DKS_MODULE_BUILD_LOGFILE} for build error." # Display message echo ${MSG_CHKLOG} # Log message instsvcdrv_supt_logmessage "${MSG_BLD_FAIL} ${MSG_CHKLOG}" fi # DKS build failed return ${BUILD_STATUS} fi fi echo -n "Starting ${ISVCDD_MODULE_NAME}:" if [ ${ISVCDD_DKS_COPY} = 1 ]; then echo -n " DKS User Copy" fi # Check if device driver loaded if [ ${ISVCDD_FOUND} = 0 ]; then if [ -f ${ISVCDD_STATUSFILE_INSTALLED} ]; then PFNAME=${ISVCDD_KERNEL_MODULE_DIR}/${ISVCDD_BINARY_FILENAME} rm -f ${PFNAME} rm -f ${ISVCDD_STATUSFILE_INSTALLED} fi # Device driver failed to load instsvcdrv_supt_showfailure "" MSG_DD_LOAD_FAILED="${ISVCDD_MODULE_NAME} device driver load failed for kernel ${RUNNING_KERNEL}." MSG_DD_SEE_ERRFILE="See ${ISVCDD_LOG_PFNAME} for output from modprobe." # Display messages echo ${MSG_DD_LOAD_FAILED} echo ${MSG_DD_SEE_ERRFILE} # Log messages LOGMSG="${MSG_DD_LOAD_FAILED} ${MSG_DD_SEE_ERRFILE}" instsvcdrv_supt_logmessage "${LOGMSG}" return ${STATUS_INSMOD_ERROR} fi # Make character special file for device driver if needed if [ ! -z "${ISVCDD_DEVICE_NAME}" ] && [ -z "${ISVCDD_LOADED_DIR_NAME}" -o ! -d "${ISVCDD_LOADED_DIR_NAME}" ]; then TYPE="c" MAJOR=$(grep ${ISVCDD_MODULE_NAME} /proc/devices | awk "{print \$1}") MINOR="0" mknod ${ISVCDD_DEVICE_PFNAME_2} ${TYPE} ${MAJOR} ${MINOR} >>${ISVCDD_LOG_PFNAME} 2>&1 if [ $? != 0 ]; then # mknod failed instsvcdrv_supt_showfailure "" # Add mknod parameters to error file echo "" >>${ISVCDD_LOG_PFNAME} 2>&1 echo "mknod parameters:" >>${ISVCDD_LOG_PFNAME} 2>&1 echo "NAME: ${ISVCDD_DEVICE_PFNAME_2}" >>${ISVCDD_LOG_PFNAME} 2>&1 echo "TYPE: ${TYPE}" >>${ISVCDD_LOG_PFNAME} 2>&1 echo "MAJOR: ${MAJOR}" >>${ISVCDD_LOG_PFNAME} 2>&1 echo "MINOR: ${MINOR}" >>${ISVCDD_LOG_PFNAME} 2>&1 MSG_MKNOD_FAILED="mknod failed for ${ISVCDD_MODULE_NAME} device driver." MSG_DD_SEE_ERRFILE="See ${ISVCDD_LOG_PFNAME} for output from mknod." # Display messages echo ${MSG_MKNOD_FAILED} echo ${MSG_DD_SEE_ERRFILE} # Log messages LOGMSG="${MSG_MKNOD_FAILED} ${MSG_DD_SEE_ERRFILE}" instsvcdrv_supt_logmessage "${LOGMSG}" # Unload device driver modprobe -r ${ISVCDD_MODULE_NAME} return ${STATUS_GENERIC_ERROR} fi chgrp root ${ISVCDD_DEVICE_PFNAME_2} chmod 660 ${ISVCDD_DEVICE_PFNAME_2} ln -sf ${ISVCDD_DEVICE_PFNAME_2} ${ISVCDD_DEVICE_PFNAME_1} fi # Device driver loaded OK instsvcdrv_supt_showsuccess "" LOGMSG="${ISVCDD_MODULE_NAME} device driver loaded" instsvcdrv_supt_logmessage "${LOGMSG}" # Remove load log file on successful load rm -f ${ISVCDD_LOG_PFNAME} # Initialization being done; wait a second sleep 1 return ${STATUS_NO_ERROR} } # instsvcdrv_load_driver ############################################################################### # Function: instsvcdrv_unload_driver <driver module name> # Description: Unload specified device driver # Returns: LSB status codes ############################################################################### instsvcdrv_unload_driver() { local status instsvcdrv_set_driver_vars $1 status=$? if [ ${status} != ${STATUS_NO_ERROR} ]; then return ${status} fi # Added check to verify if there is payload for dell dup # If present we just return without unloading the dell_rbu driver # This check is applicable for kernel version 3.10 and above. if [ -f "${ISVCDD_LOADING_PFNAME_BIOS}" ]; then return ${STATUS_NO_ERROR} fi echo -n "Stopping ${ISVCDD_MODULE_NAME}:" # check if driver has loading file if [ ! -z "${ISVCDD_LOADING_PFNAME}" ] && [ -f "${ISVCDD_LOADING_PFNAME}" ]; then # tell driver it's being unloaded echo -1 >${ISVCDD_LOADING_PFNAME} fi # unload device driver modprobe -r ${ISVCDD_MODULE_NAME} if [ $? = 0 ]; then instsvcdrv_supt_showsuccess "" LOGMSG="${ISVCDD_MODULE_NAME} device driver unloaded" instsvcdrv_supt_logmessage "${LOGMSG}" else instsvcdrv_supt_showfailure "" LOGMSG="${ISVCDD_MODULE_NAME} device driver unload failed for kernel ${RUNNING_KERNEL}" instsvcdrv_supt_logmessage "${LOGMSG}" return ${STATUS_RMMOD_ERROR} fi # clean up device driver support files instsvcdrv_clean_driver return ${STATUS_NO_ERROR} } # instsvcdrv_unload_driver ############################################################################### # Function: instsvcdrv_clean_driver # Description: Clean up device driver support files # Returns: LSB status codes ############################################################################### instsvcdrv_clean_driver() { if [ ! -z "${ISVCDD_DEVICE_NAME}" ]; then rm -f ${ISVCDD_DEVICE_PFNAME_1} rm -f ${ISVCDD_DEVICE_PFNAME_2} fi rm -f ${ISVCDD_LOG_PFNAME} } # instsvcdrv_clean_driver ############################################################################### # Function: instsvcdrv_build_driver # Description: Use DKS to build specified device driver # Returns: LSB status codes # NOTE: Device driver to build is specified using environment variables. ############################################################################### instsvcdrv_build_driver() { # Set these variables if needed if [ -z "${TARGET_KERNEL}" ]; then TARGET_KERNEL=${RUNNING_KERNEL} fi if [ -z "${KERNEL_SOURCE_DIR}" ]; then KERNEL_SOURCE_DIR="${OS_MODULES_DIR}/${TARGET_KERNEL}/build" fi export TARGET_KERNEL KERNEL_GENERIC_VER=$(echo ${TARGET_KERNEL} | sed "s/-.*//") # Determine if target kernel is greater than 2.4 kernel KERNEL_VERSION=$(echo ${TARGET_KERNEL} | sed "s/\..*//") KERNEL_PATCHLEVEL=$(echo ${TARGET_KERNEL} | sed "s/.\.//" | sed "s/\..*//") if [ ${KERNEL_VERSION} -gt 2 ]; then LOC_KERNEL_IS_GT_2_4=1 elif [ ${KERNEL_VERSION} -eq 2 ] && [ ${KERNEL_PATCHLEVEL} -gt 4 ]; then LOC_KERNEL_IS_GT_2_4=1 else LOC_KERNEL_IS_GT_2_4=0 fi # Set up DKS path variables DKS_INSTALL_BASE_DIR="${ISVCDD_DRIVERS_DIR}/dks" DKS_INSTALL_COMMON_DIR="${DKS_INSTALL_BASE_DIR}/common" DKS_INSTALL_MODULE_DIR="${DKS_INSTALL_BASE_DIR}/${ISVCDD_MODULE_NAME}" DKS_VARDATA_BASE_DIR="${ISVCDD_VARDATAPATH}/drivers/${ISVCDD_PROC_ARCH}/dks" DKS_VARDATA_BUILD_DIR="${DKS_VARDATA_BASE_DIR}/build" DKS_VARDATA_MODULE_DIR="${DKS_VARDATA_BUILD_DIR}/esm" DKS_VARDATA_CURRENT_VER_DIR="${DKS_VARDATA_BUILD_DIR}/${TARGET_KERNEL}" DKS_VARDATA_GENERIC_VER_DIR="${DKS_VARDATA_BUILD_DIR}/${KERNEL_GENERIC_VER}-generic" DKS_MODULE_BUILD_LOGFILE="${OS_VARLOG_DIR}/${ISVCDD_MODULE_NAME}.dks.log" # Check for gcc GCC_VER=$(gcc -dumpversion 2>/dev/null) if [ $? != 0 ]; then return ${STATUS_GCC_NOT_FOUND} fi # Set pathfilename for device driver to be built by DKS ISVCDD="${DKS_VARDATA_MODULE_DIR}/${ISVCDD_BINARY_FILENAME}" # Make sure DKS build log file is cleaned up rm -f ${DKS_MODULE_BUILD_LOGFILE} touch ${DKS_MODULE_BUILD_LOGFILE} chmod 600 ${DKS_MODULE_BUILD_LOGFILE} echo "Building ${ISVCDD_MODULE_NAME}..." >>${DKS_MODULE_BUILD_LOGFILE} # Check for DKS files if [ ! -e "${DKS_INSTALL_BASE_DIR}" ]; then echo "Following DKS source directory not found: ${DKS_INSTALL_BASE_DIR}" >>${DKS_MODULE_BUILD_LOGFILE} return ${STATUS_DKS_FILES_NOT_FOUND} fi # Check for kernel source if [ ! -e "${KERNEL_SOURCE_DIR}/include" ]; then echo "Following kernal source directory not found: ${KERNEL_SOURCE_DIR}/include" >>${DKS_MODULE_BUILD_LOGFILE} return ${STATUS_NO_KERNEL_SOURCE} fi # Prepare DKS build directory if [ -d ${DKS_VARDATA_BUILD_DIR} ]; then rm -rf ${DKS_VARDATA_BUILD_DIR} fi mkdir -p ${DKS_VARDATA_BUILD_DIR} mkdir -p ${DKS_VARDATA_MODULE_DIR} # Copy files to DKS build directory cp -fp ${DKS_INSTALL_MODULE_DIR}/*.c ${DKS_VARDATA_MODULE_DIR} 2>>${DKS_MODULE_BUILD_LOGFILE} cp -fp ${DKS_INSTALL_MODULE_DIR}/*.h ${DKS_VARDATA_MODULE_DIR} 2>>${DKS_MODULE_BUILD_LOGFILE} cp -fp ${DKS_INSTALL_MODULE_DIR}/*.mak ${DKS_VARDATA_MODULE_DIR} mv -f ${DKS_VARDATA_MODULE_DIR}/${ISVCDD_MODULE_NAME}.mak ${DKS_VARDATA_MODULE_DIR}/Makefile if [ ${LOC_KERNEL_IS_GT_2_4} = 0 ]; then # Set up kernel current version directory in DKS variable data directory mkdir -p ${DKS_VARDATA_CURRENT_VER_DIR} ln -sf ${KERNEL_SOURCE_DIR}/include ${DKS_VARDATA_CURRENT_VER_DIR} # Set up kernel generic version directory in DKS variable data directory mkdir -p ${DKS_VARDATA_GENERIC_VER_DIR} ln -sf ${KERNEL_SOURCE_DIR}/arch ${DKS_VARDATA_GENERIC_VER_DIR} ln -sf ${KERNEL_SOURCE_DIR}/scripts ${DKS_VARDATA_GENERIC_VER_DIR} # Copy .config file or configs/* if necessary cd ${KERNEL_SOURCE_DIR} if [ -e .config ]; then cp -f ${KERNEL_SOURCE_DIR}/.config ${DKS_VARDATA_CURRENT_VER_DIR} 2>>${DKS_MODULE_BUILD_LOGFILE} else cp -rf configs/* ${DKS_VARDATA_CURRENT_VER_DIR} 2>>${DKS_MODULE_BUILD_LOGFILE} fi if [ $? != 0 ]; then echo "Kernel source not found" >>${DKS_MODULE_BUILD_LOGFILE} return ${STATUS_NO_KERNEL_SOURCE} fi # Copy DKS master makefile to DKS build directory cp -fp ${DKS_INSTALL_BASE_DIR}/Makefile ${DKS_VARDATA_BUILD_DIR} # Copy files to kernel generic version directory cp -fp ${DKS_INSTALL_COMMON_DIR}/Rules.make ${DKS_VARDATA_GENERIC_VER_DIR} cp -fp ${DKS_INSTALL_COMMON_DIR}/Makefile ${DKS_VARDATA_GENERIC_VER_DIR} # Copy kernel-specific source files to DKS build directory if [ -d ${DKS_INSTALL_MODULE_DIR}/kernel24 ]; then cp -fp ${DKS_INSTALL_MODULE_DIR}/kernel24/*.c ${DKS_VARDATA_MODULE_DIR} 2>>${DKS_MODULE_BUILD_LOGFILE} cp -fp ${DKS_INSTALL_MODULE_DIR}/kernel24/*.h ${DKS_VARDATA_MODULE_DIR} 2>>${DKS_MODULE_BUILD_LOGFILE} fi # Change to directory with DKS master makefile cd ${DKS_VARDATA_BUILD_DIR} # Compile make KERNEL_IS_GT_2_4=${LOC_KERNEL_IS_GT_2_4} >>${DKS_MODULE_BUILD_LOGFILE} 2>&1 MAKE_STATUS=$? else # Copy kernel-specific source files to DKS build directory if [ -d ${DKS_INSTALL_MODULE_DIR}/kernel26 ]; then cp -fp ${DKS_INSTALL_MODULE_DIR}/kernel26/*.c ${DKS_VARDATA_MODULE_DIR} 2>>${DKS_MODULE_BUILD_LOGFILE} cp -fp ${DKS_INSTALL_MODULE_DIR}/kernel26/*.h ${DKS_VARDATA_MODULE_DIR} 2>>${DKS_MODULE_BUILD_LOGFILE} fi # Change to DKS module build directory cd ${DKS_VARDATA_MODULE_DIR} # Compile make -C ${KERNEL_SOURCE_DIR} SUBDIRS=${PWD} KERNEL_IS_GT_2_4=${LOC_KERNEL_IS_GT_2_4} modules >>${DKS_MODULE_BUILD_LOGFILE} 2>&1 MAKE_STATUS=$? fi # Check compile status if [ ${MAKE_STATUS} != 0 ]; then echo "${ISVCDD_MODULE_NAME} compile failed" >>${DKS_MODULE_BUILD_LOGFILE} return ${STATUS_DKS_COMPILE_ERROR} fi # Change to DKS module build directory cd ${DKS_VARDATA_MODULE_DIR} # Link make dkslink KERNEL_IS_GT_2_4=${LOC_KERNEL_IS_GT_2_4} >>${DKS_MODULE_BUILD_LOGFILE} 2>&1 if [ $? != 0 ]; then echo "${ISVCDD_MODULE_NAME} link failed" >>${DKS_MODULE_BUILD_LOGFILE} return ${STATUS_DKS_LINK_ERROR} fi if [ ! -f ${ISVCDD} ]; then echo "${ISVCDD_MODULE_NAME} binary not found" >>${DKS_MODULE_BUILD_LOGFILE} return ${STATUS_DKS_LINK_ERROR} fi # Remove file on successful build rm -f ${DKS_MODULE_BUILD_LOGFILE} # Pathfilename to device driver built using DKS # returned via ISVCDD environment variable return ${STATUS_NO_ERROR} } # instsvcdrv_build_driver ############################################################################### # Function: instsvcdrv_dks_cleanup # Description: Perform DKS cleanup # Returns: LSB status codes ############################################################################### instsvcdrv_dks_cleanup() { DKS_VARDATA_BASE_DIR="${ISVCDD_VARDATAPATH}/drivers/${ISVCDD_PROC_ARCH}/dks" DKS_VARDATA_BUILD_DIR="${DKS_VARDATA_BASE_DIR}/build" # Remove DKS build directory if [ -d ${DKS_VARDATA_BUILD_DIR} ]; then rm -rf ${DKS_VARDATA_BUILD_DIR} fi return ${STATUS_NO_ERROR} } # instsvcdrv_dks_cleanup ############################################################################### # Function: instsvcdrv_supt_esx4orlater # Description: Determine if OS is ESX 4 or later # Returns: 0 if ESX 4 or later # 1 if not ESX 4 or later ############################################################################### instsvcdrv_supt_esx4orlater() { local vmwareapp=/usr/bin/vmware local esx4orlater=1 local verinfo local ver local majorver # check if vmware app exists if [ -x ${vmwareapp} ]; then # get version info verinfo=$(${vmwareapp} -v) # check if ESX if $(echo ${verinfo} | grep "ESX" >/dev/null); then # get version if $(echo ${verinfo} | grep -i "VMware ESX Server" >/dev/null); then ver=$(echo ${verinfo} | awk '{print $4}') elif $(echo ${verinfo} | grep -i "VMware ESX" >/dev/null); then ver=$(echo ${verinfo} | awk '{print $3}') else ver= fi # check if version 4 or later if [ ! -z "${ver}" ]; then majorver=$(echo ${ver} | sed 's/\./ /g' | awk '{print $1}') if [ ${majorver} -ge 4 ]; then esx4orlater=0 fi fi fi fi return ${esx4orlater} } # instsvcdrv_supt_esx4orlater ############################################################################### # Function: instsvcdrv_openipmi_thread_status # Description: Check if the OpenIPMI "kipmi0" thread is running or not. # Returns: LSB status codes ############################################################################### instsvcdrv_openipmi_thread_status() { local status # Check if the kipmi0 thread is running or not COUNT=`ps -e | grep -c kipmi0`; if [ ${COUNT} -ge 1 ]; then debugprint "Thread is running" status=${STATUS_RUNNING} else debugprint "Thread is not running" status=${STATUS_NOT_RUNNING} fi return ${status} } # instsvcdrv_openipmi_thread_status ############################################################################### # Function: instsvcdrv_openipmi_check_files_for_kipmid_options # Description: Determine if either the "kipmid_max_busy_us" option or the # "force_kipmid" option is currently specified in any # modprobe-related config file # Returns: LSB status codes # Following is the set of codes potentially returned: # STATUS_NO_ERROR - If neither option is found. # STATUS_FORCE_THREAD_OPTION_FOUND # STATUS_TUNE_THREAD_OPTION_FOUND ############################################################################### instsvcdrv_openipmi_check_files_for_kipmid_options() { local status MODPROBE_CONF_FILE="/etc/modprobe.conf" MODPROBE_CONF_LOCAL_FILE="/etc/modprobe.conf.local" MODPROBE_CONF_DIST_FILE="/etc/modprobe.conf.dist" MODPROBE_CONF_D_DIR="/etc/modprobe.d" # Get a list of all files in the "/etc/modprobe.d" directory # First check that directory exists if [ -d "${MODPROBE_CONF_D_DIR}" ]; then SUBDIR_LIST=$(ls ${MODPROBE_CONF_D_DIR} 2>/dev/null) else SUBDIR_LIST="" fi SUBDIR_FILE_LIST="" for file_name in ${SUBDIR_LIST}; do SUBDIR_FILE_LIST="${SUBDIR_FILE_LIST} ${MODPROBE_CONF_D_DIR}/${file_name}" done # Set the file list FILE_LIST="${MODPROBE_CONF_FILE} ${MODPROBE_CONF_LOCAL_FILE} ${MODPROBE_CONF_DIST_FILE} ${SUBDIR_FILE_LIST}" # Check if either the "kipmid_max_busy_us" option or the "force_kipmid" # option is already specified in at least one of the given files for file_name in ${FILE_LIST}; do # Check if file exists if [ -f ${file_name} ]; then # Check if file currently contains an options line like: # "options ipmi_si kipmid_max_busy_us=" grep -iq '^[[:space:]]*options[[:space:]]\+ipmi_si[[:space:]]\+kipmid_max_busy_us=' ${file_name} if [ $? -eq 0 ]; then # File does contain options line debugprint "File ${file_name} contains the ${OPENIPMI_KIPMID_MAX_BUSY_US_OPTION} options line" return ${STATUS_TUNE_THREAD_OPTION_FOUND} fi # Check if file currently contains an options line like: # "options ipmi_si force_kipmid=" grep -iq '^[[:space:]]*options[[:space:]]\+ipmi_si[[:space:]]\+force_kipmid=' ${file_name} if [ $? -eq 0 ]; then # File does contain options line debugprint "File ${file_name} contains the ${OPENIPMI_FORCE_KIPMID_OPTION} options line" return ${STATUS_FORCE_THREAD_OPTION_FOUND} fi fi done debugprint "No files contain either options line" # Neither options line was found return ${STATUS_NO_ERROR} } # instsvcdrv_openipmi_check_files_for_kipmid_options ############################################################################### # Function: instsvcdrv_openipmi_force_thread_supported # Description: Determine if the "force_kipmid" option is supported by the # OpenIPMI "ipmi_si" module on the current OS. # Returns: LSB status codes ############################################################################### instsvcdrv_openipmi_force_thread_supported() { local status # Check if support for forcing the thread is enabled for this script if [ ${FORCE_THREAD_FEATURE_SUPPORTED} -ne 1 ]; then debugprint "Support for enabling or disabling the thread is disabled for this script" return ${STATUS_FORCE_THREAD_NOT_SUPPORTED} fi # Check for "force_kipmid" option modinfo ${OPENIPMI_SI_MODULE} 2>/dev/null | grep ${OPENIPMI_FORCE_KIPMID_OPTION} >/dev/null 2>&1 if [ $? -ne 0 ]; then debugprint "The ${OPENIPMI_FORCE_KIPMID_OPTION} option is not supported by module ${OPENIPMI_SI_MODULE}" return ${STATUS_FORCE_THREAD_NOT_SUPPORTED} fi # Check if OpenIPMI driver is currently running instsvcdrv_status_openipmi quiet if [ $? -ne ${STATUS_NO_ERROR} ]; then debugprint "OpenIPMI driver is stopped: ${OPENIPMI_FORCE_KIPMID_OPTION} option is not available for use" return ${STATUS_IPMI_DRIVER_STOPPED} fi # Check if either the "kipmid_max_busy_us" option or the "force_kipmid" # option is already specified in the modprobe.conf file or related files instsvcdrv_openipmi_check_files_for_kipmid_options status=$? if [ ${status} -eq ${STATUS_TUNE_THREAD_OPTION_FOUND} ]; then debugprint "A ${OPENIPMI_KIPMID_MAX_BUSY_US_OPTION} options line is already specified in a modprobe-related config file" debugprint "Therefore this script will not attempt to enable or disable the thread" return ${STATUS_FORCE_THREAD_NOT_SUPPORTED} elif [ ${status} -eq ${STATUS_FORCE_THREAD_OPTION_FOUND} ]; then debugprint "A ${OPENIPMI_FORCE_KIPMID_OPTION} options line is already specified in a modprobe-related config file" debugprint "Therefore this script will not attempt to enable or disable the thread" return ${STATUS_FORCE_THREAD_NOT_SUPPORTED} fi debugprint "${OPENIPMI_FORCE_KIPMID_OPTION} option is supported by module ${OPENIPMI_SI_MODULE}" return ${STATUS_NO_ERROR} } # instsvcdrv_openipmi_force_thread_supported ############################################################################### # Function: instsvcdrv_openipmi_force_thread # Description: Attempt to enable or disable the kipmi0 thread of the OpenIPMI # ipmi_si module # Parameter1: Either "enable" or "disable" # Parameter2: [Optional] Either "true" or "false" # Controls whether or not a failure to unload module is logged # Returns: LSB status codes ############################################################################### instsvcdrv_openipmi_force_thread() { local arg1=$1 local arg2="false" local status # Validate the parameter if [ "${arg1}" != "enable" ] && [ "${arg1}" != "disable" ]; then debugprint "Invalid parameter passed: ${arg1}" return ${STATUS_INVALID_ARG} fi # Process optional parameter #2 # (Note: Default is "false") if [ ! -z "$2" ]; then if [ `echo $2 | grep -Ec "(1|yes|YES|Yes|true|True|TRUE)"` -eq 1 ]; then arg2="true" fi fi # Check if the "force_kipmid" option is supported instsvcdrv_openipmi_force_thread_supported status=$? if [ ${status} -ne ${STATUS_NO_ERROR} ]; then return ${status} fi # Check if the kipmi0 thread is already enabled/disabled COUNT=`ps -e | grep -c kipmi0`; if [ "${arg1}" = "enable" ]; then # Check if thread is enabled if [ ${COUNT} -ge 1 ]; then debugprint "Thread is already enabled" return ${STATUS_NO_ERROR} fi # "disable" case else # Check if thread is disabled if [ ${COUNT} -eq 0 ]; then debugprint "Thread is already disabled" return ${STATUS_NO_ERROR} fi fi # unload module debugprint "Unloading OpenIPMI ${OPENIPMI_SI_MODULE} module" modprobe -q -r ${OPENIPMI_SI_MODULE} > /dev/null 2>&1 if [ $? -ne 0 ]; then # Display and log an error message ERRMSG1="Failed to unload module ${OPENIPMI_SI_MODULE}" ERRMSG3="ipmi driver may be in use" if [ "${arg1}" = "enable" ]; then ERRMSG2="(while preparing to enable kipmi0 thread)" debugprint "${ERRMSG1} ${ERRMSG2}" debugprint "${ERRMSG3}" if [ "${arg2}" = "true" ]; then instsvcdrv_supt_logmessage "${ERRMSG1} ${ERRMSG2} : ${ERRMSG3}" fi # "disable" case else ERRMSG2="(while preparing to disable kipmi0 thread)" debugprint "${ERRMSG1} ${ERRMSG2}" debugprint "${ERRMSG3}" if [ "${arg2}" = "true" ]; then instsvcdrv_supt_logmessage "${ERRMSG1} ${ERRMSG2} : ${ERRMSG3}" fi fi return ${STATUS_GENERIC_ERROR} fi # load module, passing the "force_kipmid" option appropriately # as "1" ("enabled") or "0" ("disabled") if [ "${arg1}" = "enable" ] then # enable kipmi0 thread debugprint "Loading OpenIPMI ${OPENIPMI_SI_MODULE} module with ${OPENIPMI_FORCE_KIPMID_OPTION}=1 option" modprobe ${OPENIPMI_SI_MODULE} ${OPENIPMI_FORCE_KIPMID_OPTION}=1 > /dev/null 2>&1 # "disable" case else # disable kipmi0 thread debugprint "Loading OpenIPMI ${OPENIPMI_SI_MODULE} module with ${OPENIPMI_FORCE_KIPMID_OPTION}=0 option" modprobe ${OPENIPMI_SI_MODULE} ${OPENIPMI_FORCE_KIPMID_OPTION}=0 > /dev/null 2>&1 fi if [ $? -ne 0 ]; then # Display and log an error message ERRMSG1="Failed to load module ${OPENIPMI_SI_MODULE}" if [ "${arg1}" = "enable" ]; then ERRMSG2="(while trying to enable kipmi0 thread)" debugprint "${ERRMSG1} ${ERRMSG2}" instsvcdrv_supt_logmessage "${ERRMSG1} ${ERRMSG2}" # "disable" case else ERRMSG2="(while trying to disable kipmi0 thread)" debugprint "${ERRMSG1} ${ERRMSG2}" instsvcdrv_supt_logmessage "${ERRMSG1} ${ERRMSG2}" fi return ${STATUS_GENERIC_ERROR} fi # udev can take several seconds to create /dev/ipmi0, # but it happens asynchronously, so delay here locdelay=${DEV_IPMI_TIMEOUT} while [ ! -e ${OPENIPMI_DEVNODE} -a ${locdelay} -gt 0 ]; do locdelay=$((locdelay - 1)) sleep 1 done # Module loaded. Now double check if kipmi0 thread is now enabled/disabled COUNT=`ps -e | grep -c kipmi0`; if [ "${arg1}" = "enable" ]; then # Check if still disabled if [ ${COUNT} -eq 0 ]; then # Display and log an error message ERRMSG="Failed to enable kipmi0 thread" debugprint "${ERRMSG}" instsvcdrv_supt_logmessage "${ERRMSG}" return ${STATUS_GENERIC_ERROR} fi # "disable" case else # Check if still enabled if [ ${COUNT} -ge 1 ]; then # Display and log an error message ERRMSG="Failed to disable kipmi0 thread" debugprint "${ERRMSG}" instsvcdrv_supt_logmessage "${ERRMSG}" return ${STATUS_GENERIC_ERROR} fi fi # Display and log a status message LOGMSG="${arg1}d kipmi0 thread" debugprint "${LOGMSG}" instsvcdrv_supt_logmessage "${LOGMSG}" return ${STATUS_NO_ERROR} } # instsvcdrv_openipmi_force_thread ############################################################################### # Function: instsvcdrv_openipmi_check_force_thread_support # Description: Determine the state of the support of the "force_kipmid" # option of OpenIPMI "ipmi_si" module on the current OS. # Returns: LSB status codes # Following is the set of codes potentially returned: # STATUS_FORCE_THREAD_NOT_SUPPORTED # STATUS_IPMI_DRIVER_STOPPED # STATUS_OPTION_SUPERSEDED # STATUS_OPTION_NOT_SUPPORTED # STATUS_OPTION_SUPPORTED_BUT_NOT_SET # STATUS_OPTION_SUPPORTED_AND_SET ############################################################################### instsvcdrv_openipmi_check_force_thread_support() { local status # Check if support for forcing the thread is enabled for this script if [ ${FORCE_THREAD_FEATURE_SUPPORTED} -ne 1 ]; then debugprint "Support for enabling or disabling the thread is disabled for this script" return ${STATUS_FORCE_THREAD_NOT_SUPPORTED} fi # Check for "force_kipmid" option modinfo ${OPENIPMI_SI_MODULE} 2>/dev/null | grep ${OPENIPMI_FORCE_KIPMID_OPTION} >/dev/null 2>&1 if [ $? -ne 0 ]; then debugprint "The ${OPENIPMI_FORCE_KIPMID_OPTION} option is not supported by module ${OPENIPMI_SI_MODULE}" return ${STATUS_OPTION_NOT_SUPPORTED} fi # Check if OpenIPMI driver is currently running instsvcdrv_status_openipmi quiet if [ $? -ne ${STATUS_NO_ERROR} ]; then debugprint "OpenIPMI driver is stopped: ${OPENIPMI_FORCE_KIPMID_OPTION} option is not available for use" return ${STATUS_IPMI_DRIVER_STOPPED} fi # Check if either the "kipmid_max_busy_us" option or the "force_kipmid" # option is already specified in the modprobe.conf file or related files # (NOTE: In the case where the "kipmid_max_busy_us" option is set in a file, # we effectively treat the "kipmid_max_busy_us" option as superseding the # "force_kipmid" option.) instsvcdrv_openipmi_check_files_for_kipmid_options status=$? if [ ${status} -eq ${STATUS_TUNE_THREAD_OPTION_FOUND} ]; then debugprint "A ${OPENIPMI_KIPMID_MAX_BUSY_US_OPTION} options line is already specified in a modprobe-related config file" debugprint "The ${OPENIPMI_FORCE_KIPMID_OPTION} option is superseded" return ${STATUS_OPTION_SUPERSEDED} elif [ ${status} -eq ${STATUS_FORCE_THREAD_OPTION_FOUND} ]; then debugprint "A ${OPENIPMI_FORCE_KIPMID_OPTION} options line is already specified in a modprobe-related config file" debugprint "The ${OPENIPMI_FORCE_KIPMID_OPTION} option is supported, and is currently set" return ${STATUS_OPTION_SUPPORTED_AND_SET} fi # Also check if the "kipmid_max_busy_us" option vale is already set directly # (i.e., may have been set directly with an "echo" command, rather than # via an options line in a modprobe.conf related file) instsvcdrv_openipmi_check_tune_thread_support if [ $? -eq ${STATUS_OPTION_SUPPORTED_AND_SET} ]; then debugprint "The ${OPENIPMI_FORCE_KIPMID_OPTION} option is superseded" return ${STATUS_OPTION_SUPERSEDED} fi debugprint "The ${OPENIPMI_FORCE_KIPMID_OPTION} option is supported, but is not currently set" return ${STATUS_OPTION_SUPPORTED_BUT_NOT_SET} } # instsvcdrv_openipmi_check_force_thread_support ############################################################################### # Function: instsvcdrv_openipmi_check_tune_thread_support # Description: Determine the state of the support of the "kipmid_max_busy_us" # option of OpenIPMI "ipmi_si" module on the current OS. # Returns: LSB status codes # Following is the set of codes potentially returned: # STATUS_IPMI_DRIVER_STOPPED # STATUS_TUNE_THREAD_NOT_SUPPORTED # STATUS_OPTION_NOT_SUPPORTED # STATUS_OPTION_SUPPORTED_BUT_NOT_SET # STATUS_OPTION_SUPPORTED_AND_SET ############################################################################### instsvcdrv_openipmi_check_tune_thread_support() { # Check if support for setting the tuning option is enabled for this script if [ ${TUNE_THREAD_FEATURE_SUPPORTED} -ne 1 ]; then debugprint "Support for the ${OPENIPMI_KIPMID_MAX_BUSY_US_OPTION} is disabled for this script" return ${STATUS_TUNE_THREAD_NOT_SUPPORTED} fi # Check for "kipmid_max_buys_us" option modinfo ${OPENIPMI_SI_MODULE} 2>/dev/null | grep ${OPENIPMI_KIPMID_MAX_BUSY_US_OPTION} >/dev/null 2>&1 if [ $? -ne 0 ]; then debugprint "The ${OPENIPMI_KIPMID_MAX_BUSY_US_OPTION} option is not supported by module ${OPENIPMI_SI_MODULE}" return ${STATUS_OPTION_NOT_SUPPORTED} fi # Check if OpenIPMI driver is currently running instsvcdrv_status_openipmi quiet if [ $? -ne ${STATUS_NO_ERROR} ]; then debugprint "OpenIPMI driver is stopped: ${OPENIPMI_KIPMID_MAX_BUSY_US_OPTION} option is not available for use" return ${STATUS_IPMI_DRIVER_STOPPED} fi # Check if the "kipmid_max_busy_us" option is already set or not # We do this by checking the option's parameter file # As part of this check, first do an extra sanity check that option file exists if [ ! -e "${OPENIPMI_KIPMID_MAX_BUSY_US_OPTION_FILE}" ]; then debugprint "The ${OPENIPMI_KIPMID_MAX_BUSY_US_OPTION_FILE} file does not exist" debugprint "(Most likely the OpenIPMI driver is stopped, or needs to be restarted)" debugprint "The ${OPENIPMI_KIPMID_MAX_BUSY_US_OPTION} option is therefore not supported" return ${STATUS_OPTION_NOT_SUPPORTED} fi OPTION_VALUE="`cat ${OPENIPMI_KIPMID_MAX_BUSY_US_OPTION_FILE}`" if [ "${OPTION_VALUE}" = "" ]; then debugprint "The ${OPENIPMI_KIPMID_MAX_BUSY_US_OPTION} option is supported, but is currently not set" return ${STATUS_OPTION_SUPPORTED_BUT_NOT_SET} fi debugprint "The ${OPENIPMI_KIPMID_MAX_BUSY_US_OPTION} option is supported, and is currently set to ${OPTION_VALUE}" return ${STATUS_OPTION_SUPPORTED_AND_SET} } # instsvcdrv_openipmi_check_tune_thread_support ############################################################################### # Function: instsvcdrv_openipmi_set_thread_tuning_value # Description: Attempt to set the "kipmid_max_busy_us" option/parameter # value of the ipmi_si module of the OpenIPMI driver. # This option is referred to as "tuning" option. # Parameter: A number between 0-500 # Returns: LSB status codes # Following is the set of codes potentially returned: # STATUS_NO_ERROR # STATUS_GENERIC_ERROR # STATUS_INVALID_ARG ############################################################################### instsvcdrv_openipmi_set_thread_tuning_value() { local arg1=$1 local status # Validate parameter - parameter is required if [ -z "${arg1}" ]; then debugprint "Parameter is missing" debugprint "A tuning value between 0-500 must be passed" return ${STATUS_INVALID_ARG} fi # Validate parameter # Must be a value from 0-500 if [ "${arg1}" -lt 0 ] || [ "${arg1}" -gt 500 ]; then debugprint "Invalid tuning value passed (must be between 0-500): ${arg1}" return ${STATUS_INVALID_ARG} fi # Check if the "kipmid_max_busy_us" option is supported instsvcdrv_openipmi_check_tune_thread_support status=$? if [ ${status} -ne ${STATUS_OPTION_SUPPORTED_BUT_NOT_SET} ] && [ ${status} -ne ${STATUS_OPTION_SUPPORTED_AND_SET} ]; then debugprint "Not attempting to set the ${OPENIPMI_KIPMID_MAX_BUSY_US_OPTION} option value" return ${status} fi # Try to set the kipmid_max_busy_us option value echo "${arg1}" > "${OPENIPMI_KIPMID_MAX_BUSY_US_OPTION_FILE}" status=$? if [ ${status} -ne 0 ]; then # Display and log an error message ERRMSG1="Failed while trying to set the ${OPENIPMI_KIPMID_MAX_BUSY_US_OPTION} option of the ipmi_si module to ${arg1}" ERRMSG2="'echo' command returned a status code of: ${status}" debugprint "${ERRMSG1}" debugprint "${ERRMSG2}" instsvcdrv_supt_logmessage "${ERRMSG1}; ${ERRMSG2}" return ${STATUS_GENERIC_ERROR} fi # Display and log a status message LOGMSG="Set the ${OPENIPMI_KIPMID_MAX_BUSY_US_OPTION} option of the ipmi_si module to ${arg1}" debugprint "${LOGMSG}" instsvcdrv_supt_logmessage "${LOGMSG}" return ${STATUS_NO_ERROR} } # instsvcdrv_openipmi_set_thread_tuning_value ############################################################################### # Function: instsvcdrv_openipmi_check_interrupt_support # Description: Checks if IPMI driver support interrupts # Parameter: N/A # Returns: LSB status codes # Following is the set of codes potentially returned: # STATUS_NO_ERROR # STATUS_OPTION_NOT_SUPPORTED ############################################################################### instsvcdrv_openipmi_check_interrupt_support() { local arg1=$1 local status # check IPMI driver grep -iq '^[[:space:]]*interrupts_enabled:[[:space:]]' ${OPENIPMI_IPMI_STATS_FILE} if [ $? -eq 1 ]; then # IPMI driver supports interrupts debugprint "IPMI interrupts supported" return ${STATUS_INTERRUPTS_SUPPORTED} else # IPMI driver does not support interrupts debugprint "IPMI interrupts not supported" return ${STATUS_INTERRUPTS_NOT_SUPPORTED} fi } # instsvcdrv_openipmi_check_interrupt_support ############################################################################### # Function: instsvcdrv_supt_showsuccess <message> # Description: Display service success message # Returns: none ############################################################################### instsvcdrv_supt_showsuccess() { local MSG="$1" if [ ${OS_SCRIPT_FUNCTIONS} = ${OS_SCRIPT_FUNCTIONS_LSB} ]; then log_success_msg "${MSG}" elif [ ${OS_SCRIPT_FUNCTIONS} = ${OS_SCRIPT_FUNCTIONS_RH} ]; then echo -n "${MSG}" echo_success echo else echo -n "${MSG}" printf "%b" \\033[45G echo "OK" fi } # instsvcdrv_supt_showsuccess ############################################################################### # Function: instsvcdrv_supt_showfailure <message> # Description: Display service failure message # Returns: none ############################################################################### instsvcdrv_supt_showfailure() { local MSG="$1" if [ ${OS_SCRIPT_FUNCTIONS} = ${OS_SCRIPT_FUNCTIONS_LSB} ]; then log_failure_msg "${MSG}" elif [ ${OS_SCRIPT_FUNCTIONS} = ${OS_SCRIPT_FUNCTIONS_RH} ]; then echo -n "${MSG}" echo_failure echo else echo -n "${MSG}" printf "%b" \\033[45G echo "FAILED" fi } # instsvcdrv_supt_showfailure ############################################################################### # Function: instsvcdrv_supt_showwarning <message> # Description: Display service warning message # Returns: none ############################################################################### instsvcdrv_supt_showwarning() { local MSG="$1" if [ ${OS_SCRIPT_FUNCTIONS} = ${OS_SCRIPT_FUNCTIONS_LSB} ]; then log_warning_msg "${MSG}" elif [ ${OS_SCRIPT_FUNCTIONS} = ${OS_SCRIPT_FUNCTIONS_RH} ]; then echo -n "${MSG}" echo_warning echo else echo -n "${MSG}" printf "%b" \\033[45G echo "WARNING" fi } # instsvcdrv_supt_showwarning ############################################################################### # Function: instsvcdrv_supt_logmessage <message> # Description: Log message to OS log # Returns: none ############################################################################### instsvcdrv_supt_logmessage() { logger -t "${ISVCDD_SCRIPT_NAME}" "$1" } # instsvcdrv_supt_logmessage ############################################################################### # Function: instsvcdrv_supt_lock # Description: Prevent execution of another command # Returns: none ############################################################################### instsvcdrv_supt_lock() { # If another command is executing, give it some time to finish SECS=0 while [ -f ${ISVCDD_SCRIPT_LOCKFILE} ] && [ ${SECS} -lt 60 ]; do sleep 1 SECS=$((SECS + 1)) done touch ${ISVCDD_SCRIPT_LOCKFILE} } # instsvcdrv_supt_lock ############################################################################### # Function: instsvcdrv_supt_unlock # Description: Allow execution of another command # Returns: none ############################################################################### instsvcdrv_supt_unlock() { rm -f ${ISVCDD_SCRIPT_LOCKFILE} } # instsvcdrv_supt_unlock ############################################################################### # Check command line parameter for action to perform ############################################################################### case "$1" in start) # stop running users if openipmi is about to be started instsvcdrv_stop_users_before_start_openipmi # start service instsvcdrv_supt_lock instsvcdrv_start EXIT_STATUS=$? instsvcdrv_supt_unlock # re-start previously running users if [ ${EXIT_STATUS} = ${STATUS_NO_ERROR} ]; then # note: ignore exit code from instsvcdrv_start_users instsvcdrv_start_users fi ;; stop) # stop service (and any users that are currently running) # note: ignore exit code from instsvcdrv_stop_users instsvcdrv_stop_users instsvcdrv_supt_lock instsvcdrv_stop EXIT_STATUS=$? instsvcdrv_supt_unlock ;; restart|force-reload) # restart service (and any users that are currently running) # note: ignore exit code from instsvcdrv_stop_users instsvcdrv_stop_users instsvcdrv_supt_lock instsvcdrv_stop EXIT_STATUS=$? instsvcdrv_supt_unlock if [ ${EXIT_STATUS} = ${STATUS_NO_ERROR} ]; then instsvcdrv_supt_lock instsvcdrv_start EXIT_STATUS=$? instsvcdrv_supt_unlock # note: ignore exit code from instsvcdrv_start_users instsvcdrv_start_users fi ;; status) # print and return current status of service instsvcdrv_supt_lock instsvcdrv_status EXIT_STATUS=$? instsvcdrv_supt_unlock ;; status-quiet) # return current status of service instsvcdrv_supt_lock instsvcdrv_status_quiet EXIT_STATUS=$? instsvcdrv_supt_unlock ;; reload) # reload configuration echo "${ISVCDD_SCRIPT_NAME}: reload not supported" EXIT_STATUS=${STATUS_NOT_IMPLEMENTED} ;; startusers) # start users of the service FORCE_START_USERS=1 instsvcdrv_start_users EXIT_STATUS=$? ;; stopusers) # stop users of the service instsvcdrv_stop_users EXIT_STATUS=$? ;; restartall) # restart service and all users, regardless of whether users # are currently running or not # note: ignore exit code from instsvcdrv_stop_users instsvcdrv_stop_users instsvcdrv_supt_lock instsvcdrv_stop EXIT_STATUS=$? instsvcdrv_supt_unlock if [ ${EXIT_STATUS} = ${STATUS_NO_ERROR} ]; then instsvcdrv_supt_lock instsvcdrv_start EXIT_STATUS=$? instsvcdrv_supt_unlock # force start of all users FORCE_START_USERS=1 # note: ignore exit code from instsvcdrv_start_users instsvcdrv_start_users fi ;; build) # build drivers shift instsvcdrv_build "$@" EXIT_STATUS=$? ;; preupgrade) # prepare for upgrade instsvcdrv_preupgrade EXIT_STATUS=$? ;; preuninstall) # prepare for uninstall instsvcdrv_preuninstall EXIT_STATUS=$? ;; restart-forcekernelmatch) instsvcdrv_restart_forcekernelmatch EXIT_STATUS=$? ;; threadstatus) instsvcdrv_openipmi_thread_status EXIT_STATUS=$? ;; checkthreadsupport) instsvcdrv_openipmi_force_thread_supported EXIT_STATUS=$? ;; enablethread) instsvcdrv_openipmi_force_thread enable $2 EXIT_STATUS=$? ;; disablethread) instsvcdrv_openipmi_force_thread disable $2 EXIT_STATUS=$? ;; checkforcethreadsupport) instsvcdrv_openipmi_check_force_thread_support EXIT_STATUS=$? ;; checktunethreadsupport) instsvcdrv_openipmi_check_tune_thread_support EXIT_STATUS=$? ;; setthreadtuningvalue) instsvcdrv_openipmi_set_thread_tuning_value $2 EXIT_STATUS=$? ;; checkinterruptsupport) instsvcdrv_openipmi_check_interrupt_support EXIT_STATUS=$? ;; *) echo "${ISVCDD_SCRIPT_NAME}: Invalid argument" echo "Usage: ${ISVCDD_SCRIPT_NAME} {start|stop|restart|force-reload|status|startusers|stopusers|restartall}" EXIT_STATUS=${STATUS_INVALID_ARG} esac exit ${EXIT_STATUS} ############################################################################### # End Script ###############################################################################