Annotation of /trunk/initscripts/sysvinit/sbin/modules-update

#!/bin/bash
# vim:ts=4
# Distributed under the terms of the GNU General Public License v2
#
# This script will do:
#  - create /etc/modules.conf from /etc/modules.d/*
#  - create /etc/modprobe.conf from /etc/modprobe.d/*
#  - update modules.dep if modules.conf has been updated so depmod doesnt whine
#
# This is all for backwards compatibility.  In the perfect world, we would be
# running a linux-2.6 kernel and not have any modules.d directory.  Then there
# would be no work for us as module-init-tools automatically scans modprobe.d.
# Until that happens, we'll keep scanning and warning and being a pita.
#


MROOT="${MROOT%/}/"
[ "${MROOT}" = "${MROOT#/}" ] && MROOT="${PWD}/${MROOT}"
cd "${MROOT}"

argv0=${0##*/}
. /etc/init.d/functions || {
	echo "${argv0}: Could not source /etc/init.d/functions!" 1>&2
	exit 1
}
umask 022
esyslog() { :; }
export PATH=/sbin:${PATH}

#
# Setup some variables
#

HEADER="### This file is automatically generated by modules-update"
HEADER_OLD="### This file is automatically generated by update-modules"
VERSION="1.5"

#
# Parse command-line
#

VERBOSE=0
DEBUG=0
FORCE="false"
BACKUP="false"
KV=
while [ -n "$1" ] ; do
	case $1 in
		--assume-kernel=*) KV=${1#*=};;
		-b|--backup)       BACKUP="true";;
		-f|--force|force)  FORCE="true";;
		-v|--verbose)      ((VERBOSE+=1));;
		-d|--debug)        ((DEBUG+=1));;
		-V|--version)      exec echo "${argv0}: ${VERSION}";;
		-h|--help)
			cat <<-EOF
			Usage: modules-update [options]

			Options:
			 --assume-kernel=KV  Assume the kernel is at least version KV
			 -b, --backup        Backup existing config files (add .old ext)
			 -f, --force         Force execution in face of bad things
			 -v, --verbose       Be a bit more verbose in what we do
			 -d, --debug         Helpful debug output
			 -V, --version       Dump version info
			 -h, --help          This help screen, duh
			EOF
			exit 0
			;;
		*)
			echo "Error: I don't understand $1"
			exit 1
			;;
	esac
	shift
done

if [ ! -w ./etc ] ; then
	echo "You must be root to do this"
	exit 2
fi

[ ${DEBUG} -gt 0 ] && set -x

veinfo() { [ ${VERBOSE} -gt 0 ] && echo "$*" ; return 0 ; }
vewarn() { [ ${VERBOSE} -gt 0 ] && echo "$*" ; return 0 ; }

[ "${MROOT}" != "/" ] && veinfo "Operating on MROOT = '${MROOT}'"

#
# Let's check the optimal case first: nothing to do
#
if ! ${FORCE} ; then
	if [ ! -d "./etc/modules.d" ] ; then
		if [ ! -d "./etc/modprobe.d" ] ; then
			veinfo "No /etc/modules.d or /etc/modprobe.d dir; Nothing to do!"
			exit 0

		elif [ -e "./etc/modprobe.conf" ] ; then
			vewarn "You should put settings in /etc/modprobe.d/ rather than modprobe.conf"

		elif [ -e "./etc/modules.conf" ] ; then
			vewarn "If you only run linux-2.4, you should delete /etc/modules.conf"

		else
			veinfo "We have just /etc/modprobe.d; Nothing to do!"
			exit 0
		fi
	else
		vewarn "You have /etc/modules.d, so things need to get coalesced"
	fi
fi

#
# Build list of config files to generate and verify none
# have been modified in any way
#
for x in modprobe.conf modules.conf ; do
	x="./etc/${x}"
	[ -r ${x} ] || continue

	_header="$(sed -ne 1p ${x})"
	if [ "${_header}" != "${HEADER}" ] && [ "${_header}" != "${HEADER_OLD}" ]; then
		echo "Warning: ${x#.} has not been automatically generated"

		if ${FORCE} ; then
			echo "--force specified, (re)generating file anyway"
		else
			echo "Use \"modules-update force\" to force (re)generation"
			exit 1
		fi
	fi
done


#
# If the system doesnt have old modutils, then this is prob linux-2.6 only
#
if type -P modprobe.old > /dev/null || \
   LC_ALL=C modprobe -V 2>/dev/null | grep -qs "modprobe version"
then
	GENERATE_OLD="true"
else
	GENERATE_OLD="false"
fi


# Reset the sorting order since we depend on it
export LC_COLLATE="C"

KV=${KV:-$(uname -r)}


#
#  Desc: backup a config file if need be and replace with new one
# Usage: backup <old config file to backup> <new config file to replace with>
#    Ex: backup /etc/modules.conf /etc/modules.conf.tempfile
#
backup() {
	if ${BACKUP} && [ -e "$1" ] ; then
		mv -f "$1" "$1".old
	fi
	mv -f "$2" "$1"
}


#
#  Desc: Create module header
# Usage: create_header <config dir>
#    Ex: create_header /etc/modules.d
create_header() {
	local moddir=$1

	cat <<-EOF
	${HEADER}
	#
	# Please do not edit this file directly. If you want to change or add
	# anything please take a look at the files in ${moddir} and read
	# the manpage for modules-update(8).
	#
	EOF
}


#
#  Desc: Combine all config files in a dir and place output in a file
# Usage: generate_config <output config file> <config dir> <reference config dir> <silent>
#    Ex: generate_config /etc/modules.conf /etc/modules.d
#
generate_config() {
	local config=$1
	local moddir=$2
	local refdir=$3
	local silent=$4
	local tmpfile="${config}.$$"

	[ -z "${silent}" ] && echo "Updating ${config#./etc/}"

	create_header ${refdir:-${moddir}} > "${tmpfile}"

	for cfg in "${moddir}"/* ; do
		[ -d "${cfg}" ] && continue
		[ ! -r "${cfg}" ] && continue

		# Skip backup and RCS files #20597
		case ${cfg} in *~|*.bak|*,v) continue;; esac

		# If config file is found in the reference dir, then skip it
		[ -n "${refdir}" ] && [ -e "${refdir}/${cfg##*/}" ] && continue

		(
		echo "### modules-update: start processing ${cfg#.}"
		if [ -x "${cfg}" ] ; then
			# $cfg can be executable; nice touch, Wichert! :)
			"${cfg}"
		else
			cat "${cfg}"
		fi
		echo
		echo "### modules-update: end processing ${cfg#.}"
		echo
		) >> "${tmpfile}"
	done

	backup "${config}" "${tmpfile}"

	return 0
}


#
# Generate the old modules.conf file based upon all the snippets in
# modules.d.  Since modprobe doesnt handle modules.d, we need to gather
# the files together in modules.conf for it.
#

if [ ! -d "./etc/modules.d" ] ; then
	veinfo "No need to generate modules.conf :)"

elif ${FORCE} || is_older_than ./etc/modules.conf ./etc/modules.d ; then
	generate_config ./etc/modules.conf ./etc/modules.d

else
	veinfo "modules.conf: already up-to-date wheatness"
fi

#
# Call depmod to keep insmod from complaining that modules.conf is more
# recent then the modules.dep file.
#
if [ -e "./etc/modules.conf" ] ; then
	depfile=$(
		# the modules.conf file has optional syntax:
		# depfile=/path/to/modules.dep
		ret=$(sed -n -e '/^[[:space:]]*depfile=/s:.*=::p' ./etc/modules.conf)
		eval echo "${ret:-/lib/modules/${KV}/modules.dep}"
	)

	if [ -d "${depfile%/*}" ] ; then
		if [ ./etc/modules.conf -nt "${depfile}" ] ; then
			arch=$(uname -m)
			echo "Updating modules.dep"
			for cfg in /lib/modules/${KV}/build /usr/src/linux-${KV} \
			           /lib/modules/${KV} /boot /usr/src/linux ""
			do
				cfg=".${cfg}/System.map"
				for suffix in -genkernel-${arch}-${KV} -genkernel-'*'-${KV} -${KV} "" ; do
					scfg=$(echo ${cfg}${suffix})
					scfg=${scfg%% *}
					[ -f "${scfg}" ] && cfg=${scfg} && break 2
				done
				cfg=""
			done
			[ -n "${cfg}" ] && cfg="-F ${cfg}"
			depmod -b "${ROOT}" -a ${cfg} ${KV}
			veinfo "Ran: depmod -b '${ROOT}' -a ${cfg} ${KV}"
		else
			veinfo "modules.dep: already up-to-date goodness"
		fi
	else
		vewarn "The dir '${depfile}' does not exist, skipping call to depmod"
	fi
