Annotation of qemu/balloon.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * QEMU System Emulator
        !             3:  *
        !             4:  * Copyright (c) 2003-2008 Fabrice Bellard
        !             5:  *
        !             6:  * Permission is hereby granted, free of charge, to any person obtaining a copy
        !             7:  * of this software and associated documentation files (the "Software"), to deal
        !             8:  * in the Software without restriction, including without limitation the rights
        !             9:  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
        !            10:  * copies of the Software, and to permit persons to whom the Software is
        !            11:  * furnished to do so, subject to the following conditions:
        !            12:  *
        !            13:  * The above copyright notice and this permission notice shall be included in
        !            14:  * all copies or substantial portions of the Software.
        !            15:  *
        !            16:  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
        !            17:  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
        !            18:  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
        !            19:  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
        !            20:  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
        !            21:  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
        !            22:  * THE SOFTWARE.
        !            23:  */
        !            24: 
        !            25: #include "sysemu.h"
        !            26: #include "monitor.h"
        !            27: #include "qjson.h"
        !            28: #include "qint.h"
        !            29: #include "cpu-common.h"
        !            30: #include "kvm.h"
        !            31: #include "balloon.h"
        !            32: 
        !            33: 
        !            34: static QEMUBalloonEvent *qemu_balloon_event;
        !            35: void *qemu_balloon_event_opaque;
        !            36: 
        !            37: void qemu_add_balloon_handler(QEMUBalloonEvent *func, void *opaque)
        !            38: {
        !            39:     qemu_balloon_event = func;
        !            40:     qemu_balloon_event_opaque = opaque;
        !            41: }
        !            42: 
        !            43: int qemu_balloon(ram_addr_t target, MonitorCompletion cb, void *opaque)
        !            44: {
        !            45:     if (qemu_balloon_event) {
        !            46:         qemu_balloon_event(qemu_balloon_event_opaque, target, cb, opaque);
        !            47:         return 1;
        !            48:     } else {
        !            49:         return 0;
        !            50:     }
        !            51: }
        !            52: 
        !            53: int qemu_balloon_status(MonitorCompletion cb, void *opaque)
        !            54: {
        !            55:     if (qemu_balloon_event) {
        !            56:         qemu_balloon_event(qemu_balloon_event_opaque, 0, cb, opaque);
        !            57:         return 1;
        !            58:     } else {
        !            59:         return 0;
        !            60:     }
        !            61: }
        !            62: 
        !            63: static void print_balloon_stat(const char *key, QObject *obj, void *opaque)
        !            64: {
        !            65:     Monitor *mon = opaque;
        !            66: 
        !            67:     if (strcmp(key, "actual"))
        !            68:         monitor_printf(mon, ",%s=%" PRId64, key,
        !            69:                        qint_get_int(qobject_to_qint(obj)));
        !            70: }
        !            71: 
        !            72: void monitor_print_balloon(Monitor *mon, const QObject *data)
        !            73: {
        !            74:     QDict *qdict;
        !            75: 
        !            76:     qdict = qobject_to_qdict(data);
        !            77:     if (!qdict_haskey(qdict, "actual"))
        !            78:         return;
        !            79: 
        !            80:     monitor_printf(mon, "balloon: actual=%" PRId64,
        !            81:                    qdict_get_int(qdict, "actual") >> 20);
        !            82:     qdict_iter(qdict, print_balloon_stat, mon);
        !            83:     monitor_printf(mon, "\n");
        !            84: }
        !            85: 
        !            86: /**
        !            87:  * do_info_balloon(): Balloon information
        !            88:  *
        !            89:  * Make an asynchronous request for balloon info.  When the request completes
        !            90:  * a QDict will be returned according to the following specification:
        !            91:  *
        !            92:  * - "actual": current balloon value in bytes
        !            93:  * The following fields may or may not be present:
        !            94:  * - "mem_swapped_in": Amount of memory swapped in (bytes)
        !            95:  * - "mem_swapped_out": Amount of memory swapped out (bytes)
        !            96:  * - "major_page_faults": Number of major faults
        !            97:  * - "minor_page_faults": Number of minor faults
        !            98:  * - "free_mem": Total amount of free and unused memory (bytes)
        !            99:  * - "total_mem": Total amount of available memory (bytes)
        !           100:  *
        !           101:  * Example:
        !           102:  *
        !           103:  * { "actual": 1073741824, "mem_swapped_in": 0, "mem_swapped_out": 0,
        !           104:  *   "major_page_faults": 142, "minor_page_faults": 239245,
        !           105:  *   "free_mem": 1014185984, "total_mem": 1044668416 }
        !           106:  */
        !           107: int do_info_balloon(Monitor *mon, MonitorCompletion cb, void *opaque)
        !           108: {
        !           109:     int ret;
        !           110: 
        !           111:     if (kvm_enabled() && !kvm_has_sync_mmu()) {
        !           112:         qerror_report(QERR_KVM_MISSING_CAP, "synchronous MMU", "balloon");
        !           113:         return -1;
        !           114:     }
        !           115: 
        !           116:     ret = qemu_balloon_status(cb, opaque);
        !           117:     if (!ret) {
        !           118:         qerror_report(QERR_DEVICE_NOT_ACTIVE, "balloon");
        !           119:         return -1;
        !           120:     }
        !           121: 
        !           122:     return 0;
        !           123: }
        !           124: 
        !           125: /**
        !           126:  * do_balloon(): Request VM to change its memory allocation
        !           127:  */
        !           128: int do_balloon(Monitor *mon, const QDict *params,
        !           129:               MonitorCompletion cb, void *opaque)
        !           130: {
        !           131:     int ret;
        !           132: 
        !           133:     if (kvm_enabled() && !kvm_has_sync_mmu()) {
        !           134:         qerror_report(QERR_KVM_MISSING_CAP, "synchronous MMU", "balloon");
        !           135:         return -1;
        !           136:     }
        !           137: 
        !           138:     ret = qemu_balloon(qdict_get_int(params, "value"), cb, opaque);
        !           139:     if (ret == 0) {
        !           140:         qerror_report(QERR_DEVICE_NOT_ACTIVE, "balloon");
        !           141:         return -1;
        !           142:     }
        !           143: 
        !           144:     cb(opaque, NULL);
        !           145:     return 0;
        !           146: }

unix.superglobalmegacorp.com