ia64/linux-2.6.18-xen.hg

view lib/string.c @ 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 /*
2 * linux/lib/string.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
7 /*
8 * stupid library routines.. The optimized versions should generally be found
9 * as inline code in <asm-xx/string.h>
10 *
11 * These are buggy as well..
12 *
13 * * Fri Jun 25 1999, Ingo Oeser <ioe@informatik.tu-chemnitz.de>
14 * - Added strsep() which will replace strtok() soon (because strsep() is
15 * reentrant and should be faster). Use only strsep() in new code, please.
16 *
17 * * Sat Feb 09 2002, Jason Thomas <jason@topic.com.au>,
18 * Matthew Hawkins <matt@mh.dropbear.id.au>
19 * - Kissed strtok() goodbye
20 */
22 #include <linux/types.h>
23 #include <linux/string.h>
24 #include <linux/ctype.h>
25 #include <linux/module.h>
27 #ifndef __HAVE_ARCH_STRNICMP
28 /**
29 * strnicmp - Case insensitive, length-limited string comparison
30 * @s1: One string
31 * @s2: The other string
32 * @len: the maximum number of characters to compare
33 */
34 int strnicmp(const char *s1, const char *s2, size_t len)
35 {
36 /* Yes, Virginia, it had better be unsigned */
37 unsigned char c1, c2;
39 c1 = c2 = 0;
40 if (len) {
41 do {
42 c1 = *s1;
43 c2 = *s2;
44 s1++;
45 s2++;
46 if (!c1)
47 break;
48 if (!c2)
49 break;
50 if (c1 == c2)
51 continue;
52 c1 = tolower(c1);
53 c2 = tolower(c2);
54 if (c1 != c2)
55 break;
56 } while (--len);
57 }
58 return (int)c1 - (int)c2;
59 }
60 EXPORT_SYMBOL(strnicmp);
61 #endif
63 #ifndef __HAVE_ARCH_STRCPY
64 /**
65 * strcpy - Copy a %NUL terminated string
66 * @dest: Where to copy the string to
67 * @src: Where to copy the string from
68 */
69 #undef strcpy
70 char *strcpy(char *dest, const char *src)
71 {
72 char *tmp = dest;
74 while ((*dest++ = *src++) != '\0')
75 /* nothing */;
76 return tmp;
77 }
78 EXPORT_SYMBOL(strcpy);
79 #endif
81 #ifndef __HAVE_ARCH_STRNCPY
82 /**
83 * strncpy - Copy a length-limited, %NUL-terminated string
84 * @dest: Where to copy the string to
85 * @src: Where to copy the string from
86 * @count: The maximum number of bytes to copy
87 *
88 * The result is not %NUL-terminated if the source exceeds
89 * @count bytes.
90 *
91 * In the case where the length of @src is less than that of
92 * count, the remainder of @dest will be padded with %NUL.
93 *
94 */
95 char *strncpy(char *dest, const char *src, size_t count)
96 {
97 char *tmp = dest;
99 while (count) {
100 if ((*tmp = *src) != 0)
101 src++;
102 tmp++;
103 count--;
104 }
105 return dest;
106 }
107 EXPORT_SYMBOL(strncpy);
108 #endif
110 #ifndef __HAVE_ARCH_STRLCPY
111 /**
112 * strlcpy - Copy a %NUL terminated string into a sized buffer
113 * @dest: Where to copy the string to
114 * @src: Where to copy the string from
115 * @size: size of destination buffer
116 *
117 * Compatible with *BSD: the result is always a valid
118 * NUL-terminated string that fits in the buffer (unless,
119 * of course, the buffer size is zero). It does not pad
120 * out the result like strncpy() does.
121 */
122 size_t strlcpy(char *dest, const char *src, size_t size)
123 {
124 size_t ret = strlen(src);
126 if (size) {
127 size_t len = (ret >= size) ? size - 1 : ret;
128 memcpy(dest, src, len);
129 dest[len] = '\0';
130 }
131 return ret;
132 }
133 EXPORT_SYMBOL(strlcpy);
134 #endif
136 #ifndef __HAVE_ARCH_STRCAT
137 /**
138 * strcat - Append one %NUL-terminated string to another
139 * @dest: The string to be appended to
140 * @src: The string to append to it
141 */
142 #undef strcat
143 char *strcat(char *dest, const char *src)
144 {
145 char *tmp = dest;
147 while (*dest)
148 dest++;
149 while ((*dest++ = *src++) != '\0')
150 ;
151 return tmp;
152 }
153 EXPORT_SYMBOL(strcat);
154 #endif
156 #ifndef __HAVE_ARCH_STRNCAT
157 /**
158 * strncat - Append a length-limited, %NUL-terminated string to another
159 * @dest: The string to be appended to
160 * @src: The string to append to it
161 * @count: The maximum numbers of bytes to copy
162 *
163 * Note that in contrast to strncpy, strncat ensures the result is
164 * terminated.
165 */
166 char *strncat(char *dest, const char *src, size_t count)
167 {
168 char *tmp = dest;
170 if (count) {
171 while (*dest)
172 dest++;
173 while ((*dest++ = *src++) != 0) {
174 if (--count == 0) {
175 *dest = '\0';
176 break;
177 }
178 }
179 }
180 return tmp;
181 }
182 EXPORT_SYMBOL(strncat);
183 #endif
185 #ifndef __HAVE_ARCH_STRLCAT
186 /**
187 * strlcat - Append a length-limited, %NUL-terminated string to another
188 * @dest: The string to be appended to
189 * @src: The string to append to it
190 * @count: The size of the destination buffer.
191 */
192 size_t strlcat(char *dest, const char *src, size_t count)
193 {
194 size_t dsize = strlen(dest);
195 size_t len = strlen(src);
196 size_t res = dsize + len;
198 /* This would be a bug */
199 BUG_ON(dsize >= count);
201 dest += dsize;
202 count -= dsize;
203 if (len >= count)
204 len = count-1;
205 memcpy(dest, src, len);
206 dest[len] = 0;
207 return res;
208 }
209 EXPORT_SYMBOL(strlcat);
210 #endif
212 #ifndef __HAVE_ARCH_STRCMP
213 /**
214 * strcmp - Compare two strings
215 * @cs: One string
216 * @ct: Another string
217 */
218 #undef strcmp
219 int strcmp(const char *cs, const char *ct)
220 {
221 signed char __res;
223 while (1) {
224 if ((__res = *cs - *ct++) != 0 || !*cs++)
225 break;
226 }
227 return __res;
228 }
229 EXPORT_SYMBOL(strcmp);
230 #endif
232 #ifndef __HAVE_ARCH_STRNCMP
233 /**
234 * strncmp - Compare two length-limited strings
235 * @cs: One string
236 * @ct: Another string
237 * @count: The maximum number of bytes to compare
238 */
239 int strncmp(const char *cs, const char *ct, size_t count)
240 {
241 signed char __res = 0;
243 while (count) {
244 if ((__res = *cs - *ct++) != 0 || !*cs++)
245 break;
246 count--;
247 }
248 return __res;
249 }
250 EXPORT_SYMBOL(strncmp);
251 #endif
253 #ifndef __HAVE_ARCH_STRCHR
254 /**
255 * strchr - Find the first occurrence of a character in a string
256 * @s: The string to be searched
257 * @c: The character to search for
258 */
259 char *strchr(const char *s, int c)
260 {
261 for (; *s != (char)c; ++s)
262 if (*s == '\0')
263 return NULL;
264 return (char *)s;
265 }
266 EXPORT_SYMBOL(strchr);
267 #endif
269 #ifndef __HAVE_ARCH_STRRCHR
270 /**
271 * strrchr - Find the last occurrence of a character in a string
272 * @s: The string to be searched
273 * @c: The character to search for
274 */
275 char *strrchr(const char *s, int c)
276 {
277 const char *p = s + strlen(s);
278 do {
279 if (*p == (char)c)
280 return (char *)p;
281 } while (--p >= s);
282 return NULL;
283 }
284 EXPORT_SYMBOL(strrchr);
285 #endif
287 #ifndef __HAVE_ARCH_STRNCHR
288 /**
289 * strnchr - Find a character in a length limited string
290 * @s: The string to be searched
291 * @count: The number of characters to be searched
292 * @c: The character to search for
293 */
294 char *strnchr(const char *s, size_t count, int c)
295 {
296 for (; count-- && *s != '\0'; ++s)
297 if (*s == (char)c)
298 return (char *)s;
299 return NULL;
300 }
301 EXPORT_SYMBOL(strnchr);
302 #endif
304 /**
305 * strstrip - Removes leading and trailing whitespace from @s.
306 * @s: The string to be stripped.
307 *
308 * Note that the first trailing whitespace is replaced with a %NUL-terminator
309 * in the given string @s. Returns a pointer to the first non-whitespace
310 * character in @s.
311 */
312 char *strstrip(char *s)
313 {
314 size_t size;
315 char *end;
317 size = strlen(s);
319 if (!size)
320 return s;
322 end = s + size - 1;
323 while (end != s && isspace(*end))
324 end--;
325 *(end + 1) = '\0';
327 while (*s && isspace(*s))
328 s++;
330 return s;
331 }
332 EXPORT_SYMBOL(strstrip);
334 #ifndef __HAVE_ARCH_STRLEN
335 /**
336 * strlen - Find the length of a string
337 * @s: The string to be sized
338 */
339 size_t strlen(const char *s)
340 {
341 const char *sc;
343 for (sc = s; *sc != '\0'; ++sc)
344 /* nothing */;
345 return sc - s;
346 }
347 EXPORT_SYMBOL(strlen);
348 #endif
350 #ifndef __HAVE_ARCH_STRNLEN
351 /**
352 * strnlen - Find the length of a length-limited string
353 * @s: The string to be sized
354 * @count: The maximum number of bytes to search
355 */
356 size_t strnlen(const char *s, size_t count)
357 {
358 const char *sc;
360 for (sc = s; count-- && *sc != '\0'; ++sc)
361 /* nothing */;
362 return sc - s;
363 }
364 EXPORT_SYMBOL(strnlen);
365 #endif
367 #ifndef __HAVE_ARCH_STRSPN
368 /**
369 * strspn - Calculate the length of the initial substring of @s which only
370 * contain letters in @accept
371 * @s: The string to be searched
372 * @accept: The string to search for
373 */
374 size_t strspn(const char *s, const char *accept)
375 {
376 const char *p;
377 const char *a;
378 size_t count = 0;
380 for (p = s; *p != '\0'; ++p) {
381 for (a = accept; *a != '\0'; ++a) {
382 if (*p == *a)
383 break;
384 }
385 if (*a == '\0')
386 return count;
387 ++count;
388 }
389 return count;
390 }
392 EXPORT_SYMBOL(strspn);
393 #endif
395 #ifndef __HAVE_ARCH_STRCSPN
396 /**
397 * strcspn - Calculate the length of the initial substring of @s which does
398 * not contain letters in @reject
399 * @s: The string to be searched
400 * @reject: The string to avoid
401 */
402 size_t strcspn(const char *s, const char *reject)
403 {
404 const char *p;
405 const char *r;
406 size_t count = 0;
408 for (p = s; *p != '\0'; ++p) {
409 for (r = reject; *r != '\0'; ++r) {
410 if (*p == *r)
411 return count;
412 }
413 ++count;
414 }
415 return count;
416 }
417 EXPORT_SYMBOL(strcspn);
418 #endif
420 #ifndef __HAVE_ARCH_STRPBRK
421 /**
422 * strpbrk - Find the first occurrence of a set of characters
423 * @cs: The string to be searched
424 * @ct: The characters to search for
425 */
426 char *strpbrk(const char *cs, const char *ct)
427 {
428 const char *sc1, *sc2;
430 for (sc1 = cs; *sc1 != '\0'; ++sc1) {
431 for (sc2 = ct; *sc2 != '\0'; ++sc2) {
432 if (*sc1 == *sc2)
433 return (char *)sc1;
434 }
435 }
436 return NULL;
437 }
438 EXPORT_SYMBOL(strpbrk);
439 #endif
441 #ifndef __HAVE_ARCH_STRSEP
442 /**
443 * strsep - Split a string into tokens
444 * @s: The string to be searched
445 * @ct: The characters to search for
446 *
447 * strsep() updates @s to point after the token, ready for the next call.
448 *
449 * It returns empty tokens, too, behaving exactly like the libc function
450 * of that name. In fact, it was stolen from glibc2 and de-fancy-fied.
451 * Same semantics, slimmer shape. ;)
452 */
453 char *strsep(char **s, const char *ct)
454 {
455 char *sbegin = *s;
456 char *end;
458 if (sbegin == NULL)
459 return NULL;
461 end = strpbrk(sbegin, ct);
462 if (end)
463 *end++ = '\0';
464 *s = end;
465 return sbegin;
466 }
467 EXPORT_SYMBOL(strsep);
468 #endif
470 #ifndef __HAVE_ARCH_MEMSET
471 /**
472 * memset - Fill a region of memory with the given value
473 * @s: Pointer to the start of the area.
474 * @c: The byte to fill the area with
475 * @count: The size of the area.
476 *
477 * Do not use memset() to access IO space, use memset_io() instead.
478 */
479 void *memset(void *s, int c, size_t count)
480 {
481 char *xs = s;
483 while (count--)
484 *xs++ = c;
485 return s;
486 }
487 EXPORT_SYMBOL(memset);
488 #endif
490 #ifndef __HAVE_ARCH_MEMCPY
491 /**
492 * memcpy - Copy one area of memory to another
493 * @dest: Where to copy to
494 * @src: Where to copy from
495 * @count: The size of the area.
496 *
497 * You should not use this function to access IO space, use memcpy_toio()
498 * or memcpy_fromio() instead.
499 */
500 void *memcpy(void *dest, const void *src, size_t count)
501 {
502 char *tmp = dest;
503 const char *s = src;
505 while (count--)
506 *tmp++ = *s++;
507 return dest;
508 }
509 EXPORT_SYMBOL(memcpy);
510 #endif
512 #ifndef __HAVE_ARCH_MEMMOVE
513 /**
514 * memmove - Copy one area of memory to another
515 * @dest: Where to copy to
516 * @src: Where to copy from
517 * @count: The size of the area.
518 *
519 * Unlike memcpy(), memmove() copes with overlapping areas.
520 */
521 void *memmove(void *dest, const void *src, size_t count)
522 {
523 char *tmp;
524 const char *s;
526 if (dest <= src) {
527 tmp = dest;
528 s = src;
529 while (count--)
530 *tmp++ = *s++;
531 } else {
532 tmp = dest;
533 tmp += count;
534 s = src;
535 s += count;
536 while (count--)
537 *--tmp = *--s;
538 }
539 return dest;
540 }
541 EXPORT_SYMBOL(memmove);
542 #endif
544 #ifndef __HAVE_ARCH_MEMCMP
545 /**
546 * memcmp - Compare two areas of memory
547 * @cs: One area of memory
548 * @ct: Another area of memory
549 * @count: The size of the area.
550 */
551 #undef memcmp
552 int memcmp(const void *cs, const void *ct, size_t count)
553 {
554 const unsigned char *su1, *su2;
555 int res = 0;
557 for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
558 if ((res = *su1 - *su2) != 0)
559 break;
560 return res;
561 }
562 EXPORT_SYMBOL(memcmp);
563 #endif
565 #ifndef __HAVE_ARCH_MEMSCAN
566 /**
567 * memscan - Find a character in an area of memory.
568 * @addr: The memory area
569 * @c: The byte to search for
570 * @size: The size of the area.
571 *
572 * returns the address of the first occurrence of @c, or 1 byte past
573 * the area if @c is not found
574 */
575 void *memscan(void *addr, int c, size_t size)
576 {
577 unsigned char *p = addr;
579 while (size) {
580 if (*p == c)
581 return (void *)p;
582 p++;
583 size--;
584 }
585 return (void *)p;
586 }
587 EXPORT_SYMBOL(memscan);
588 #endif
590 #ifndef __HAVE_ARCH_STRSTR
591 /**
592 * strstr - Find the first substring in a %NUL terminated string
593 * @s1: The string to be searched
594 * @s2: The string to search for
595 */
596 char *strstr(const char *s1, const char *s2)
597 {
598 int l1, l2;
600 l2 = strlen(s2);
601 if (!l2)
602 return (char *)s1;
603 l1 = strlen(s1);
604 while (l1 >= l2) {
605 l1--;
606 if (!memcmp(s1, s2, l2))
607 return (char *)s1;
608 s1++;
609 }
610 return NULL;
611 }
612 EXPORT_SYMBOL(strstr);
613 #endif
615 #ifndef __HAVE_ARCH_MEMCHR
616 /**
617 * memchr - Find a character in an area of memory.
618 * @s: The memory area
619 * @c: The byte to search for
620 * @n: The size of the area.
621 *
622 * returns the address of the first occurrence of @c, or %NULL
623 * if @c is not found
624 */
625 void *memchr(const void *s, int c, size_t n)
626 {
627 const unsigned char *p = s;
628 while (n-- != 0) {
629 if ((unsigned char)c == *p++) {
630 return (void *)(p - 1);
631 }
632 }
633 return NULL;
634 }
635 EXPORT_SYMBOL(memchr);
636 #endif