fi


#
# Generate the new modprobe.conf file if possible.  What this entails is
# grabbing details from the old modprobe via the -c option and sticking
# it in the newer config file.  This is useful for backwards compat support
# and for packages that provide older style /etc/modules.d/ files but not
# newer style /etc/modprobe.d/ files.
#
# First we try to use the script `generate-modprobe.conf` from the
# module-init-tools and if that fails us, we try and generate modprobe.conf
# ourselves from the /etc/modules.d/ files.
#
if ! type -P generate-modprobe.conf > /dev/null ; then
	vewarn "Skipping /etc/modprobe.conf generation (generate-modprobe.conf doesn't exist)"

elif ! ${FORCE} && ! is_older_than ./etc/modprobe.conf ./etc/modules.d ./etc/modprobe.d ; then
	veinfo "modprobe.conf: already up-to-date nutness"

elif [ ! -e ./etc/modules.conf -a ! -e ./etc/modules.d ] ; then
	veinfo "No need to generate modprobe.conf :)"
	rm -f ./etc/modprobe.conf

else
	#
	# First, bitch like crazy
	#
	for f in ./etc/modules.d/* ; do
		# hack: ignore baselayout ;x
		case ${f##*/} in
			aliases|i386) continue;;
		esac
		[ -e "${f}" ] || continue
		if [ ! -e "./etc/modprobe.d/${f##*/}" ] ; then
			echo "Please file a bug about ${f#.}: it needs an /etc/modprobe.d/${f##*/}"
		fi
	done

	generated_ok=0
	tmpfile="./etc/modprobe.conf.$$"

	#
	# First we try to use regular generate-modprobe.conf
	#
	if ${GENERATE_OLD} ; then
		echo "Updating modprobe.conf"
		create_header /etc/modprobe.d > "${tmpfile}"
		if generate-modprobe.conf ${ASSUME_KV:+--assume-kernel=${KV}} \
		   >> "${tmpfile}" 2> "${tmpfile}.err"
		then
			backup "./etc/modprobe.conf" "${tmpfile}"
			generated_ok=1
		else
			[[ ${VERBOSE} -gt 0 ]] && cat "${tmpfile}.err"
			echo "Warning: could not generate /etc/modprobe.conf!"
		fi
	fi

	#
	# If the helper script failed, we fall back to doing it by hand
	#
	if [[ ${generated_ok} -eq 0 ]] ; then
		echo "Updating modprobe.conf by hand"

		generate_config ./etc/modprobe.conf ./etc/modules.d ./etc/modprobe.d 0
		create_header /etc/modprobe.d > "${tmpfile}"

		# Just use generate-modprobe.conf to filter compatible syntax
		if TESTING_MODPROBE_CONF=./etc/modprobe.conf \
		   generate-modprobe.conf ${ASSUME_KV:+--assume-kernel=${KV}} \
		   >> "${tmpfile}" 2> "${tmpfile}.err"
		then
			# we use mv here instead of backup_config() as the call to
			# generate_config() above already took care of the backup
			mv -f "${tmpfile}" "./etc/modprobe.conf"
		else
			[[ ${VERBOSE} -gt 0 ]] && cat "${tmpfile}.err"
			echo "Warning: could not generate /etc/modprobe.conf!"
		fi
	fi

	#
	# Now append all the new files ... modprobe will not scan /etc/modprobe.d/
	# if /etc/modprobe.conf exists, so we need to append /etc/modprobe.conf with
	# /etc/modprobe.d/* ... http://bugs.gentoo.org/145962
	#
	if [[ -e ./etc/modprobe.conf ]] ; then
		for cfg in ./etc/modprobe.d/* ; do
			[ -d "${cfg}" ] && continue
			[ ! -r "${cfg}" ] && continue

			# Skip backup and RCS files #20597
			case ${cfg} in *~|*.bak|*,v) continue;; esac

			(
			echo
			echo "### modules-update: start processing ${cfg#.}"
			cat "${cfg}"
			echo "### modules-update: end processing ${cfg#.}"
			) >> "./etc/modprobe.conf"
		done
	fi

	rm -f "${tmpfile}" "${tmpfile}.err"
fi

: # make sure we fall through with 0 exit status
1	niro	2	#!/bin/bash
2	niro	698	# vim:ts=4
3			# Distributed under the terms of the GNU General Public License v2
4	niro	2	#
5	niro	698	# This script will do:
6			# - create /etc/modules.conf from /etc/modules.d/*
7			# - create /etc/modprobe.conf from /etc/modprobe.d/*
8			# - update modules.dep if modules.conf has been updated so depmod doesnt whine
9	niro	276	#
10	niro	698	# This is all for backwards compatibility. In the perfect world, we would be
11			# running a linux-2.6 kernel and not have any modules.d directory. Then there
12			# would be no work for us as module-init-tools automatically scans modprobe.d.
13			# Until that happens, we'll keep scanning and warning and being a pita.
14	niro	276	#
15	niro	2
16
17	niro	698	MROOT="${MROOT%/}/"
18			[ "${MROOT}" = "${MROOT#/}" ] && MROOT="${PWD}/${MROOT}"
19			cd "${MROOT}"
20
21			argv0=${0##*/}
22			. /etc/init.d/functions \|\| {
23			echo "${argv0}: Could not source /etc/init.d/functions!" 1>&2
24			exit 1
25			}
26			umask 022
27			esyslog() { :; }
28			export PATH=/sbin:${PATH}
29
30	niro	276	#
31	niro	698	# Setup some variables
32	niro	276	#
33	niro	2
34	niro	1278	HEADER="### This file is automatically generated by modules-update"
35			HEADER_OLD="### This file is automatically generated by update-modules"
36			VERSION="1.5"
37	niro	2
38	niro	698	#
39	niro	276	# Parse command-line
40	niro	698	#
41
42			VERBOSE=0
43			DEBUG=0
44			FORCE="false"
45			BACKUP="false"
46			KV=
47			while [ -n "$1" ] ; do
48			case $1 in
49			--assume-kernel=) KV=${1#=};;
50			-b\|--backup) BACKUP="true";;
51			-f\|--force\|force) FORCE="true";;
52			-v\|--verbose) ((VERBOSE+=1));;
53			-d\|--debug) ((DEBUG+=1));;
54	niro	1278	-V\|--version) exec echo "${argv0}: ${VERSION}";;
55	niro	698	-h\|--help)
56			cat <<-EOF
57	niro	1278	Usage: modules-update [options]
58	niro	698
59			Options:
60			--assume-kernel=KV Assume the kernel is at least version KV
61			-b, --backup Backup existing config files (add .old ext)
62			-f, --force Force execution in face of bad things
63			-v, --verbose Be a bit more verbose in what we do
64			-d, --debug Helpful debug output
65			-V, --version Dump version info
66			-h, --help This help screen, duh
67			EOF
68			exit 0
69			;;
70	niro	276	*)
71			echo "Error: I don't understand $1"
72	niro	698	exit 1
73			;;
74	niro	276	esac
75			shift
76			done
77	niro	2
78	niro	698	if [ ! -w ./etc ] ; then
79			echo "You must be root to do this"
80			exit 2
81			fi
82	niro	276
83	niro	698	[ ${DEBUG} -gt 0 ] && set -x
84
85			veinfo() { [ ${VERBOSE} -gt 0 ] && echo "$*" ; return 0 ; }
86			vewarn() { [ ${VERBOSE} -gt 0 ] && echo "$*" ; return 0 ; }
87
88			[ "${MROOT}" != "/" ] && veinfo "Operating on MROOT = '${MROOT}'"
89
90			#
91			# Let's check the optimal case first: nothing to do
92			#
93			if ! ${FORCE} ; then
94			if [ ! -d "./etc/modules.d" ] ; then
95			if [ ! -d "./etc/modprobe.d" ] ; then
96			veinfo "No /etc/modules.d or /etc/modprobe.d dir; Nothing to do!"
97			exit 0
98
99			elif [ -e "./etc/modprobe.conf" ] ; then
100			vewarn "You should put settings in /etc/modprobe.d/ rather than modprobe.conf"
101
102			elif [ -e "./etc/modules.conf" ] ; then
103			vewarn "If you only run linux-2.4, you should delete /etc/modules.conf"
104
105			else
106			veinfo "We have just /etc/modprobe.d; Nothing to do!"
107			exit 0
108			fi
109			else
110			vewarn "You have /etc/modules.d, so things need to get coalesced"
111			fi
112			fi
113
114			#
115			# Build list of config files to generate and verify none
116			# have been modified in any way
117			#
118			for x in modprobe.conf modules.conf ; do
119			x="./etc/${x}"
120			[ -r ${x} ] \|\| continue
121
122	niro	1278	_header="$(sed -ne 1p ${x})"
123			if [ "${_header}" != "${HEADER}" ] && [ "${_header}" != "${HEADER_OLD}" ]; then
124	niro	698	echo "Warning: ${x#.} has not been automatically generated"
125
126			if ${FORCE} ; then
127			echo "--force specified, (re)generating file anyway"
128			else
129	niro	1278	echo "Use \"modules-update force\" to force (re)generation"
130	niro	698	exit 1
131			fi
132			fi
133			done
134
135
136			#
137			# If the system doesnt have old modutils, then this is prob linux-2.6 only
138			#
139			if type -P modprobe.old > /dev/null \|\| \
140			LC_ALL=C modprobe -V 2>/dev/null \| grep -qs "modprobe version"
141	niro	2	then
142	niro	698	GENERATE_OLD="true"
143	niro	276	else
144	niro	698	GENERATE_OLD="false"
145	niro	2	fi
146
147
148			# Reset the sorting order since we depend on it
149			export LC_COLLATE="C"
150
151	niro	698	KV=${KV:-$(uname -r)}
152
153
154			#
155			# Desc: backup a config file if need be and replace with new one
156			# Usage: backup <old config file to backup> <new config file to replace with>
157			# Ex: backup /etc/modules.conf /etc/modules.conf.tempfile
158			#
159			backup() {
160			if ${BACKUP} && [ -e "$1" ] ; then
161			mv -f "$1" "$1".old
162			fi
163			mv -f "$2" "$1"
164	niro	2	}
165
166
167	niro	698	#
168			# Desc: Create module header
169			# Usage: create_header <config dir>
170			# Ex: create_header /etc/modules.d
171			create_header() {
172			local moddir=$1
173	niro	105
174	niro	698	cat <<-EOF
175			${HEADER}
176			#
177			# Please do not edit this file directly. If you want to change or add
178			# anything please take a look at the files in ${moddir} and read
179	niro	1278	# the manpage for modules-update(8).
180	niro	698	#
181			EOF
182			}
183	niro	2
184	niro	698
185			#
186			# Desc: Combine all config files in a dir and place output in a file
187			# Usage: generate_config <output config file> <config dir> <reference config dir> <silent>
188			# Ex: generate_config /etc/modules.conf /etc/modules.d
189			#
190	niro	276	generate_config() {
191	niro	698	local config=$1
192			local moddir=$2
193			local refdir=$3
194			local silent=$4
195			local tmpfile="${config}.$$"
196	niro	2
197	niro	698	[ -z "${silent}" ] && echo "Updating ${config#./etc/}"
198	niro	2
199	niro	698	create_header ${refdir:-${moddir}} > "${tmpfile}"
200	niro	2
201	niro	698	for cfg in "${moddir}"/* ; do
202			[ -d "${cfg}" ] && continue
203			[ ! -r "${cfg}" ] && continue
204	niro	2
205	niro	698	# Skip backup and RCS files #20597
206			case ${cfg} in ~\|.bak\|*,v) continue;; esac
207	niro	2
208	niro	698	# If config file is found in the reference dir, then skip it
209			[ -n "${refdir}" ] && [ -e "${refdir}/${cfg##*/}" ] && continue
210
211			(
212	niro	1278	echo "### modules-update: start processing ${cfg#.}"
213	niro	698	if [ -x "${cfg}" ] ; then
214	niro	276	# $cfg can be executable; nice touch, Wichert! :)
215	niro	698	"${cfg}"
216	niro	276	else
217	niro	698	cat "${cfg}"
218	niro	276	fi
219	niro	698	echo
220	niro	1278	echo "### modules-update: end processing ${cfg#.}"
221	niro	698	echo
222			) >> "${tmpfile}"
223	niro	276	done
224	niro	2
225	niro	698	backup "${config}" "${tmpfile}"
226
227	niro	276	return 0
228			}
229	niro	105
230	niro	698
231			#
232			# Generate the old modules.conf file based upon all the snippets in
233			# modules.d. Since modprobe doesnt handle modules.d, we need to gather
234			# the files together in modules.conf for it.
235			#
236
237			if [ ! -d "./etc/modules.d" ] ; then
238			veinfo "No need to generate modules.conf :)"
239
240			elif ${FORCE} \|\| is_older_than ./etc/modules.conf ./etc/modules.d ; then
241			generate_config ./etc/modules.conf ./etc/modules.d
242
243			else
244			veinfo "modules.conf: already up-to-date wheatness"
245			fi
246
247			#
248			# Call depmod to keep insmod from complaining that modules.conf is more
249			# recent then the modules.dep file.
250			#
251			if [ -e "./etc/modules.conf" ] ; then
252			depfile=$(
253			# the modules.conf file has optional syntax:
254			# depfile=/path/to/modules.dep
255			ret=$(sed -n -e '/^[[:space:]]depfile=/s:.=::p' ./etc/modules.conf)
256			eval echo "${ret:-/lib/modules/${KV}/modules.dep}"
257			)
258
259			if [ -d "${depfile%/*}" ] ; then
260			if [ ./etc/modules.conf -nt "${depfile}" ] ; then
261			arch=$(uname -m)
262			echo "Updating modules.dep"
263			for cfg in /lib/modules/${KV}/build /usr/src/linux-${KV} \
264			/lib/modules/${KV} /boot /usr/src/linux ""
265			do
266			cfg=".${cfg}/System.map"
267			for suffix in -genkernel-${arch}-${KV} -genkernel-'*'-${KV} -${KV} "" ; do
268			scfg=$(echo ${cfg}${suffix})
269			scfg=${scfg%% *}
270			[ -f "${scfg}" ] && cfg=${scfg} && break 2
271			done
272			cfg=""
273			done
274			[ -n "${cfg}" ] && cfg="-F ${cfg}"
275			depmod -b "${ROOT}" -a ${cfg} ${KV}
276			veinfo "Ran: depmod -b '${ROOT}' -a ${cfg} ${KV}"
277			else
278			veinfo "modules.dep: already up-to-date goodness"
279			fi
280			else
281			vewarn "The dir '${depfile}' does not exist, skipping call to depmod"
282	niro	2	fi
283	niro	276	fi
284	niro	105
285	niro	698
286			#
287			# Generate the new modprobe.conf file if possible. What this entails is
288			# grabbing details from the old modprobe via the -c option and sticking
289			# it in the newer config file. This is useful for backwards compat support
290			# and for packages that provide older style /etc/modules.d/ files but not
291			# newer style /etc/modprobe.d/ files.
292			#
293			# First we try to use the script `generate-modprobe.conf` from the
294			# module-init-tools and if that fails us, we try and generate modprobe.conf
295			# ourselves from the /etc/modules.d/ files.
296			#
297			if ! type -P generate-modprobe.conf > /dev/null ; then
298			vewarn "Skipping /etc/modprobe.conf generation (generate-modprobe.conf doesn't exist)"
299
300			elif ! ${FORCE} && ! is_older_than ./etc/modprobe.conf ./etc/modules.d ./etc/modprobe.d ; then
301			veinfo "modprobe.conf: already up-to-date nutness"
302
303	niro	1278	elif [ ! -e ./etc/modules.conf -a ! -e ./etc/modules.d ] ; then
304			veinfo "No need to generate modprobe.conf :)"
305			rm -f ./etc/modprobe.conf
306
307	niro	698	else
308			#
309			# First, bitch like crazy
310			#
311			for f in ./etc/modules.d/* ; do
312			# hack: ignore baselayout ;x
313			case ${f##*/} in
314			aliases\|i386) continue;;
315			esac
316			[ -e "${f}" ] \|\| continue
317			if [ ! -e "./etc/modprobe.d/${f##*/}" ] ; then
318			echo "Please file a bug about ${f#.}: it needs an /etc/modprobe.d/${f##*/}"
319	niro	276	fi
320	niro	698	done
321
322			generated_ok=0
323			tmpfile="./etc/modprobe.conf.$$"
324
325			#
326			# First we try to use regular generate-modprobe.conf
327			#
328			if ${GENERATE_OLD} ; then
329			echo "Updating modprobe.conf"
330			create_header /etc/modprobe.d > "${tmpfile}"
331			if generate-modprobe.conf ${ASSUME_KV:+--assume-kernel=${KV}} \
332			>> "${tmpfile}" 2> "${tmpfile}.err"
333	niro	2	then
334	niro	698	backup "./etc/modprobe.conf" "${tmpfile}"
335			generated_ok=1
336	niro	2	else
337	niro	698	[[ ${VERBOSE} -gt 0 ]] && cat "${tmpfile}.err"
338			echo "Warning: could not generate /etc/modprobe.conf!"
339	niro	2	fi
340	niro	698	fi
341	niro	276
342	niro	698	#
343			# If the helper script failed, we fall back to doing it by hand
344			#
345			if [[ ${generated_ok} -eq 0 ]] ; then
346			echo "Updating modprobe.conf by hand"
347	niro	276
348	niro	698	generate_config ./etc/modprobe.conf ./etc/modules.d ./etc/modprobe.d 0
349			create_header /etc/modprobe.d > "${tmpfile}"
350	niro	276
351	niro	698	# Just use generate-modprobe.conf to filter compatible syntax
352			if TESTING_MODPROBE_CONF=./etc/modprobe.conf \
353			generate-modprobe.conf ${ASSUME_KV:+--assume-kernel=${KV}} \
354			>> "${tmpfile}" 2> "${tmpfile}.err"
355			then
356			# we use mv here instead of backup_config() as the call to
357			# generate_config() above already took care of the backup
358			mv -f "${tmpfile}" "./etc/modprobe.conf"
359			else
360			[[ ${VERBOSE} -gt 0 ]] && cat "${tmpfile}.err"
361			echo "Warning: could not generate /etc/modprobe.conf!"
362	niro	276	fi
363	niro	2	fi
364
365	niro	698	#
366			# Now append all the new files ... modprobe will not scan /etc/modprobe.d/
367			# if /etc/modprobe.conf exists, so we need to append /etc/modprobe.conf with
368			# /etc/modprobe.d/* ... http://bugs.gentoo.org/145962
369			#
370			if [[ -e ./etc/modprobe.conf ]] ; then
371			for cfg in ./etc/modprobe.d/* ; do
372			[ -d "${cfg}" ] && continue
373			[ ! -r "${cfg}" ] && continue
374
375			# Skip backup and RCS files #20597
376			case ${cfg} in ~\|.bak\|*,v) continue;; esac
377
378			(
379			echo
380	niro	1278	echo "### modules-update: start processing ${cfg#.}"
381	niro	698	cat "${cfg}"
382	niro	1278	echo "### modules-update: end processing ${cfg#.}"
383	niro	698	) >> "./etc/modprobe.conf"
384			done
385	niro	276	fi
386	niro	698
387			rm -f "${tmpfile}" "${tmpfile}.err"
388	niro	2	fi
389
390	niro	698	: # make sure we fall through with 0 exit status