Hello community, here is the log from the commit of package xen checked in at Sat Jun 3 01:01:10 CEST 2006. -------- --- arch/i386/xen/xen.changes 2006-06-02 00:14:42.000000000 +0200 +++ xen/xen.changes 2006-06-02 19:45:21.000000000 +0200 @@ -1,0 +2,8 @@ +Fri Jun 2 11:08:07 MDT 2006 - ccoffing@novell.com + +- Include xen-3.0-testing changeset 9693. This scales the + ballooning timeout with the amount of memory being requested + (necessary for large memory machines). This is a more proper fix + for Novell bug #175805, and addresses XenSource bug #650. + +------------------------------------------------------------------- New: ---- xen-9693-wait-for-large-ballooning.diff ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ xen.spec ++++++ --- /var/tmp/diff_new_pack.ELlmgs/_old 2006-06-03 01:00:39.000000000 +0200 +++ /var/tmp/diff_new_pack.ELlmgs/_new 2006-06-03 01:00:39.000000000 +0200 @@ -19,7 +19,7 @@ %define with_pygrub 1 %define xen_build_dir xen-3.0-testing Version: 3.0.2_09697 -Release: 2 +Release: 3 License: GPL Group: System/Kernel Autoreqprov: on @@ -103,9 +103,10 @@ Patch114: xen-9685-segment-bases.diff Patch115: xen-9686-32-64-vmx-regs.diff Patch116: xen-9688-rm-broken-string-func.diff -Patch117: xen-9695-signed.diff -Patch118: xen-9696-rm-broken-string-func.diff -Patch119: xen-unstable-9967-summa.diff +Patch117: xen-9693-wait-for-large-ballooning.diff +Patch118: xen-9695-signed.diff +Patch119: xen-9696-rm-broken-string-func.diff +Patch120: xen-unstable-9967-summa.diff Patch200: xen-enable-hvm-debug.diff Patch201: xen-enable-debug Patch202: xen-poweroff.diff @@ -472,6 +473,7 @@ %patch117 -p1 %patch118 -p1 %patch119 -p1 +%patch120 -p1 # Now our patches... %patch1 -p1 %patch2 -p1 @@ -829,6 +831,11 @@ %{insserv_cleanup} %changelog -n xen +* Fri Jun 02 2006 - ccoffing@novell.com +- Include xen-3.0-testing changeset 9693. This scales the + ballooning timeout with the amount of memory being requested + (necessary for large memory machines). This is a more proper fix + for Novell bug #175805, and addresses XenSource bug #650. * Thu Jun 01 2006 - ccoffing@novell.com - Update the README, regarding how to make the mouse work properly with VNC in HVM. ++++++ xen-9693-wait-for-large-ballooning.diff ++++++ # HG changeset patch # User kaf24@firebug.cl.cam.ac.uk # Date Thu May 25 21:41:59 2006 +0100 # Node ID a4214205e288196afc4193cd47d8bf515712d16f # parent: 4664b4c68212133c84a1a8c6f8e8705e9c530130 [XEND] Wait sufficient time for memory to balloon out before creating a new domain. On the ES7000 when Dom0 boots up with all of system memory and you try to bring up a DomU with more than 2GB of memory, xend times out before the memory is freed causing the domain not to be created. This patch increases the timeout depending on the amount of memory that needs to be freed. It also places a cap on the sleep time so that it does not grow without a limit. This fixes bug# 650 http://bugzilla.xensource.com/bugzilla/show_bug.cgi?id=3D650 Signed-off-by: Aravindh Puthiyaparambil <aravindh.puthiyaparambil@unisys.com> xen-unstable changeset: 10165:93db1b536f383ee93359080097b0870ea3add01a xen-unstable date: Thu May 25 21:41:04 2006 +0100 --- a/tools/python/xen/xend/balloon.py Thu May 25 21:20:02 2006 +0100 +++ b/tools/python/xen/xend/balloon.py Thu May 25 21:41:59 2006 +0100 @@ -32,6 +32,7 @@ BALLOON_OUT_SLACK = 1 # MiB. We need th BALLOON_OUT_SLACK = 1 # MiB. We need this because the physinfo details are # rounded. RETRY_LIMIT = 10 +RETRY_LIMIT_INCR = 5 ## # The time to sleep between retries grows linearly, using this value (in # seconds). When the system is lightly loaded, memory should be scrubbed and @@ -118,7 +119,8 @@ def free(required): retries = 0 sleep_time = SLEEP_TIME_GROWTH last_new_alloc = None - while retries < RETRY_LIMIT: + rlimit = RETRY_LIMIT + while retries < rlimit: free_mem = xc.physinfo()['free_memory'] if free_mem >= need_mem: @@ -127,7 +129,9 @@ def free(required): return if retries == 0: - log.debug("Balloon: free %d; need %d.", free_mem, need_mem) + rlimit += ((need_mem - free_mem)/1024) * RETRY_LIMIT_INCR + log.debug("Balloon: free %d; need %d; retries: %d.", + free_mem, need_mem, rlimit) if dom0_min_mem > 0: dom0_alloc = get_dom0_current_alloc() @@ -143,8 +147,9 @@ def free(required): # Continue to retry, waiting for ballooning. time.sleep(sleep_time) + if retries < 2 * RETRY_LIMIT: + sleep_time += SLEEP_TIME_GROWTH retries += 1 - sleep_time += SLEEP_TIME_GROWTH # Not enough memory; diagnose the problem. if dom0_min_mem == 0: ++++++ xen-balloon.diff ++++++ --- /var/tmp/diff_new_pack.ELlmgs/_old 2006-06-03 01:00:43.000000000 +0200 +++ /var/tmp/diff_new_pack.ELlmgs/_new 2006-06-03 01:00:43.000000000 +0200 @@ -2,68 +2,37 @@ =================================================================== --- xen-3.0-testing.orig/tools/python/xen/xend/balloon.py +++ xen-3.0-testing/tools/python/xen/xend/balloon.py -@@ -31,7 +31,11 @@ PROC_XEN_BALLOON = '/proc/xen/balloon' +@@ -31,6 +31,9 @@ PROC_XEN_BALLOON = '/proc/xen/balloon' BALLOON_OUT_SLACK = 1 # MiB. We need this because the physinfo details are # rounded. --RETRY_LIMIT = 10 +RETURN_OVERSHOOT = 16 # MiB. Overshooting the target free memory by less + # than this amount is okay; more than this is returned + # to domain 0 (other domains may have died, freeing mem.) -+ -+RETRY_LIMIT = 20 + RETRY_LIMIT = 10 + RETRY_LIMIT_INCR = 5 ## - # The time to sleep between retries grows linearly, using this value (in - # seconds). When the system is lightly loaded, memory should be scrubbed and -@@ -127,26 +131,36 @@ def free(required): +@@ -128,7 +131,7 @@ def free(required): retries = 0 sleep_time = SLEEP_TIME_GROWTH - last_new_alloc = None + last_new_alloc = float('inf') -+ last_dom0_alloc = None -+ times_unchanged = 0 - while retries < RETRY_LIMIT: + rlimit = RETRY_LIMIT + while retries < rlimit: free_mem = xc.physinfo()['free_memory'] -+ dom0_alloc = get_dom0_current_alloc() -+ if dom0_alloc == last_dom0_alloc: -+ times_unchanged += 1 -+ else: -+ times_unchanged = 0 -+ last_dom0_alloc = dom0_alloc +@@ -148,7 +151,8 @@ def free(required): + new_alloc = dom0_alloc - (need_mem - free_mem) -+ log.debug("Balloon #%d: free %d; need %d", retries, free_mem, need_mem) - if free_mem >= need_mem: -- log.debug("Balloon: free %d; need %d; done.", free_mem, -- need_mem) - return - -- if retries == 0: -- log.debug("Balloon: free %d; need %d.", free_mem, need_mem) -+ # This gives it at least 2.1 seconds to respond any, yet prevents -+ # us from waiting the full time if nothing is going to happen. -+ if times_unchanged > 4: -+ break - - if dom0_min_mem > 0: -- dom0_alloc = get_dom0_current_alloc() -- new_alloc = dom0_alloc - (need_mem - free_mem) -+ log.debug("Balloon #%d: dom0_alloc %d; free %d; need %d.", -+ retries, dom0_alloc, free_mem, need_mem) - -+ new_alloc = dom0_alloc - (need_mem - free_mem) if (new_alloc >= dom0_min_mem and - new_alloc != last_new_alloc): -- log.debug("Balloon: setting dom0 target to %d.", -- new_alloc) + (new_alloc < last_new_alloc or + new_alloc > last_new_alloc + RETURN_OVERSHOOT)): -+ log.debug("Balloon: setting dom0 target to %d.", new_alloc) + log.debug("Balloon: setting dom0 target to %d.", + new_alloc) dom0 = XendDomain.instance().privilegedDomain() - dom0.setMemoryTarget(new_alloc) - last_new_alloc = new_alloc -@@ -157,7 +171,7 @@ def free(required): - sleep_time += SLEEP_TIME_GROWTH +@@ -162,7 +166,7 @@ def free(required): + retries += 1 # Not enough memory; diagnose the problem. - if dom0_min_mem == 0: ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Remember to have fun... --------------------------------------------------------------------- To unsubscribe, e-mail: opensuse-commit-unsubscribe@opensuse.org For additional commands, e-mail: opensuse-commit-help@opensuse.org