ia64/linux-2.6.18-xen.hg

view lib/kobject.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 * kobject.c - library routines for handling generic kernel objects
3 *
4 * Copyright (c) 2002-2003 Patrick Mochel <mochel@osdl.org>
5 *
6 * This file is released under the GPLv2.
7 *
8 *
9 * Please see the file Documentation/kobject.txt for critical information
10 * about using the kobject interface.
11 */
13 #include <linux/kobject.h>
14 #include <linux/string.h>
15 #include <linux/module.h>
16 #include <linux/stat.h>
17 #include <linux/slab.h>
19 /**
20 * populate_dir - populate directory with attributes.
21 * @kobj: object we're working on.
22 *
23 * Most subsystems have a set of default attributes that
24 * are associated with an object that registers with them.
25 * This is a helper called during object registration that
26 * loops through the default attributes of the subsystem
27 * and creates attributes files for them in sysfs.
28 *
29 */
31 static int populate_dir(struct kobject * kobj)
32 {
33 struct kobj_type * t = get_ktype(kobj);
34 struct attribute * attr;
35 int error = 0;
36 int i;
38 if (t && t->default_attrs) {
39 for (i = 0; (attr = t->default_attrs[i]) != NULL; i++) {
40 if ((error = sysfs_create_file(kobj,attr)))
41 break;
42 }
43 }
44 return error;
45 }
47 static int create_dir(struct kobject * kobj)
48 {
49 int error = 0;
50 if (kobject_name(kobj)) {
51 error = sysfs_create_dir(kobj);
52 if (!error) {
53 if ((error = populate_dir(kobj)))
54 sysfs_remove_dir(kobj);
55 }
56 }
57 return error;
58 }
60 static inline struct kobject * to_kobj(struct list_head * entry)
61 {
62 return container_of(entry,struct kobject,entry);
63 }
65 static int get_kobj_path_length(struct kobject *kobj)
66 {
67 int length = 1;
68 struct kobject * parent = kobj;
70 /* walk up the ancestors until we hit the one pointing to the
71 * root.
72 * Add 1 to strlen for leading '/' of each level.
73 */
74 do {
75 if (kobject_name(parent) == NULL)
76 return 0;
77 length += strlen(kobject_name(parent)) + 1;
78 parent = parent->parent;
79 } while (parent);
80 return length;
81 }
83 static void fill_kobj_path(struct kobject *kobj, char *path, int length)
84 {
85 struct kobject * parent;
87 --length;
88 for (parent = kobj; parent; parent = parent->parent) {
89 int cur = strlen(kobject_name(parent));
90 /* back up enough to print this name with '/' */
91 length -= cur;
92 strncpy (path + length, kobject_name(parent), cur);
93 *(path + --length) = '/';
94 }
96 pr_debug("%s: path = '%s'\n",__FUNCTION__,path);
97 }
99 /**
100 * kobject_get_path - generate and return the path associated with a given kobj
101 * and kset pair. The result must be freed by the caller with kfree().
102 *
103 * @kobj: kobject in question, with which to build the path
104 * @gfp_mask: the allocation type used to allocate the path
105 */
106 char *kobject_get_path(struct kobject *kobj, gfp_t gfp_mask)
107 {
108 char *path;
109 int len;
111 len = get_kobj_path_length(kobj);
112 if (len == 0)
113 return NULL;
114 path = kmalloc(len, gfp_mask);
115 if (!path)
116 return NULL;
117 memset(path, 0x00, len);
118 fill_kobj_path(kobj, path, len);
120 return path;
121 }
123 /**
124 * kobject_init - initialize object.
125 * @kobj: object in question.
126 */
127 void kobject_init(struct kobject * kobj)
128 {
129 kref_init(&kobj->kref);
130 INIT_LIST_HEAD(&kobj->entry);
131 init_waitqueue_head(&kobj->poll);
132 kobj->kset = kset_get(kobj->kset);
133 }
136 /**
137 * unlink - remove kobject from kset list.
138 * @kobj: kobject.
139 *
140 * Remove the kobject from the kset list and decrement
141 * its parent's refcount.
142 * This is separated out, so we can use it in both
143 * kobject_del() and kobject_add() on error.
144 */
146 static void unlink(struct kobject * kobj)
147 {
148 if (kobj->kset) {
149 spin_lock(&kobj->kset->list_lock);
150 list_del_init(&kobj->entry);
151 spin_unlock(&kobj->kset->list_lock);
152 }
153 kobject_put(kobj);
154 }
156 /**
157 * kobject_add - add an object to the hierarchy.
158 * @kobj: object.
159 */
161 int kobject_add(struct kobject * kobj)
162 {
163 int error = 0;
164 struct kobject * parent;
166 if (!(kobj = kobject_get(kobj)))
167 return -ENOENT;
168 if (!kobj->k_name)
169 kobj->k_name = kobj->name;
170 if (!kobj->k_name) {
171 pr_debug("kobject attempted to be registered with no name!\n");
172 WARN_ON(1);
173 return -EINVAL;
174 }
175 parent = kobject_get(kobj->parent);
177 pr_debug("kobject %s: registering. parent: %s, set: %s\n",
178 kobject_name(kobj), parent ? kobject_name(parent) : "<NULL>",
179 kobj->kset ? kobj->kset->kobj.name : "<NULL>" );
181 if (kobj->kset) {
182 spin_lock(&kobj->kset->list_lock);
184 if (!parent)
185 parent = kobject_get(&kobj->kset->kobj);
187 list_add_tail(&kobj->entry,&kobj->kset->list);
188 spin_unlock(&kobj->kset->list_lock);
189 }
190 kobj->parent = parent;
192 error = create_dir(kobj);
193 if (error) {
194 /* unlink does the kobject_put() for us */
195 unlink(kobj);
196 if (parent)
197 kobject_put(parent);
199 /* be noisy on error issues */
200 if (error == -EEXIST)
201 printk("kobject_add failed for %s with -EEXIST, "
202 "don't try to register things with the "
203 "same name in the same directory.\n",
204 kobject_name(kobj));
205 else
206 printk("kobject_add failed for %s (%d)\n",
207 kobject_name(kobj), error);
208 dump_stack();
209 }
211 return error;
212 }
215 /**
216 * kobject_register - initialize and add an object.
217 * @kobj: object in question.
218 */
220 int kobject_register(struct kobject * kobj)
221 {
222 int error = -EINVAL;
223 if (kobj) {
224 kobject_init(kobj);
225 error = kobject_add(kobj);
226 if (!error)
227 kobject_uevent(kobj, KOBJ_ADD);
228 }
229 return error;
230 }
233 /**
234 * kobject_set_name - Set the name of an object
235 * @kobj: object.
236 * @fmt: format string used to build the name
237 *
238 * If strlen(name) >= KOBJ_NAME_LEN, then use a dynamically allocated
239 * string that @kobj->k_name points to. Otherwise, use the static
240 * @kobj->name array.
241 */
242 int kobject_set_name(struct kobject * kobj, const char * fmt, ...)
243 {
244 int error = 0;
245 int limit = KOBJ_NAME_LEN;
246 int need;
247 va_list args;
248 char * name;
250 /*
251 * First, try the static array
252 */
253 va_start(args,fmt);
254 need = vsnprintf(kobj->name,limit,fmt,args);
255 va_end(args);
256 if (need < limit)
257 name = kobj->name;
258 else {
259 /*
260 * Need more space? Allocate it and try again
261 */
262 limit = need + 1;
263 name = kmalloc(limit,GFP_KERNEL);
264 if (!name) {
265 error = -ENOMEM;
266 goto Done;
267 }
268 va_start(args,fmt);
269 need = vsnprintf(name,limit,fmt,args);
270 va_end(args);
272 /* Still? Give up. */
273 if (need >= limit) {
274 kfree(name);
275 error = -EFAULT;
276 goto Done;
277 }
278 }
280 /* Free the old name, if necessary. */
281 if (kobj->k_name && kobj->k_name != kobj->name)
282 kfree(kobj->k_name);
284 /* Now, set the new name */
285 kobj->k_name = name;
286 Done:
287 return error;
288 }
290 EXPORT_SYMBOL(kobject_set_name);
293 /**
294 * kobject_rename - change the name of an object
295 * @kobj: object in question.
296 * @new_name: object's new name
297 */
299 int kobject_rename(struct kobject * kobj, const char *new_name)
300 {
301 int error = 0;
303 kobj = kobject_get(kobj);
304 if (!kobj)
305 return -EINVAL;
306 error = sysfs_rename_dir(kobj, new_name);
307 kobject_put(kobj);
309 return error;
310 }
312 /**
313 * kobject_del - unlink kobject from hierarchy.
314 * @kobj: object.
315 */
317 void kobject_del(struct kobject * kobj)
318 {
319 sysfs_remove_dir(kobj);
320 unlink(kobj);
321 }
323 /**
324 * kobject_unregister - remove object from hierarchy and decrement refcount.
325 * @kobj: object going away.
326 */
328 void kobject_unregister(struct kobject * kobj)
329 {
330 pr_debug("kobject %s: unregistering\n",kobject_name(kobj));
331 kobject_uevent(kobj, KOBJ_REMOVE);
332 kobject_del(kobj);
333 kobject_put(kobj);
334 }
336 /**
337 * kobject_get - increment refcount for object.
338 * @kobj: object.
339 */
341 struct kobject * kobject_get(struct kobject * kobj)
342 {
343 if (kobj)
344 kref_get(&kobj->kref);
345 return kobj;
346 }
348 /**
349 * kobject_cleanup - free kobject resources.
350 * @kobj: object.
351 */
353 void kobject_cleanup(struct kobject * kobj)
354 {
355 struct kobj_type * t = get_ktype(kobj);
356 struct kset * s = kobj->kset;
357 struct kobject * parent = kobj->parent;
359 pr_debug("kobject %s: cleaning up\n",kobject_name(kobj));
360 if (kobj->k_name != kobj->name)
361 kfree(kobj->k_name);
362 kobj->k_name = NULL;
363 if (t && t->release)
364 t->release(kobj);
365 if (s)
366 kset_put(s);
367 if (parent)
368 kobject_put(parent);
369 }
371 static void kobject_release(struct kref *kref)
372 {
373 kobject_cleanup(container_of(kref, struct kobject, kref));
374 }
376 /**
377 * kobject_put - decrement refcount for object.
378 * @kobj: object.
379 *
380 * Decrement the refcount, and if 0, call kobject_cleanup().
381 */
382 void kobject_put(struct kobject * kobj)
383 {
384 if (kobj)
385 kref_put(&kobj->kref, kobject_release);
386 }
389 static void dir_release(struct kobject *kobj)
390 {
391 kfree(kobj);
392 }
394 static struct kobj_type dir_ktype = {
395 .release = dir_release,
396 .sysfs_ops = NULL,
397 .default_attrs = NULL,
398 };
400 /**
401 * kobject_add_dir - add sub directory of object.
402 * @parent: object in which a directory is created.
403 * @name: directory name.
404 *
405 * Add a plain directory object as child of given object.
406 */
407 struct kobject *kobject_add_dir(struct kobject *parent, const char *name)
408 {
409 struct kobject *k;
411 if (!parent)
412 return NULL;
414 k = kzalloc(sizeof(*k), GFP_KERNEL);
415 if (!k)
416 return NULL;
418 k->parent = parent;
419 k->ktype = &dir_ktype;
420 kobject_set_name(k, name);
421 kobject_register(k);
423 return k;
424 }
426 /**
427 * kset_init - initialize a kset for use
428 * @k: kset
429 */
431 void kset_init(struct kset * k)
432 {
433 kobject_init(&k->kobj);
434 INIT_LIST_HEAD(&k->list);
435 spin_lock_init(&k->list_lock);
436 }
439 /**
440 * kset_add - add a kset object to the hierarchy.
441 * @k: kset.
442 *
443 * Simply, this adds the kset's embedded kobject to the
444 * hierarchy.
445 * We also try to make sure that the kset's embedded kobject
446 * has a parent before it is added. We only care if the embedded
447 * kobject is not part of a kset itself, since kobject_add()
448 * assigns a parent in that case.
449 * If that is the case, and the kset has a controlling subsystem,
450 * then we set the kset's parent to be said subsystem.
451 */
453 int kset_add(struct kset * k)
454 {
455 if (!k->kobj.parent && !k->kobj.kset && k->subsys)
456 k->kobj.parent = &k->subsys->kset.kobj;
458 return kobject_add(&k->kobj);
459 }
462 /**
463 * kset_register - initialize and add a kset.
464 * @k: kset.
465 */
467 int kset_register(struct kset * k)
468 {
469 kset_init(k);
470 return kset_add(k);
471 }
474 /**
475 * kset_unregister - remove a kset.
476 * @k: kset.
477 */
479 void kset_unregister(struct kset * k)
480 {
481 kobject_unregister(&k->kobj);
482 }
485 /**
486 * kset_find_obj - search for object in kset.
487 * @kset: kset we're looking in.
488 * @name: object's name.
489 *
490 * Lock kset via @kset->subsys, and iterate over @kset->list,
491 * looking for a matching kobject. If matching object is found
492 * take a reference and return the object.
493 */
495 struct kobject * kset_find_obj(struct kset * kset, const char * name)
496 {
497 struct list_head * entry;
498 struct kobject * ret = NULL;
500 spin_lock(&kset->list_lock);
501 list_for_each(entry,&kset->list) {
502 struct kobject * k = to_kobj(entry);
503 if (kobject_name(k) && !strcmp(kobject_name(k),name)) {
504 ret = kobject_get(k);
505 break;
506 }
507 }
508 spin_unlock(&kset->list_lock);
509 return ret;
510 }
513 void subsystem_init(struct subsystem * s)
514 {
515 init_rwsem(&s->rwsem);
516 kset_init(&s->kset);
517 }
519 /**
520 * subsystem_register - register a subsystem.
521 * @s: the subsystem we're registering.
522 *
523 * Once we register the subsystem, we want to make sure that
524 * the kset points back to this subsystem for correct usage of
525 * the rwsem.
526 */
528 int subsystem_register(struct subsystem * s)
529 {
530 int error;
532 subsystem_init(s);
533 pr_debug("subsystem %s: registering\n",s->kset.kobj.name);
535 if (!(error = kset_add(&s->kset))) {
536 if (!s->kset.subsys)
537 s->kset.subsys = s;
538 }
539 return error;
540 }
542 void subsystem_unregister(struct subsystem * s)
543 {
544 pr_debug("subsystem %s: unregistering\n",s->kset.kobj.name);
545 kset_unregister(&s->kset);
546 }
549 /**
550 * subsystem_create_file - export sysfs attribute file.
551 * @s: subsystem.
552 * @a: subsystem attribute descriptor.
553 */
555 int subsys_create_file(struct subsystem * s, struct subsys_attribute * a)
556 {
557 int error = 0;
558 if (subsys_get(s)) {
559 error = sysfs_create_file(&s->kset.kobj,&a->attr);
560 subsys_put(s);
561 }
562 return error;
563 }
566 /**
567 * subsystem_remove_file - remove sysfs attribute file.
568 * @s: subsystem.
569 * @a: attribute desciptor.
570 */
571 #if 0
572 void subsys_remove_file(struct subsystem * s, struct subsys_attribute * a)
573 {
574 if (subsys_get(s)) {
575 sysfs_remove_file(&s->kset.kobj,&a->attr);
576 subsys_put(s);
577 }
578 }
579 #endif /* 0 */
581 EXPORT_SYMBOL(kobject_init);
582 EXPORT_SYMBOL(kobject_register);
583 EXPORT_SYMBOL(kobject_unregister);
584 EXPORT_SYMBOL(kobject_get);
585 EXPORT_SYMBOL(kobject_put);
586 EXPORT_SYMBOL(kobject_add);
587 EXPORT_SYMBOL(kobject_del);
589 EXPORT_SYMBOL(kset_register);
590 EXPORT_SYMBOL(kset_unregister);
592 EXPORT_SYMBOL(subsystem_register);
593 EXPORT_SYMBOL(subsystem_unregister);
594 EXPORT_SYMBOL(subsys_create_file);