[net-next-2.6.git] / scripts / gen_initramfs_list.sh

#!/bin/bash
# Copyright (C) Martin Schlemmer <azarah@nosferatu.za.org>
# Copyright (c) 2006           Sam Ravnborg <sam@ravnborg.org>
#
# Released under the terms of the GNU GPL
#
# Generate a cpio packed initramfs. It uses gen_init_cpio to generate
# the cpio archive, and gzip to pack it.
# The script may also be used to generate the inputfile used for gen_init_cpio
# This script assumes that gen_init_cpio is located in usr/ directory

# error out on errors
set -e

usage() {
cat << EOF
Usage:
$0 [-o <file>] [-u <uid>] [-g <gid>] {-d | <cpio_source>} ...
	-o <file>      Create gzipped initramfs file named <file> using
	               gen_init_cpio and gzip
	-u <uid>       User ID to map to user ID 0 (root).
	               <uid> is only meaningful if <cpio_source>
	               is a directory.
	-g <gid>       Group ID to map to group ID 0 (root).
	               <gid> is only meaningful if <cpio_source>
	               is a directory.
	<cpio_source>  File list or directory for cpio archive.
	               If <cpio_source> is a .cpio file it will be used
		       as direct input to initramfs.
	-d             Output the default cpio list.

All options except -o and -l may be repeated and are interpreted
sequentially and immediately.  -u and -g states are preserved across
<cpio_source> options so an explicit "-u 0 -g 0" is required
to reset the root/group mapping.
EOF
}

list_default_initramfs() {
	# echo usr/kinit/kinit
	:
}

default_initramfs() {
	cat <<-EOF >> ${output}
		# This is a very simple, default initramfs

		dir /dev 0755 0 0
		nod /dev/console 0600 0 0 c 5 1
		dir /root 0700 0 0
		# file /kinit usr/kinit/kinit 0755 0 0
		# slink /init kinit 0755 0 0
	EOF
}

filetype() {
	local argv1="$1"

	# symlink test must come before file test
	if [ -L "${argv1}" ]; then
		echo "slink"
	elif [ -f "${argv1}" ]; then
		echo "file"
	elif [ -d "${argv1}" ]; then
		echo "dir"
	elif [ -b "${argv1}" -o -c "${argv1}" ]; then
		echo "nod"
	elif [ -p "${argv1}" ]; then
		echo "pipe"
	elif [ -S "${argv1}" ]; then
		echo "sock"
	else
		echo "invalid"
	fi
	return 0
}

list_print_mtime() {
	:
}

print_mtime() {
	local my_mtime="0"

	if [ -e "$1" ]; then
		my_mtime=$(find "$1" -printf "%T@\n" | sort -r | head -n 1)
	fi

	echo "# Last modified: ${my_mtime}" >> ${output}
	echo "" >> ${output}
}

list_parse() {
	echo "$1 \\"
}

# for each file print a line in following format
# <filetype> <name> <path to file> <octal mode> <uid> <gid>
# for links, devices etc the format differs. See gen_init_cpio for details
parse() {
	local location="$1"
	local name="${location/${srcdir}//}"
	# change '//' into '/'
	name="${name//\/\///}"
	local mode="$2"
	local uid="$3"
	local gid="$4"
	local ftype=$(filetype "${location}")
	# remap uid/gid to 0 if necessary
	[ "$uid" -eq "$root_uid" ] && uid=0
	[ "$gid" -eq "$root_gid" ] && gid=0
	local str="${mode} ${uid} ${gid}"

	[ "${ftype}" == "invalid" ] && return 0
	[ "${location}" == "${srcdir}" ] && return 0

	case "${ftype}" in
		"file")
			str="${ftype} ${name} ${location} ${str}"
			;;
		"nod")
			local dev_type=
			local maj=$(LC_ALL=C ls -l "${location}" | \
					gawk '{sub(/,/, "", $5); print $5}')
			local min=$(LC_ALL=C ls -l "${location}" | \
					gawk '{print $6}')

			if [ -b "${location}" ]; then
				dev_type="b"
			else
				dev_type="c"
			fi
			str="${ftype} ${name} ${str} ${dev_type} ${maj} ${min}"
			;;
		"slink")
			local target=$(LC_ALL=C ls -l "${location}" | \
					gawk '{print $11}')
			str="${ftype} ${name} ${target} ${str}"
			;;
		*)
			str="${ftype} ${name} ${str}"
			;;
	esac

	echo "${str}" >> ${output}

	return 0
}

unknown_option() {
	printf "ERROR: unknown option \"$arg\"\n" >&2
	printf "If the filename validly begins with '-', " >&2
	printf "then it must be prefixed\n" >&2
	printf "by './' so that it won't be interpreted as an option." >&2
	printf "\n" >&2
	usage >&2
	exit 1
}

