sys/dev/xen/balloon/balloon.c

   1 /******************************************************************************
   2  * balloon.c
   3  *
   4  * Xen balloon driver - enables returning/claiming memory to/from Xen.
   5  *
   6  * Copyright (c) 2003, B Dragovic
   7  * Copyright (c) 2003-2004, M Williamson, K Fraser
   8  * Copyright (c) 2005 Dan M. Smith, IBM Corporation
   9  *
  10  * This file may be distributed separately from the Linux kernel, or
  11  * incorporated into other software packages, subject to the following license:
  12  *
  13  * Permission is hereby granted, free of charge, to any person obtaining a copy
  14  * of this source file (the "Software"), to deal in the Software without
  15  * restriction, including without limitation the rights to use, copy, modify,
  16  * merge, publish, distribute, sublicense, and/or sell copies of the Software,
  17  * and to permit persons to whom the Software is furnished to do so, subject to
  18  * the following conditions:
  19  *
  20  * The above copyright notice and this permission notice shall be included in
  21  * all copies or substantial portions of the Software.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  24  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  25  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  26  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  27  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  28  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  29  * IN THE SOFTWARE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include <sys/param.h>
  36 #include <sys/lock.h>
  37 #include <sys/kernel.h>
  38 #include <sys/kthread.h>
  39 #include <sys/malloc.h>
  40 #include <sys/mutex.h>
  41 #include <sys/sysctl.h>
  42 #include <sys/module.h>
  43
  44 #include <vm/vm.h>
  45 #include <vm/vm_page.h>
  46
  47 #include <xen/xen-os.h>
  48 #include <xen/hypervisor.h>
  49 #include <xen/features.h>
  50 #include <xen/xenstore/xenstorevar.h>
  51
  52 static MALLOC_DEFINE(M_BALLOON, "Balloon", "Xen Balloon Driver");
  53
  54 /* Convert from KB (as fetched from xenstore) to number of PAGES */
  55 #define KB_TO_PAGE_SHIFT        (PAGE_SHIFT - 10)
  56
  57 struct mtx balloon_mutex;
  58
  59 /* We increase/decrease in batches which fit in a page */
  60 static unsigned long frame_list[PAGE_SIZE / sizeof(unsigned long)];
  61
  62 struct balloon_stats {
  63         /* We aim for 'current allocation' == 'target allocation'. */
  64         unsigned long current_pages;
  65         unsigned long target_pages;
  66         /* We may hit the hard limit in Xen. If we do then we remember it. */
  67         unsigned long hard_limit;
  68         /*
  69          * Drivers may alter the memory reservation independently, but they
  70          * must inform the balloon driver so we avoid hitting the hard limit.
  71          */
  72         unsigned long driver_pages;
  73         /* Number of pages in high- and low-memory balloons. */
  74         unsigned long balloon_low;
  75         unsigned long balloon_high;
  76 };
  77
  78 static struct balloon_stats balloon_stats;
  79 #define bs balloon_stats
  80
  81 SYSCTL_DECL(_dev_xen);
  82 static SYSCTL_NODE(_dev_xen, OID_AUTO, balloon, CTLFLAG_RD, NULL, "Balloon");
  83 SYSCTL_ULONG(_dev_xen_balloon, OID_AUTO, current, CTLFLAG_RD,
  84     &bs.current_pages, 0, "Current allocation");
  85 SYSCTL_ULONG(_dev_xen_balloon, OID_AUTO, target, CTLFLAG_RD,
  86     &bs.target_pages, 0, "Target allocation");
  87 SYSCTL_ULONG(_dev_xen_balloon, OID_AUTO, driver_pages, CTLFLAG_RD,
  88     &bs.driver_pages, 0, "Driver pages");
  89 SYSCTL_ULONG(_dev_xen_balloon, OID_AUTO, hard_limit, CTLFLAG_RD,
  90     &bs.hard_limit, 0, "Xen hard limit");
  91 SYSCTL_ULONG(_dev_xen_balloon, OID_AUTO, low_mem, CTLFLAG_RD,
  92     &bs.balloon_low, 0, "Low-mem balloon");
  93 SYSCTL_ULONG(_dev_xen_balloon, OID_AUTO, high_mem, CTLFLAG_RD,
  94     &bs.balloon_high, 0, "High-mem balloon");
  95
  96 /* List of ballooned pages, threaded through the mem_map array. */
  97 static TAILQ_HEAD(,vm_page) ballooned_pages;
  98
  99 /* Main work function, always executed in process context. */
 100 static void balloon_process(void *unused);
 101
 102 #define IPRINTK(fmt, args...) \
 103         printk(KERN_INFO "xen_mem: " fmt, ##args)
 104 #define WPRINTK(fmt, args...) \
 105         printk(KERN_WARNING "xen_mem: " fmt, ##args)
 106
 107 static unsigned long
 108 current_target(void)
 109 {
 110         unsigned long target = min(bs.target_pages, bs.hard_limit);
 111         if (target > (bs.current_pages + bs.balloon_low + bs.balloon_high))
 112                 target = bs.current_pages + bs.balloon_low + bs.balloon_high;
 113         return (target);
 114 }
 115
 116 static unsigned long
 117 minimum_target(void)
 118 {
 119         unsigned long min_pages, curr_pages = current_target();
 120
 121 #define MB2PAGES(mb) ((mb) << (20 - PAGE_SHIFT))
 122         /*
 123          * Simple continuous piecewiese linear function:
 124          *  max MiB -> min MiB  gradient
 125          *       0         0
 126          *      16        16
 127          *      32        24
 128          *     128        72    (1/2)
 129          *     512       168    (1/4)
 130          *    2048       360    (1/8)
 131          *    8192       552    (1/32)
 132          *   32768      1320
 133          *  131072      4392
 134          */
 135         if (realmem < MB2PAGES(128))
 136                 min_pages = MB2PAGES(8) + (realmem >> 1);
 137         else if (realmem < MB2PAGES(512))
 138                 min_pages = MB2PAGES(40) + (realmem >> 2);
 139         else if (realmem < MB2PAGES(2048))
 140                 min_pages = MB2PAGES(104) + (realmem >> 3);
 141         else
 142                 min_pages = MB2PAGES(296) + (realmem >> 5);
 143 #undef MB2PAGES
 144
 145         /* Don't enforce growth */
 146         return (min(min_pages, curr_pages));
 147 }
 148
 149 static int
 150 increase_reservation(unsigned long nr_pages)
 151 {
 152         unsigned long  pfn, i;
 153         vm_page_t      page;
 154         long           rc;
 155         struct xen_memory_reservation reservation = {
 156                 .address_bits = 0,
 157                 .extent_order = 0,
 158                 .domid        = DOMID_SELF
 159         };
 160
 161         mtx_assert(&balloon_mutex, MA_OWNED);
 162
 163         if (nr_pages > nitems(frame_list))
 164                 nr_pages = nitems(frame_list);
 165
 166         for (page = TAILQ_FIRST(&ballooned_pages), i = 0;
 167             i < nr_pages; i++, page = TAILQ_NEXT(page, plinks.q)) {
 168                 KASSERT(page != NULL, ("ballooned_pages list corrupt"));
 169                 frame_list[i] = (VM_PAGE_TO_PHYS(page) >> PAGE_SHIFT);
 170         }
 171
 172         set_xen_guest_handle(reservation.extent_start, frame_list);
 173         reservation.nr_extents   = nr_pages;
 174         rc = HYPERVISOR_memory_op(
 175                 XENMEM_populate_physmap, &reservation);
 176         if (rc < nr_pages) {
 177                 if (rc > 0) {
 178                         int ret;
 179
 180                         /* We hit the Xen hard limit: reprobe. */
 181                         reservation.nr_extents = rc;
 182                         ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation,
 183                                         &reservation);
 184                         KASSERT(ret == rc, ("HYPERVISOR_memory_op failed"));
 185                 }
 186                 if (rc >= 0)
 187                         bs.hard_limit = (bs.current_pages + rc -
 188                                          bs.driver_pages);
 189                 goto out;
 190         }
 191
 192         for (i = 0; i < nr_pages; i++) {
 193                 page = TAILQ_FIRST(&ballooned_pages);
 194                 KASSERT(page != NULL, ("Unable to get ballooned page"));
 195                 TAILQ_REMOVE(&ballooned_pages, page, plinks.q);
 196                 bs.balloon_low--;
 197
 198                 pfn = (VM_PAGE_TO_PHYS(page) >> PAGE_SHIFT);
 199                 KASSERT(xen_feature(XENFEAT_auto_translated_physmap),
 200                     ("auto translated physmap but mapping is valid"));
 201
 202                 vm_page_free(page);
 203         }
 204
 205         bs.current_pages += nr_pages;
 206
 207  out:
 208         return (0);
 209 }
 210
 211 static int
 212 decrease_reservation(unsigned long nr_pages)
 213 {
 214         unsigned long  pfn, i;
 215         vm_page_t      page;
 216         int            need_sleep = 0;
 217         int ret;
 218         struct xen_memory_reservation reservation = {
 219                 .address_bits = 0,
 220                 .extent_order = 0,
 221                 .domid        = DOMID_SELF
 222         };
 223
 224         mtx_assert(&balloon_mutex, MA_OWNED);
 225
 226         if (nr_pages > nitems(frame_list))
 227                 nr_pages = nitems(frame_list);
 228
 229         for (i = 0; i < nr_pages; i++) {
 230                 if ((page = vm_page_alloc(NULL, 0,
 231                             VM_ALLOC_NORMAL | VM_ALLOC_NOOBJ |
 232                             VM_ALLOC_ZERO)) == NULL) {
 233                         nr_pages = i;
 234                         need_sleep = 1;
 235                         break;
 236                 }
 237
 238                 if ((page->flags & PG_ZERO) == 0) {
 239                         /*
 240                          * Zero the page, or else we might be leaking
 241                          * important data to other domains on the same
 242                          * host. Xen doesn't scrub ballooned out memory
 243                          * pages, the guest is in charge of making
 244                          * sure that no information is leaked.
 245                          */
 246                         pmap_zero_page(page);
 247                 }
 248
 249                 pfn = (VM_PAGE_TO_PHYS(page) >> PAGE_SHIFT);
 250                 frame_list[i] = pfn;
 251
 252                 TAILQ_INSERT_HEAD(&ballooned_pages, page, plinks.q);
 253                 bs.balloon_low++;
 254         }
 255
 256         set_xen_guest_handle(reservation.extent_start, frame_list);
 257         reservation.nr_extents   = nr_pages;
 258         ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation, &reservation);
 259         KASSERT(ret == nr_pages, ("HYPERVISOR_memory_op failed"));
 260
 261         bs.current_pages -= nr_pages;
 262
 263         return (need_sleep);
 264 }
 265
 266 /*
 267  * We avoid multiple worker processes conflicting via the balloon mutex.
 268  * We may of course race updates of the target counts (which are protected
 269  * by the balloon lock), or with changes to the Xen hard limit, but we will
 270  * recover from these in time.
 271  */
 272 static void
 273 balloon_process(void *unused)
 274 {
 275         int need_sleep = 0;
 276         long credit;
 277
 278         mtx_lock(&balloon_mutex);
 279         for (;;) {
 280                 int sleep_time;
 281
 282                 do {
 283                         credit = current_target() - bs.current_pages;
 284                         if (credit > 0)
 285                                 need_sleep = (increase_reservation(credit) != 0);
 286                         if (credit < 0)
 287                                 need_sleep = (decrease_reservation(-credit) != 0);
 288
 289                 } while ((credit != 0) && !need_sleep);
 290
 291                 /* Schedule more work if there is some still to be done. */
 292                 if (current_target() != bs.current_pages)
 293                         sleep_time = hz;
 294                 else
 295                         sleep_time = 0;
 296
 297                 msleep(balloon_process, &balloon_mutex, 0, "balloon",
 298                        sleep_time);
 299         }
 300         mtx_unlock(&balloon_mutex);
 301 }
 302
 303 /* Resets the Xen limit, sets new target, and kicks off processing. */
 304 static void
 305 set_new_target(unsigned long target)
 306 {
 307         /* No need for lock. Not read-modify-write updates. */
 308         bs.hard_limit   = ~0UL;
 309         bs.target_pages = max(target, minimum_target());
 310         wakeup(balloon_process);
 311 }
 312
 313 static struct xs_watch target_watch =
 314 {
 315         .node = "memory/target"
 316 };
 317
 318 /* React to a change in the target key */
 319 static void
 320 watch_target(struct xs_watch *watch,
 321              const char **vec, unsigned int len)
 322 {
 323         unsigned long long new_target;
 324         int err;
 325
 326         err = xs_scanf(XST_NIL, "memory", "target", NULL,
 327             "%llu", &new_target);
 328         if (err) {
 329                 /* This is ok (for domain0 at least) - so just return */
 330                 return;
 331         }
 332
 333         /*
 334          * The given memory/target value is in KiB, so it needs converting to
 335          * pages.  PAGE_SHIFT converts bytes to pages, hence PAGE_SHIFT - 10.
 336          */
 337         set_new_target(new_target >> KB_TO_PAGE_SHIFT);
 338 }
 339
 340 /*------------------ Private Device Attachment Functions  --------------------*/
 341 /**
 342  * \brief Identify instances of this device type in the system.
 343  *
 344  * \param driver  The driver performing this identify action.
 345  * \param parent  The NewBus parent device for any devices this method adds.
 346  */
 347 static void
 348 xenballoon_identify(driver_t *driver __unused, device_t parent)
 349 {
 350         /*
 351          * A single device instance for our driver is always present
 352          * in a system operating under Xen.
 353          */
 354         BUS_ADD_CHILD(parent, 0, driver->name, 0);
 355 }
 356
 357 /**
 358  * \brief Probe for the existance of the Xen Balloon device
 359  *
 360  * \param dev  NewBus device_t for this Xen control instance.
 361  *
 362  * \return  Always returns 0 indicating success.
 363  */
 364 static int
 365 xenballoon_probe(device_t dev)
 366 {
 367
 368         device_set_desc(dev, "Xen Balloon Device");
 369         return (0);
 370 }
 371
 372 /**
 373  * \brief Attach the Xen Balloon device.
 374  *
 375  * \param dev  NewBus device_t for this Xen control instance.
 376  *
 377  * \return  On success, 0. Otherwise an errno value indicating the
 378  *          type of failure.
 379  */
 380 static int
 381 xenballoon_attach(device_t dev)
 382 {
 383         int err;
 384
 385         mtx_init(&balloon_mutex, "balloon_mutex", NULL, MTX_DEF);
 386
 387         bs.current_pages = xen_pv_domain() ?
 388             HYPERVISOR_start_info->nr_pages : realmem;
 389         bs.target_pages  = bs.current_pages;
 390         bs.balloon_low   = 0;
 391         bs.balloon_high  = 0;
 392         bs.driver_pages  = 0UL;
 393         bs.hard_limit    = ~0UL;
 394
 395         kproc_create(balloon_process, NULL, NULL, 0, 0, "balloon");
 396
 397         target_watch.callback = watch_target;
 398
 399         err = xs_register_watch(&target_watch);
 400         if (err)
 401                 device_printf(dev,
 402                     "xenballon: failed to set balloon watcher\n");
 403
 404         return (err);
 405 }
 406
 407 /*-------------------- Private Device Attachment Data  -----------------------*/
 408 static device_method_t xenballoon_methods[] = {
 409         /* Device interface */
 410         DEVMETHOD(device_identify,      xenballoon_identify),
 411         DEVMETHOD(device_probe,         xenballoon_probe),
 412         DEVMETHOD(device_attach,        xenballoon_attach),
 413
 414         DEVMETHOD_END
 415 };
 416
 417 DEFINE_CLASS_0(xenballoon, xenballoon_driver, xenballoon_methods, 0);
 418 devclass_t xenballoon_devclass;
 419
 420 DRIVER_MODULE(xenballoon, xenstore, xenballoon_driver, xenballoon_devclass,
 421     NULL, NULL);