ia64/linux-2.6.18-xen.hg

view arch/sparc/lib/memset.S @ 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 /* linux/arch/sparc/lib/memset.S: Sparc optimized memset, bzero and clear_user code
2 * Copyright (C) 1991,1996 Free Software Foundation
3 * Copyright (C) 1996,1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
4 * Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu)
5 *
6 * Returns 0, if ok, and number of bytes not yet set if exception
7 * occurs and we were called as clear_user.
8 */
10 #include <asm/ptrace.h>
12 /* Work around cpp -rob */
13 #define ALLOC #alloc
14 #define EXECINSTR #execinstr
15 #define EX(x,y,a,b) \
16 98: x,y; \
17 .section .fixup,ALLOC,EXECINSTR; \
18 .align 4; \
19 99: ba 30f; \
20 a, b, %o0; \
21 .section __ex_table,ALLOC; \
22 .align 4; \
23 .word 98b, 99b; \
24 .text; \
25 .align 4
27 #define EXT(start,end,handler) \
28 .section __ex_table,ALLOC; \
29 .align 4; \
30 .word start, 0, end, handler; \
31 .text; \
32 .align 4
34 /* Please don't change these macros, unless you change the logic
35 * in the .fixup section below as well.
36 * Store 64 bytes at (BASE + OFFSET) using value SOURCE. */
37 #define ZERO_BIG_BLOCK(base, offset, source) \
38 std source, [base + offset + 0x00]; \
39 std source, [base + offset + 0x08]; \
40 std source, [base + offset + 0x10]; \
41 std source, [base + offset + 0x18]; \
42 std source, [base + offset + 0x20]; \
43 std source, [base + offset + 0x28]; \
44 std source, [base + offset + 0x30]; \
45 std source, [base + offset + 0x38];
47 #define ZERO_LAST_BLOCKS(base, offset, source) \
48 std source, [base - offset - 0x38]; \
49 std source, [base - offset - 0x30]; \
50 std source, [base - offset - 0x28]; \
51 std source, [base - offset - 0x20]; \
52 std source, [base - offset - 0x18]; \
53 std source, [base - offset - 0x10]; \
54 std source, [base - offset - 0x08]; \
55 std source, [base - offset - 0x00];
57 .text
58 .align 4
60 .globl __bzero_begin
61 __bzero_begin:
63 .globl __bzero, __memset,
64 .globl memset
65 .globl __memset_start, __memset_end
66 __memset_start:
67 __memset:
68 memset:
69 and %o1, 0xff, %g3
70 sll %g3, 8, %g2
71 or %g3, %g2, %g3
72 sll %g3, 16, %g2
73 or %g3, %g2, %g3
74 b 1f
75 mov %o2, %o1
76 3:
77 cmp %o2, 3
78 be 2f
79 EX(stb %g3, [%o0], sub %o1, 0)
81 cmp %o2, 2
82 be 2f
83 EX(stb %g3, [%o0 + 0x01], sub %o1, 1)
85 EX(stb %g3, [%o0 + 0x02], sub %o1, 2)
86 2:
87 sub %o2, 4, %o2
88 add %o1, %o2, %o1
89 b 4f
90 sub %o0, %o2, %o0
92 __bzero:
93 mov %g0, %g3
94 1:
95 cmp %o1, 7
96 bleu 7f
97 andcc %o0, 3, %o2
99 bne 3b
100 4:
101 andcc %o0, 4, %g0
103 be 2f
104 mov %g3, %g2
106 EX(st %g3, [%o0], sub %o1, 0)
107 sub %o1, 4, %o1
108 add %o0, 4, %o0
109 2:
110 andcc %o1, 0xffffff80, %o3 ! Now everything is 8 aligned and o1 is len to run
111 be 9f
112 andcc %o1, 0x78, %o2
113 10:
114 ZERO_BIG_BLOCK(%o0, 0x00, %g2)
115 subcc %o3, 128, %o3
116 ZERO_BIG_BLOCK(%o0, 0x40, %g2)
117 11:
118 EXT(10b, 11b, 20f)
119 bne 10b
120 add %o0, 128, %o0
122 orcc %o2, %g0, %g0
123 9:
124 be 13f
125 andcc %o1, 7, %o1
127 srl %o2, 1, %o3
128 set 13f, %o4
129 sub %o4, %o3, %o4
130 jmp %o4
131 add %o0, %o2, %o0
133 12:
134 ZERO_LAST_BLOCKS(%o0, 0x48, %g2)
135 ZERO_LAST_BLOCKS(%o0, 0x08, %g2)
136 13:
137 be 8f
138 andcc %o1, 4, %g0
140 be 1f
141 andcc %o1, 2, %g0
143 EX(st %g3, [%o0], and %o1, 7)
144 add %o0, 4, %o0
145 1:
146 be 1f
147 andcc %o1, 1, %g0
149 EX(sth %g3, [%o0], and %o1, 3)
150 add %o0, 2, %o0
151 1:
152 bne,a 8f
153 EX(stb %g3, [%o0], and %o1, 1)
154 8:
155 retl
156 clr %o0
157 7:
158 be 13b
159 orcc %o1, 0, %g0
161 be 0f
162 8:
163 add %o0, 1, %o0
164 subcc %o1, 1, %o1
165 bne,a 8b
166 EX(stb %g3, [%o0 - 1], add %o1, 1)
167 0:
168 retl
169 clr %o0
170 __memset_end:
172 .section .fixup,#alloc,#execinstr
173 .align 4
174 20:
175 cmp %g2, 8
176 bleu 1f
177 and %o1, 0x7f, %o1
178 sub %g2, 9, %g2
179 add %o3, 64, %o3
180 1:
181 sll %g2, 3, %g2
182 add %o3, %o1, %o0
183 b 30f
184 sub %o0, %g2, %o0
185 21:
186 mov 8, %o0
187 and %o1, 7, %o1
188 sub %o0, %g2, %o0
189 sll %o0, 3, %o0
190 b 30f
191 add %o0, %o1, %o0
192 30:
193 /* %o4 is faulting address, %o5 is %pc where fault occurred */
194 save %sp, -104, %sp
195 mov %i5, %o0
196 mov %i7, %o1
197 call lookup_fault
198 mov %i4, %o2
199 ret
200 restore
202 .globl __bzero_end
203 __bzero_end: