ia64/linux-2.6.18-xen.hg

view scripts/gen_initramfs_list.sh @ 897:329ea0ccb344

balloon: try harder to balloon up under memory pressure.

Currently if the balloon driver is unable to increase the guest's
reservation it assumes the failure was due to reaching its full
allocation, gives up on the ballooning operation and records the limit
it reached as the "hard limit". The driver will not try again until
the target is set again (even to the same value).

However it is possible that ballooning has in fact failed due to
memory pressure in the host and therefore it is desirable to keep
attempting to reach the target in case memory becomes available. The
most likely scenario is that some guests are ballooning down while
others are ballooning up and therefore there is temporary memory
pressure while things stabilise. You would not expect a well behaved
toolstack to ask a domain to balloon to more than its allocation nor
would you expect it to deliberately over-commit memory by setting
balloon targets which exceed the total host memory.

This patch drops the concept of a hard limit and causes the balloon
driver to retry increasing the reservation on a timer in the same
manner as when decreasing the reservation.

Also if we partially succeed in increasing the reservation
(i.e. receive less pages than we asked for) then we may as well keep
those pages rather than returning them to Xen.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Fri Jun 05 14:01:20 2009 +0100 (2009-06-05)
parents 831230e53067
children
line source
1 #!/bin/bash
2 # Copyright (C) Martin Schlemmer <azarah@nosferatu.za.org>
3 # Copyright (c) 2006 Sam Ravnborg <sam@ravnborg.org>
4 #
5 # Released under the terms of the GNU GPL
6 #
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
12 # error out on errors
13 set -e
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.
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 }
39 list_default_initramfs() {
40 # echo usr/kinit/kinit
41 :
42 }
44 default_initramfs() {
45 cat <<-EOF >> ${output}
46 # This is a very simple, default initramfs
48 dir /dev 0755 0 0
49 nod /dev/console 0600 0 0 c 5 1
50 dir /root 0700 0 0
51 # file /kinit usr/kinit/kinit 0755 0 0
52 # slink /init kinit 0755 0 0
53 EOF
54 }
56 filetype() {
57 local argv1="$1"
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 }
78 list_print_mtime() {
79 :
80 }
82 print_mtime() {
83 local my_mtime="0"
85 if [ -e "$1" ]; then
86 my_mtime=$(find "$1" -printf "%T@\n" | sort -r | head -n 1)
87 fi
89 echo "# Last modified: ${my_mtime}" >> ${output}
90 echo "" >> ${output}
91 }
93 list_parse() {
94 echo "$1 \\"
95 }
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
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}"
114 [ "${ftype}" == "invalid" ] && return 0
115 [ "${location}" == "${srcdir}" ] && return 0
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}')
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
145 echo "${str}" >> ${output}
147 return 0
148 }
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 }
160 list_header() {
161 echo "deps_initramfs := \\"
162 }
164 header() {
165 printf "\n#####################\n# $1\n" >> ${output}
166 }
168 # process one directory (incl sub-directories)
169 dir_filelist() {
170 ${dep_list}header "$1"
172 srcdir=$(echo "$1" | sed -e 's://*:/:g')
173 dirlist=$(find "${srcdir}" -printf "%p %m %U %G\n" 2>/dev/null)
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"
179 echo "${dirlist}" | \
180 while read x; do
181 ${dep_list}parse ${x}
182 done
183 fi
184 }
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}
202 else
203 cat "$1" | while read type dir file perm ; do
204 if [ "$type" == "file" ]; then
205 echo "$file \\";
206 fi
207 done
208 fi
209 elif [ -d "$1" ]; then
210 dir_filelist "$1"
211 else
212 echo " ${prog}: Cannot open '$1'" >&2
213 exit 1
214 fi
215 }
217 prog=$0
218 root_uid=0
219 root_gid=0
220 dep_list=
221 cpio_file=
222 cpio_list=
223 output="/dev/stdout"
224 output_file=""
226 arg="$1"
227 case "$arg" in
228 "-l") # files included in initramfs - used by kbuild
229 dep_list="list_"
230 shift
231 ;;
232 "-o") # generate gzipped cpio image named $1
233 shift
234 output_file="$1"
235 cpio_list="$(mktemp ${TMPDIR:-/tmp}/cpiolist.XXXXXX)"
236 output=${cpio_list}
237 shift
238 ;;
239 esac
240 while [ $# -gt 0 ]; do
241 arg="$1"
242 shift
243 case "$arg" in
244 "-u") # map $1 to uid=0 (root)
245 root_uid="$1"
246 shift
247 ;;
248 "-g") # map $1 to gid=0 (root)
249 root_gid="$1"
250 shift
251 ;;
252 "-d") # display default initramfs list
253 default_list="$arg"
254 ${dep_list}default_initramfs
255 ;;
256 "-h")
257 usage
258 exit 0
259 ;;
260 *)
261 case "$arg" in
262 "-"*)
263 unknown_option
264 ;;
265 *) # input file/dir - process it
266 input_file "$arg" "$#"
267 ;;
268 esac
269 ;;
270 esac
271 done
273 # If output_file is set we will generate cpio archive and gzip it
274 # we are carefull to delete tmp files
275 if [ ! -z ${output_file} ]; then
276 if [ -z ${cpio_file} ]; then
277 cpio_tfile="$(mktemp ${TMPDIR:-/tmp}/cpiofile.XXXXXX)"
278 usr/gen_init_cpio ${cpio_list} > ${cpio_tfile}
279 else
280 cpio_tfile=${cpio_file}
281 fi
282 rm ${cpio_list}
283 cat ${cpio_tfile} | gzip -f -9 - > ${output_file}
284 [ -z ${cpio_file} ] && rm ${cpio_tfile}
285 fi
286 exit 0