ia64/linux-2.6.18-xen.hg

view drivers/md/dm-log.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 /*
2 * Copyright (C) 2003 Sistina Software
3 *
4 * This file is released under the LGPL.
5 */
7 #ifndef DM_DIRTY_LOG
8 #define DM_DIRTY_LOG
10 #include "dm.h"
12 typedef sector_t region_t;
14 struct dirty_log_type;
16 struct dirty_log {
17 struct dirty_log_type *type;
18 void *context;
19 };
21 struct dirty_log_type {
22 struct list_head list;
23 const char *name;
24 struct module *module;
25 unsigned int use_count;
27 int (*ctr)(struct dirty_log *log, struct dm_target *ti,
28 unsigned int argc, char **argv);
29 void (*dtr)(struct dirty_log *log);
31 /*
32 * There are times when we don't want the log to touch
33 * the disk.
34 */
35 int (*suspend)(struct dirty_log *log);
36 int (*resume)(struct dirty_log *log);
38 /*
39 * Retrieves the smallest size of region that the log can
40 * deal with.
41 */
42 uint32_t (*get_region_size)(struct dirty_log *log);
44 /*
45 * A predicate to say whether a region is clean or not.
46 * May block.
47 */
48 int (*is_clean)(struct dirty_log *log, region_t region);
50 /*
51 * Returns: 0, 1, -EWOULDBLOCK, < 0
52 *
53 * A predicate function to check the area given by
54 * [sector, sector + len) is in sync.
55 *
56 * If -EWOULDBLOCK is returned the state of the region is
57 * unknown, typically this will result in a read being
58 * passed to a daemon to deal with, since a daemon is
59 * allowed to block.
60 */
61 int (*in_sync)(struct dirty_log *log, region_t region, int can_block);
63 /*
64 * Flush the current log state (eg, to disk). This
65 * function may block.
66 */
67 int (*flush)(struct dirty_log *log);
69 /*
70 * Mark an area as clean or dirty. These functions may
71 * block, though for performance reasons blocking should
72 * be extremely rare (eg, allocating another chunk of
73 * memory for some reason).
74 */
75 void (*mark_region)(struct dirty_log *log, region_t region);
76 void (*clear_region)(struct dirty_log *log, region_t region);
78 /*
79 * Returns: <0 (error), 0 (no region), 1 (region)
80 *
81 * The mirrord will need perform recovery on regions of
82 * the mirror that are in the NOSYNC state. This
83 * function asks the log to tell the caller about the
84 * next region that this machine should recover.
85 *
86 * Do not confuse this function with 'in_sync()', one
87 * tells you if an area is synchronised, the other
88 * assigns recovery work.
89 */
90 int (*get_resync_work)(struct dirty_log *log, region_t *region);
92 /*
93 * This notifies the log that the resync of an area has
94 * been completed. The log should then mark this region
95 * as CLEAN.
96 */
97 void (*complete_resync_work)(struct dirty_log *log,
98 region_t region, int success);
100 /*
101 * Returns the number of regions that are in sync.
102 */
103 region_t (*get_sync_count)(struct dirty_log *log);
105 /*
106 * Support function for mirror status requests.
107 */
108 int (*status)(struct dirty_log *log, status_type_t status_type,
109 char *result, unsigned int maxlen);
110 };
112 int dm_register_dirty_log_type(struct dirty_log_type *type);
113 int dm_unregister_dirty_log_type(struct dirty_log_type *type);
116 /*
117 * Make sure you use these two functions, rather than calling
118 * type->constructor/destructor() directly.
119 */
120 struct dirty_log *dm_create_dirty_log(const char *type_name, struct dm_target *ti,
121 unsigned int argc, char **argv);
122 void dm_destroy_dirty_log(struct dirty_log *log);
124 /*
125 * init/exit functions.
126 */
127 int dm_dirty_log_init(void);
128 void dm_dirty_log_exit(void);
130 #endif