list_header() {
	echo "deps_initramfs := \\"
}

header() {
	printf "\n#####################\n# $1\n" >> ${output}
}

# process one directory (incl sub-directories)
dir_filelist() {
	${dep_list}header "$1"

	srcdir=$(echo "$1" | sed -e 's://*:/:g')
	dirlist=$(find "${srcdir}" -printf "%p %m %U %G\n" 2>/dev/null)

	# If $dirlist is only one line, then the directory is empty
	if [  "$(echo "${dirlist}" | wc -l)" -gt 1 ]; then
		${dep_list}print_mtime "$1"

		echo "${dirlist}" | \
		while read x; do
			${dep_list}parse ${x}
		done
	fi
}

# if only one file is specified and it is .cpio file then use it direct as fs
# if a directory is specified then add all files in given direcotry to fs
# if a regular file is specified assume it is in gen_initramfs format
input_file() {
	source="$1"
	if [ -f "$1" ]; then
		${dep_list}header "$1"
		is_cpio="$(echo "$1" | sed 's/^.*\.cpio/cpio/')"
		if [ $2 -eq 0 -a ${is_cpio} == "cpio" ]; then
			cpio_file=$1
			[ ! -z ${dep_list} ] && echo "$1"
			return 0
		fi
		if [ -z ${dep_list} ]; then
			print_mtime "$1" >> ${output}
			cat "$1"         >> ${output}
		else
			grep ^file "$1" | cut -d ' ' -f 3
		fi
	elif [ -d "$1" ]; then
		dir_filelist "$1"
	else
		echo "  ${prog}: Cannot open '$1'" >&2
		exit 1
	fi
}

prog=$0
root_uid=0
root_gid=0
dep_list=
cpio_file=
cpio_list=
output="/dev/stdout"
output_file=""

arg="$1"
case "$arg" in
	"-l")	# files included in initramfs - used by kbuild
		dep_list="list_"
		shift
		;;
	"-o")	# generate gzipped cpio image named $1
		shift
		output_file="$1"
		cpio_list="$(mktemp ${TMPDIR:-/tmp}/cpiolist.XXXXXX)"
		output=${cpio_list}
		shift
		;;
esac
while [ $# -gt 0 ]; do
	arg="$1"
	shift
	case "$arg" in
		"-u")	# map $1 to uid=0 (root)
			root_uid="$1"
			shift
			;;
		"-g")	# map $1 to gid=0 (root)
			root_gid="$1"
			shift
			;;
		"-d")	# display default initramfs list
			default_list="$arg"
			${dep_list}default_initramfs
			;;
		"-h")
			usage
			exit 0
			;;
		*)
			case "$arg" in
				"-"*)
					unknown_option
					;;
				*)	# input file/dir - process it
					input_file "$arg" "$#"
					;;
			esac
			;;
	esac
done

# If output_file is set we will generate cpio archive and gzip it
# we are carefull to delete tmp files
if [ ! -z ${output_file} ]; then
	if [ -z ${cpio_file} ]; then
		cpio_tfile="$(mktemp ${TMPDIR:-/tmp}/cpiofile.XXXXXX)"
		usr/gen_init_cpio ${cpio_list} > ${cpio_tfile}
	else
		cpio_tfile=${cpio_file}
	fi
	rm ${cpio_list}
	cat ${cpio_tfile} | gzip -f -9 - > ${output_file}
	[ -z ${cpio_file} ] && rm ${cpio_tfile}
fi
exit 0
Commit	Line	Data
1da177e4 LT	1	#!/bin/bash
1da177e4 LT	2	# Copyright (C) Martin Schlemmer <azarah@nosferatu.za.org>
d39a206b	3	# Copyright (c) 2006 Sam Ravnborg <sam@ravnborg.org>
1da177e4	4	#
d39a206b	5	# Released under the terms of the GNU GPL
1da177e4	6	#
d39a206b SR	7	# Generate a cpio packed initramfs. It uses gen_init_cpio to generate
	8	# the cpio archive, and gzip to pack it.
	9	# The script may also be used to generate the inputfile used for gen_init_cpio
	10	# This script assumes that gen_init_cpio is located in usr/ directory
	11
	12	# error out on errors
	13	set -e
	14
	15	usage() {
	16	cat << EOF
	17	Usage:
	18	$0 [-o <file>] [-u <uid>] [-g <gid>] {-d \| <cpio_source>} ...
	19	-o <file> Create gzipped initramfs file named <file> using
	20	gen_init_cpio and gzip
	21	-u <uid> User ID to map to user ID 0 (root).
	22	<uid> is only meaningful if <cpio_source>
	23	is a directory.
	24	-g <gid> Group ID to map to group ID 0 (root).
	25	<gid> is only meaningful if <cpio_source>
	26	is a directory.
	27	<cpio_source> File list or directory for cpio archive.
	28	If <cpio_source> is a .cpio file it will be used
	29	as direct input to initramfs.
	30	-d Output the default cpio list.
	31
	32	All options except -o and -l may be repeated and are interpreted
	33	sequentially and immediately. -u and -g states are preserved across
	34	<cpio_source> options so an explicit "-u 0 -g 0" is required
	35	to reset the root/group mapping.
	36	EOF
	37	}
	38
	39	list_default_initramfs() {
	40	# echo usr/kinit/kinit
	41	:
	42	}
1da177e4 LT	43
1da177e4 LT	44	default_initramfs() {
d39a206b	45	cat <<-EOF >> ${output}
1da177e4 LT	46	# This is a very simple, default initramfs
	47
	48	dir /dev 0755 0 0
	49	nod /dev/console 0600 0 0 c 5 1
	50	dir /root 0700 0 0
d39a206b SR	51	# file /kinit usr/kinit/kinit 0755 0 0
d39a206b SR	52	# slink /init kinit 0755 0 0
1da177e4 LT	53	EOF
	54	}
	55
	56	filetype() {
	57	local argv1="$1"
	58
	59	# symlink test must come before file test
	60	if [ -L "${argv1}" ]; then
	61	echo "slink"
	62	elif [ -f "${argv1}" ]; then
	63	echo "file"
	64	elif [ -d "${argv1}" ]; then
	65	echo "dir"
	66	elif [ -b "${argv1}" -o -c "${argv1}" ]; then
	67	echo "nod"
	68	elif [ -p "${argv1}" ]; then
	69	echo "pipe"
	70	elif [ -S "${argv1}" ]; then
	71	echo "sock"
	72	else
	73	echo "invalid"
	74	fi
	75	return 0
	76	}
	77
d39a206b SR	78	list_print_mtime() {
	79	:
	80	}
	81
1da177e4	82	print_mtime() {
1da177e4 LT	83	local my_mtime="0"
1da177e4 LT	84
d39a206b SR	85	if [ -e "$1" ]; then
d39a206b SR	86	my_mtime=$(find "$1" -printf "%T@\n" \| sort -r \| head -n 1)
1da177e4	87	fi
d39a206b SR	88
	89	echo "# Last modified: ${my_mtime}" >> ${output}
	90	echo "" >> ${output}
	91	}
	92
	93	list_parse() {
	94	echo "$1 \\"
1da177e4 LT	95	}
1da177e4 LT	96
d39a206b SR	97	# for each file print a line in following format
	98	# <filetype> <name> <path to file> <octal mode> <uid> <gid>
	99	# for links, devices etc the format differs. See gen_init_cpio for details
1da177e4 LT	100	parse() {
	101	local location="$1"
	102	local name="${location/${srcdir}//}"
	103	# change '//' into '/'
	104	name="${name//\/\///}"
	105	local mode="$2"
	106	local uid="$3"
	107	local gid="$4"
	108	local ftype=$(filetype "${location}")
	109	# remap uid/gid to 0 if necessary
	110	[ "$uid" -eq "$root_uid" ] && uid=0
	111	[ "$gid" -eq "$root_gid" ] && gid=0
	112	local str="${mode} ${uid} ${gid}"
	113
	114	[ "${ftype}" == "invalid" ] && return 0
	115	[ "${location}" == "${srcdir}" ] && return 0
	116
	117	case "${ftype}" in
	118	"file")
	119	str="${ftype} ${name} ${location} ${str}"
	120	;;
	121	"nod")
	122	local dev_type=
	123	local maj=$(LC_ALL=C ls -l "${location}" \| \
	124	gawk '{sub(/,/, "", $5); print $5}')
	125	local min=$(LC_ALL=C ls -l "${location}" \| \
	126	gawk '{print $6}')
	127
	128	if [ -b "${location}" ]; then
	129	dev_type="b"
	130	else
	131	dev_type="c"
	132	fi
	133	str="${ftype} ${name} ${str} ${dev_type} ${maj} ${min}"
	134	;;
	135	"slink")
	136	local target=$(LC_ALL=C ls -l "${location}" \| \
	137	gawk '{print $11}')
	138	str="${ftype} ${name} ${target} ${str}"
	139	;;
	140	*)
	141	str="${ftype} ${name} ${str}"
	142	;;
	143	esac
	144
d39a206b	145	echo "${str}" >> ${output}
1da177e4 LT	146
	147	return 0
	148	}
	149
