ia64/linux-2.6.18-xen.hg

view drivers/md/raid6.h @ 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-c -*- ------------------------------------------------------- *
2 *
3 * Copyright 2003 H. Peter Anvin - All Rights Reserved
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation, Inc., 53 Temple Place Ste 330,
8 * Bostom MA 02111-1307, USA; either version 2 of the License, or
9 * (at your option) any later version; incorporated herein by reference.
10 *
11 * ----------------------------------------------------------------------- */
13 #ifndef LINUX_RAID_RAID6_H
14 #define LINUX_RAID_RAID6_H
16 #ifdef __KERNEL__
18 /* Set to 1 to use kernel-wide empty_zero_page */
19 #define RAID6_USE_EMPTY_ZERO_PAGE 0
21 #include <linux/module.h>
22 #include <linux/stddef.h>
23 #include <linux/compiler.h>
24 #include <linux/types.h>
25 #include <linux/kernel.h>
26 #include <linux/errno.h>
27 #include <linux/mempool.h>
28 #include <linux/list.h>
29 #include <linux/vmalloc.h>
30 #include <linux/raid/md.h>
31 #include <linux/raid/raid5.h>
33 typedef raid5_conf_t raid6_conf_t; /* Same configuration */
35 /* Additional compute_parity mode -- updates the parity w/o LOCKING */
36 #define UPDATE_PARITY 4
38 /* We need a pre-zeroed page... if we don't want to use the kernel-provided
39 one define it here */
40 #if RAID6_USE_EMPTY_ZERO_PAGE
41 # define raid6_empty_zero_page empty_zero_page
42 #else
43 extern const char raid6_empty_zero_page[PAGE_SIZE];
44 #endif
46 #else /* ! __KERNEL__ */
47 /* Used for testing in user space */
49 #include <errno.h>
50 #include <inttypes.h>
51 #include <limits.h>
52 #include <stddef.h>
53 #include <sys/mman.h>
54 #include <sys/types.h>
56 /* Not standard, but glibc defines it */
57 #define BITS_PER_LONG __WORDSIZE
59 typedef uint8_t u8;
60 typedef uint16_t u16;
61 typedef uint32_t u32;
62 typedef uint64_t u64;
64 #ifndef PAGE_SIZE
65 # define PAGE_SIZE 4096
66 #endif
67 extern const char raid6_empty_zero_page[PAGE_SIZE];
69 #define __init
70 #define __exit
71 #define __attribute_const__ __attribute__((const))
72 #define noinline __attribute__((noinline))
74 #define preempt_enable()
75 #define preempt_disable()
76 #define cpu_has_feature(x) 1
77 #define enable_kernel_altivec()
78 #define disable_kernel_altivec()
80 #endif /* __KERNEL__ */
82 /* Routine choices */
83 struct raid6_calls {
84 void (*gen_syndrome)(int, size_t, void **);
85 int (*valid)(void); /* Returns 1 if this routine set is usable */
86 const char *name; /* Name of this routine set */
87 int prefer; /* Has special performance attribute */
88 };
90 /* Selected algorithm */
91 extern struct raid6_calls raid6_call;
93 /* Algorithm list */
94 extern const struct raid6_calls * const raid6_algos[];
95 int raid6_select_algo(void);
97 /* Return values from chk_syndrome */
98 #define RAID6_OK 0
99 #define RAID6_P_BAD 1
100 #define RAID6_Q_BAD 2
101 #define RAID6_PQ_BAD 3
103 /* Galois field tables */
104 extern const u8 raid6_gfmul[256][256] __attribute__((aligned(256)));
105 extern const u8 raid6_gfexp[256] __attribute__((aligned(256)));
106 extern const u8 raid6_gfinv[256] __attribute__((aligned(256)));
107 extern const u8 raid6_gfexi[256] __attribute__((aligned(256)));
109 /* Recovery routines */
110 void raid6_2data_recov(int disks, size_t bytes, int faila, int failb, void **ptrs);
111 void raid6_datap_recov(int disks, size_t bytes, int faila, void **ptrs);
112 void raid6_dual_recov(int disks, size_t bytes, int faila, int failb, void **ptrs);
114 /* Some definitions to allow code to be compiled for testing in userspace */
115 #ifndef __KERNEL__
117 # define jiffies raid6_jiffies()
118 # define printk printf
119 # define GFP_KERNEL 0
120 # define __get_free_pages(x,y) ((unsigned long)mmap(NULL, PAGE_SIZE << (y), PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, 0, 0))
121 # define free_pages(x,y) munmap((void *)(x), (y)*PAGE_SIZE)
123 static inline void cpu_relax(void)
124 {
125 /* Nothing */
126 }
128 #undef HZ
129 #define HZ 1000
130 static inline uint32_t raid6_jiffies(void)
131 {
132 struct timeval tv;
133 gettimeofday(&tv, NULL);
134 return tv.tv_sec*1000 + tv.tv_usec/1000;
135 }
137 #endif /* ! __KERNEL__ */
139 #endif /* LINUX_RAID_RAID6_H */