LXR qemu/include/hw/mem/memory-device.h

   1/*
   2 * Memory Device Interface
   3 *
   4 * Copyright (c) 2018 Red Hat, Inc.
   5 *
   6 * Authors:
   7 *  David Hildenbrand <david@redhat.com>
   8 *
   9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
  10 * See the COPYING file in the top-level directory.
  11 */
  12
  13#ifndef MEMORY_DEVICE_H
  14#define MEMORY_DEVICE_H
  15
  16#include "hw/qdev-core.h"
  17#include "qapi/qapi-types-misc.h"
  18#include "qom/object.h"
  19
  20#define TYPE_MEMORY_DEVICE "memory-device"
  21
  22#define MEMORY_DEVICE_CLASS(klass) \
  23     OBJECT_CLASS_CHECK(MemoryDeviceClass, (klass), TYPE_MEMORY_DEVICE)
  24#define MEMORY_DEVICE_GET_CLASS(obj) \
  25    OBJECT_GET_CLASS(MemoryDeviceClass, (obj), TYPE_MEMORY_DEVICE)
  26#define MEMORY_DEVICE(obj) \
  27     INTERFACE_CHECK(MemoryDeviceState, (obj), TYPE_MEMORY_DEVICE)
  28
  29typedef struct MemoryDeviceState MemoryDeviceState;
  30
  31/**
  32 * MemoryDeviceClass:
  33 *
  34 * All memory devices need to implement TYPE_MEMORY_DEVICE as an interface.
  35 *
  36 * A memory device is a device that owns a memory region which is
  37 * mapped into guest physical address space at a certain address. The
  38 * address in guest physical memory can either be specified explicitly
  39 * or get assigned automatically.
  40 *
  41 * Conceptually, memory devices only span one memory region. If multiple
  42 * successive memory regions are used, a covering memory region has to
  43 * be provided. Scattered memory regions are not supported for single
  44 * devices.
  45 */
  46typedef struct MemoryDeviceClass {
  47    /* private */
  48    InterfaceClass parent_class;
  49
  50    /*
  51     * Return the address of the memory device in guest physical memory.
  52     *
  53     * Called when (un)plugging a memory device or when iterating over
  54     * all memory devices mapped into guest physical address space.
  55     *
  56     * If "0" is returned, no address has been specified by the user and
  57     * no address has been assigned to this memory device yet.
  58     */
  59    uint64_t (*get_addr)(const MemoryDeviceState *md);
  60
  61    /*
  62     * Set the address of the memory device in guest physical memory.
  63     *
  64     * Called when plugging the memory device to configure the determined
  65     * address in guest physical memory.
  66     */
  67    void (*set_addr)(MemoryDeviceState *md, uint64_t addr, Error **errp);
  68
  69    /*
  70     * Return the amount of memory provided by the memory device currently
  71     * usable ("plugged") by the VM.
  72     *
  73     * Called when calculating the total amount of ram available to the
  74     * VM (e.g. to report memory stats to the user).
  75     *
  76     * This is helpful for devices that dynamically manage the amount of
  77     * memory accessible by the guest via the reserved memory region. For
  78     * most devices, this corresponds to the size of the memory region.
  79     */
  80    uint64_t (*get_plugged_size)(const MemoryDeviceState *md, Error **errp);
  81
  82    /*
  83     * Return the memory region of the memory device.
  84     *
  85     * Called when (un)plugging the memory device, to (un)map the
  86     * memory region in guest physical memory, but also to detect the
  87     * required alignment during address assignment or when the size of the
  88     * memory region is required.
  89     */
  90    MemoryRegion *(*get_memory_region)(MemoryDeviceState *md, Error **errp);
  91
  92    /*
  93     * Translate the memory device into #MemoryDeviceInfo.
  94     */
  95    void (*fill_device_info)(const MemoryDeviceState *md,
  96                             MemoryDeviceInfo *info);
  97} MemoryDeviceClass;
  98
  99MemoryDeviceInfoList *qmp_memory_device_list(void);
 100uint64_t get_plugged_memory_size(void);
 101void memory_device_pre_plug(MemoryDeviceState *md, MachineState *ms,
 102                            const uint64_t *legacy_align, Error **errp);
 103void memory_device_plug(MemoryDeviceState *md, MachineState *ms);
 104void memory_device_unplug(MemoryDeviceState *md, MachineState *ms);
 105uint64_t memory_device_get_region_size(const MemoryDeviceState *md,
 106                                       Error **errp);
 107
 108#endif
 109