d39a206b SR	150	unknown_option() {
	151	printf "ERROR: unknown option \"$arg\"\n" >&2
	152	printf "If the filename validly begins with '-', " >&2
	153	printf "then it must be prefixed\n" >&2
	154	printf "by './' so that it won't be interpreted as an option." >&2
	155	printf "\n" >&2
	156	usage >&2
	157	exit 1
	158	}
	159
	160	list_header() {
	161	echo "deps_initramfs := \\"
	162	}
	163
	164	header() {
	165	printf "\n#####################\n# $1\n" >> ${output}
	166	}
	167
	168	# process one directory (incl sub-directories)
	169	dir_filelist() {
	170	${dep_list}header "$1"
	171
	172	srcdir=$(echo "$1" \| sed -e 's://*:/:g')
	173	dirlist=$(find "${srcdir}" -printf "%p %m %U %G\n" 2>/dev/null)
	174
	175	# If $dirlist is only one line, then the directory is empty
	176	if [ "$(echo "${dirlist}" \| wc -l)" -gt 1 ]; then
	177	${dep_list}print_mtime "$1"
	178
	179	echo "${dirlist}" \| \
	180	while read x; do
	181	${dep_list}parse ${x}
	182	done
	183	fi
1da177e4 LT	184	}
1da177e4 LT	185
d39a206b SR	186	# if only one file is specified and it is .cpio file then use it direct as fs
	187	# if a directory is specified then add all files in given direcotry to fs
	188	# if a regular file is specified assume it is in gen_initramfs format
	189	input_file() {
	190	source="$1"
	191	if [ -f "$1" ]; then
	192	${dep_list}header "$1"
	193	is_cpio="$(echo "$1" \| sed 's/^.*\.cpio/cpio/')"
	194	if [ $2 -eq 0 -a ${is_cpio} == "cpio" ]; then
	195	cpio_file=$1
	196	[ ! -z ${dep_list} ] && echo "$1"
	197	return 0
	198	fi
	199	if [ -z ${dep_list} ]; then
	200	print_mtime "$1" >> ${output}
	201	cat "$1" >> ${output}
1da177e4	202	else
d39a206b	203	grep ^file "$1" \| cut -d ' ' -f 3
1da177e4	204	fi
d39a206b SR	205	elif [ -d "$1" ]; then
d39a206b SR	206	dir_filelist "$1"
1da177e4	207	else
d39a206b	208	echo " ${prog}: Cannot open '$1'" >&2
1da177e4 LT	209	exit 1
	210	fi
	211	}
	212
d39a206b	213	prog=$0
1da177e4 LT	214	root_uid=0
1da177e4 LT	215	root_gid=0
d39a206b SR	216	dep_list=
	217	cpio_file=
	218	cpio_list=
	219	output="/dev/stdout"
	220	output_file=""
1da177e4	221
d39a206b SR	222	arg="$1"
	223	case "$arg" in
	224	"-l") # files included in initramfs - used by kbuild
	225	dep_list="list_"
	226	shift
	227	;;
	228	"-o") # generate gzipped cpio image named $1
	229	shift
	230	output_file="$1"
	231	cpio_list="$(mktemp ${TMPDIR:-/tmp}/cpiolist.XXXXXX)"
	232	output=${cpio_list}
	233	shift
	234	;;
	235	esac
1da177e4 LT	236	while [ $# -gt 0 ]; do
	237	arg="$1"
	238	shift
	239	case "$arg" in
d39a206b	240	"-u") # map $1 to uid=0 (root)
1da177e4 LT	241	root_uid="$1"
	242	shift
	243	;;
d39a206b	244	"-g") # map $1 to gid=0 (root)
1da177e4 LT	245	root_gid="$1"
	246	shift
	247	;;
d39a206b	248	"-d") # display default initramfs list
1da177e4	249	default_list="$arg"
d39a206b	250	${dep_list}default_initramfs
1da177e4 LT	251	;;
	252	"-h")
	253	usage
	254	exit 0
	255	;;
	256	*)
	257	case "$arg" in
	258	"-"*)
d39a206b	259	unknown_option
1da177e4	260	;;
d39a206b SR	261	*) # input file/dir - process it
d39a206b SR	262	input_file "$arg" "$#"
1da177e4 LT	263	;;
	264	esac
	265	;;
	266	esac
	267	done
	268
d39a206b SR	269	# If output_file is set we will generate cpio archive and gzip it
	270	# we are carefull to delete tmp files
	271	if [ ! -z ${output_file} ]; then
	272	if [ -z ${cpio_file} ]; then
	273	cpio_tfile="$(mktemp ${TMPDIR:-/tmp}/cpiofile.XXXXXX)"
	274	usr/gen_init_cpio ${cpio_list} > ${cpio_tfile}
	275	else
	276	cpio_tfile=${cpio_file}
	277	fi
	278	rm ${cpio_list}
	279	cat ${cpio_tfile} \| gzip -f -9 - > ${output_file}
	280	[ -z ${cpio_file} ] && rm ${cpio_tfile}
	281	fi
1da177e4	282	exit 0