Contents of /trunk/magellan-initscripts/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 update-modules"

#
# 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}$Revision: 1.4 $ $Date: 2008-03-25 21:41:22 $";;
		-h|--help)
			cat <<-EOF
			Usage: update-modules [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

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

		if ${FORCE} ; then
			echo "--force specified, (re)generating file anyway"
		else
			echo "Use \"update-modules 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 update-modules(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 "### update-modules: start processing ${cfg#.}"
		if [ -x "${cfg}" ] ; then
			# $cfg can be executable; nice touch, Wichert! :)
			"${cfg}"
		else
			cat "${cfg}"
		fi
		echo
		echo "### update-modules: 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"

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 "### update-modules: start processing ${cfg#.}"
			cat "${cfg}"
			echo "### update-modules: end processing ${cfg#.}"
			) >> "./etc/modprobe.conf"
		done
	fi

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

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