1 /*
2 * Physical memory management API
3 *
4 * Copyright 2011 Red Hat, Inc. and/or its affiliates
5 *
6 * Authors:
7 * Avi Kivity <avi@redhat.com>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
11 *
12 */
13
14 #ifndef MEMORY_H
15 #define MEMORY_H
16
17 #ifndef CONFIG_USER_ONLY
18
19 #include "exec/cpu-common.h"
20 #include "exec/hwaddr.h"
21 #include "exec/memattrs.h"
22 #include "exec/memop.h"
23 #include "exec/ramlist.h"
24 #include "qemu/bswap.h"
25 #include "qemu/queue.h"
26 #include "qemu/int128.h"
27 #include "qemu/notify.h"
28 #include "qom/object.h"
29 #include "qemu/rcu.h"
30
31 #define RAM_ADDR_INVALID (~(ram_addr_t)0)
32
33 #define MAX_PHYS_ADDR_SPACE_BITS 62
34 #define MAX_PHYS_ADDR (((hwaddr)1 << MAX_PHYS_ADDR_SPACE_BITS) - 1)
35
36 #define TYPE_MEMORY_REGION "memory-region"
37 DECLARE_INSTANCE_CHECKER(MemoryRegion, MEMORY_REGION,
38 TYPE_MEMORY_REGION)
39
40 #define TYPE_IOMMU_MEMORY_REGION "iommu-memory-region"
41 typedef struct IOMMUMemoryRegionClass IOMMUMemoryRegionClass;
42 DECLARE_OBJ_CHECKERS(IOMMUMemoryRegion, IOMMUMemoryRegionClass,
43 IOMMU_MEMORY_REGION, TYPE_IOMMU_MEMORY_REGION)
44
45 #ifdef CONFIG_FUZZ
46 void fuzz_dma_read_cb(size_t addr,
47 size_t len,
48 MemoryRegion *mr);
49 #else
50 static inline void fuzz_dma_read_cb(size_t addr,
51 size_t len,
52 MemoryRegion *mr)
53 {
54 /* Do Nothing */
55 }
56 #endif
57
58 extern bool global_dirty_log;
59
60 typedef struct MemoryRegionOps MemoryRegionOps;
61
62 struct ReservedRegion {
63 hwaddr low;
64 hwaddr high;
65 unsigned type;
66 };
67
68 typedef struct IOMMUTLBEntry IOMMUTLBEntry;
69
70 /* See address_space_translate: bit 0 is read, bit 1 is write. */
71 typedef enum {
72 IOMMU_NONE = 0,
73 IOMMU_RO = 1,
74 IOMMU_WO = 2,
75 IOMMU_RW = 3,
76 } IOMMUAccessFlags;
77
78 #define IOMMU_ACCESS_FLAG(r, w) (((r) ? IOMMU_RO : 0) | ((w) ? IOMMU_WO : 0))
79
80 struct IOMMUTLBEntry {
81 AddressSpace *target_as;
82 hwaddr iova;
83 hwaddr translated_addr;
84 hwaddr addr_mask; /* 0xfff = 4k translation */
85 IOMMUAccessFlags perm;
86 };
87
88 /*
89 * Bitmap for different IOMMUNotifier capabilities. Each notifier can
90 * register with one or multiple IOMMU Notifier capability bit(s).
91 */
92 typedef enum {
93 IOMMU_NOTIFIER_NONE = 0,
94 /* Notify cache invalidations */
95 IOMMU_NOTIFIER_UNMAP = 0x1,
96 /* Notify entry changes (newly created entries) */
97 IOMMU_NOTIFIER_MAP = 0x2,
98 /* Notify changes on device IOTLB entries */
99 IOMMU_NOTIFIER_DEVIOTLB_UNMAP = 0x04,
100 } IOMMUNotifierFlag;
101
102 #define IOMMU_NOTIFIER_IOTLB_EVENTS (IOMMU_NOTIFIER_MAP | IOMMU_NOTIFIER_UNMAP)
103 #define IOMMU_NOTIFIER_DEVIOTLB_EVENTS IOMMU_NOTIFIER_DEVIOTLB_UNMAP
104 #define IOMMU_NOTIFIER_ALL (IOMMU_NOTIFIER_IOTLB_EVENTS | \
105 IOMMU_NOTIFIER_DEVIOTLB_EVENTS)
106
107 struct IOMMUNotifier;
108 typedef void (*IOMMUNotify)(struct IOMMUNotifier *notifier,
109 IOMMUTLBEntry *data);
110
111 struct IOMMUNotifier {
112 IOMMUNotify notify;
113 IOMMUNotifierFlag notifier_flags;
114 /* Notify for address space range start <= addr <= end */
115 hwaddr start;
116 hwaddr end;
117 int iommu_idx;
118 QLIST_ENTRY(IOMMUNotifier) node;
119 };
120 typedef struct IOMMUNotifier IOMMUNotifier;
121
122 typedef struct IOMMUTLBEvent {
123 IOMMUNotifierFlag type;
124 IOMMUTLBEntry entry;
125 } IOMMUTLBEvent;
126
127 /* RAM is pre-allocated and passed into qemu_ram_alloc_from_ptr */
128 #define RAM_PREALLOC (1 << 0)
129
130 /* RAM is mmap-ed with MAP_SHARED */
131 #define RAM_SHARED (1 << 1)
132
133 /* Only a portion of RAM (used_length) is actually used, and migrated.
134 * This used_length size can change across reboots.
135 */
136 #define RAM_RESIZEABLE (1 << 2)
137
138 /* UFFDIO_ZEROPAGE is available on this RAMBlock to atomically
139 * zero the page and wake waiting processes.
140 * (Set during postcopy)
141 */
142 #define RAM_UF_ZEROPAGE (1 << 3)
143
144 /* RAM can be migrated */
145 #define RAM_MIGRATABLE (1 << 4)
146
147 /* RAM is a persistent kind memory */
148 #define RAM_PMEM (1 << 5)
149
150
151 /*
152 * UFFDIO_WRITEPROTECT is used on this RAMBlock to
153 * support 'write-tracking' migration type.
154 * Implies ram_state->ram_wt_enabled.
155 */
156 #define RAM_UF_WRITEPROTECT (1 << 6)
157
iommu_notifier_init(IOMMUNotifier * n,IOMMUNotify fn,IOMMUNotifierFlag flags,hwaddr start,hwaddr end,int iommu_idx)158 static inline void iommu_notifier_init(IOMMUNotifier *n, IOMMUNotify fn,
159 IOMMUNotifierFlag flags,
160 hwaddr start, hwaddr end,
161 int iommu_idx)
162 {
163 n->notify = fn;
164 n->notifier_flags = flags;
165 n->start = start;
166 n->end = end;
167 n->iommu_idx = iommu_idx;
168 }
169
170 /*
171 * Memory region callbacks
172 */
173 struct MemoryRegionOps {
174 /* Read from the memory region. @addr is relative to @mr; @size is
175 * in bytes. */
176 uint64_t (*read)(void *opaque,
177 hwaddr addr,
178 unsigned size);
179 /* Write to the memory region. @addr is relative to @mr; @size is
180 * in bytes. */
181 void (*write)(void *opaque,
182 hwaddr addr,
183 uint64_t data,
184 unsigned size);
185
186 MemTxResult (*read_with_attrs)(void *opaque,
187 hwaddr addr,
188 uint64_t *data,
189 unsigned size,
190 MemTxAttrs attrs);
191 MemTxResult (*write_with_attrs)(void *opaque,
192 hwaddr addr,
193 uint64_t data,
194 unsigned size,
195 MemTxAttrs attrs);
196
197 enum device_endian endianness;
198 /* Guest-visible constraints: */
199 struct {
200 /* If nonzero, specify bounds on access sizes beyond which a machine
201 * check is thrown.
202 */
203 unsigned min_access_size;
204 unsigned max_access_size;
205 /* If true, unaligned accesses are supported. Otherwise unaligned
206 * accesses throw machine checks.
207 */
208 bool unaligned;
209 /*
210 * If present, and returns #false, the transaction is not accepted
211 * by the device (and results in machine dependent behaviour such
212 * as a machine check exception).
213 */
214 bool (*accepts)(void *opaque, hwaddr addr,
215 unsigned size, bool is_write,
216 MemTxAttrs attrs);
217 } valid;
218 /* Internal implementation constraints: */
219 struct {
220 /* If nonzero, specifies the minimum size implemented. Smaller sizes
221 * will be rounded upwards and a partial result will be returned.
222 */
223 unsigned min_access_size;
224 /* If nonzero, specifies the maximum size implemented. Larger sizes
225 * will be done as a series of accesses with smaller sizes.
226 */
227 unsigned max_access_size;
228 /* If true, unaligned accesses are supported. Otherwise all accesses
229 * are converted to (possibly multiple) naturally aligned accesses.
230 */
231 bool unaligned;
232 } impl;
233 };
234
235 typedef struct MemoryRegionClass {
236 /* private */
237 ObjectClass parent_class;
238 } MemoryRegionClass;
239
240
241 enum IOMMUMemoryRegionAttr {
242 IOMMU_ATTR_SPAPR_TCE_FD
243 };
244
245 /*
246 * IOMMUMemoryRegionClass:
247 *
248 * All IOMMU implementations need to subclass TYPE_IOMMU_MEMORY_REGION
249 * and provide an implementation of at least the @translate method here
250 * to handle requests to the memory region. Other methods are optional.
251 *
252 * The IOMMU implementation must use the IOMMU notifier infrastructure
253 * to report whenever mappings are changed, by calling
254 * memory_region_notify_iommu() (or, if necessary, by calling
255 * memory_region_notify_iommu_one() for each registered notifier).
256 *
257 * Conceptually an IOMMU provides a mapping from input address
258 * to an output TLB entry. If the IOMMU is aware of memory transaction
259 * attributes and the output TLB entry depends on the transaction
260 * attributes, we represent this using IOMMU indexes. Each index
261 * selects a particular translation table that the IOMMU has:
262 *
263 * @attrs_to_index returns the IOMMU index for a set of transaction attributes
264 *
265 * @translate takes an input address and an IOMMU index
266 *
267 * and the mapping returned can only depend on the input address and the
268 * IOMMU index.
269 *
270 * Most IOMMUs don't care about the transaction attributes and support
271 * only a single IOMMU index. A more complex IOMMU might have one index
272 * for secure transactions and one for non-secure transactions.
273 */
274 struct IOMMUMemoryRegionClass {
275 /* private: */
276 MemoryRegionClass parent_class;
277
278 /* public: */
279 /**
280 * @translate:
281 *
282 * Return a TLB entry that contains a given address.
283 *
284 * The IOMMUAccessFlags indicated via @flag are optional and may
285 * be specified as IOMMU_NONE to indicate that the caller needs
286 * the full translation information for both reads and writes. If
287 * the access flags are specified then the IOMMU implementation
288 * may use this as an optimization, to stop doing a page table
289 * walk as soon as it knows that the requested permissions are not
290 * allowed. If IOMMU_NONE is passed then the IOMMU must do the
291 * full page table walk and report the permissions in the returned
292 * IOMMUTLBEntry. (Note that this implies that an IOMMU may not
293 * return different mappings for reads and writes.)
294 *
295 * The returned information remains valid while the caller is
296 * holding the big QEMU lock or is inside an RCU critical section;
297 * if the caller wishes to cache the mapping beyond that it must
298 * register an IOMMU notifier so it can invalidate its cached
299 * information when the IOMMU mapping changes.
300 *
301 * @iommu: the IOMMUMemoryRegion
302 *
303 * @hwaddr: address to be translated within the memory region
304 *
305 * @flag: requested access permission
306 *
307 * @iommu_idx: IOMMU index for the translation
308 */
309 IOMMUTLBEntry (*translate)(IOMMUMemoryRegion *iommu, hwaddr addr,
310 IOMMUAccessFlags flag, int iommu_idx);
311 /**
312 * @get_min_page_size:
313 *
314 * Returns minimum supported page size in bytes.
315 *
316 * If this method is not provided then the minimum is assumed to
317 * be TARGET_PAGE_SIZE.
318 *
319 * @iommu: the IOMMUMemoryRegion
320 */
321 uint64_t (*get_min_page_size)(IOMMUMemoryRegion *iommu);
322 /**
323 * @notify_flag_changed:
324 *
325 * Called when IOMMU Notifier flag changes (ie when the set of
326 * events which IOMMU users are requesting notification for changes).
327 * Optional method -- need not be provided if the IOMMU does not
328 * need to know exactly which events must be notified.
329 *
330 * @iommu: the IOMMUMemoryRegion
331 *
332 * @old_flags: events which previously needed to be notified
333 *
334 * @new_flags: events which now need to be notified
335 *
336 * Returns 0 on success, or a negative errno; in particular
337 * returns -EINVAL if the new flag bitmap is not supported by the
338 * IOMMU memory region. In case of failure, the error object
339 * must be created
340 */
341 int (*notify_flag_changed)(IOMMUMemoryRegion *iommu,
342 IOMMUNotifierFlag old_flags,
343 IOMMUNotifierFlag new_flags,
344 Error **errp);
345 /**
346 * @replay:
347 *
348 * Called to handle memory_region_iommu_replay().
349 *
350 * The default implementation of memory_region_iommu_replay() is to
351 * call the IOMMU translate method for every page in the address space
352 * with flag == IOMMU_NONE and then call the notifier if translate
353 * returns a valid mapping. If this method is implemented then it
354 * overrides the default behaviour, and must provide the full semantics
355 * of memory_region_iommu_replay(), by calling @notifier for every
356 * translation present in the IOMMU.
357 *
358 * Optional method -- an IOMMU only needs to provide this method
359 * if the default is inefficient or produces undesirable side effects.
360 *
361 * Note: this is not related to record-and-replay functionality.
362 */
363 void (*replay)(IOMMUMemoryRegion *iommu, IOMMUNotifier *notifier);
364
365 /**
366 * @get_attr:
367 *
368 * Get IOMMU misc attributes. This is an optional method that
369 * can be used to allow users of the IOMMU to get implementation-specific
370 * information. The IOMMU implements this method to handle calls
371 * by IOMMU users to memory_region_iommu_get_attr() by filling in
372 * the arbitrary data pointer for any IOMMUMemoryRegionAttr values that
373 * the IOMMU supports. If the method is unimplemented then
374 * memory_region_iommu_get_attr() will always return -EINVAL.
375 *
376 * @iommu: the IOMMUMemoryRegion
377 *
378 * @attr: attribute being queried
379 *
380 * @data: memory to fill in with the attribute data
381 *
382 * Returns 0 on success, or a negative errno; in particular
383 * returns -EINVAL for unrecognized or unimplemented attribute types.
384 */
385 int (*get_attr)(IOMMUMemoryRegion *iommu, enum IOMMUMemoryRegionAttr attr,
386 void *data);
387
388 /**
389 * @attrs_to_index:
390 *
391 * Return the IOMMU index to use for a given set of transaction attributes.
392 *
393 * Optional method: if an IOMMU only supports a single IOMMU index then
394 * the default implementation of memory_region_iommu_attrs_to_index()
395 * will return 0.
396 *
397 * The indexes supported by an IOMMU must be contiguous, starting at 0.
398 *
399 * @iommu: the IOMMUMemoryRegion
400 * @attrs: memory transaction attributes
401 */
402 int (*attrs_to_index)(IOMMUMemoryRegion *iommu, MemTxAttrs attrs);
403
404 /**
405 * @num_indexes:
406 *
407 * Return the number of IOMMU indexes this IOMMU supports.
408 *
409 * Optional method: if this method is not provided, then
410 * memory_region_iommu_num_indexes() will return 1, indicating that
411 * only a single IOMMU index is supported.
412 *
413 * @iommu: the IOMMUMemoryRegion
414 */
415 int (*num_indexes)(IOMMUMemoryRegion *iommu);
416
417 /**
418 * @iommu_set_page_size_mask:
419 *
420 * Restrict the page size mask that can be supported with a given IOMMU
421 * memory region. Used for example to propagate host physical IOMMU page
422 * size mask limitations to the virtual IOMMU.
423 *
424 * Optional method: if this method is not provided, then the default global
425 * page mask is used.
426 *
427 * @iommu: the IOMMUMemoryRegion
428 *
429 * @page_size_mask: a bitmask of supported page sizes. At least one bit,
430 * representing the smallest page size, must be set. Additional set bits
431 * represent supported block sizes. For example a host physical IOMMU that
432 * uses page tables with a page size of 4kB, and supports 2MB and 4GB
433 * blocks, will set mask 0x40201000. A granule of 4kB with indiscriminate
434 * block sizes is specified with mask 0xfffffffffffff000.
435 *
436 * Returns 0 on success, or a negative error. In case of failure, the error
437 * object must be created.
438 */
439 int (*iommu_set_page_size_mask)(IOMMUMemoryRegion *iommu,
440 uint64_t page_size_mask,
441 Error **errp);
442 };
443
444 typedef struct CoalescedMemoryRange CoalescedMemoryRange;
445 typedef struct MemoryRegionIoeventfd MemoryRegionIoeventfd;
446
447 /** MemoryRegion:
448 *
449 * A struct representing a memory region.
450 */
451 struct MemoryRegion {
452 Object parent_obj;
453
454 /* private: */
455
456 /* The following fields should fit in a cache line */
457 bool romd_mode;
458 bool ram;
459 bool subpage;
460 bool readonly; /* For RAM regions */
461 bool nonvolatile;
462 bool rom_device;
463 bool flush_coalesced_mmio;
464 uint8_t dirty_log_mask;
465 bool is_iommu;
466 RAMBlock *ram_block;
467 Object *owner;
468
469 const MemoryRegionOps *ops;
470 void *opaque;
471 MemoryRegion *container;
472 Int128 size;
473 hwaddr addr;
474 void (*destructor)(MemoryRegion *mr);
475 uint64_t align;
476 bool terminates;
477 bool ram_device;
478 bool enabled;
479 bool warning_printed; /* For reservations */
480 uint8_t vga_logging_count;
481 MemoryRegion *alias;
482 hwaddr alias_offset;
483 int32_t priority;
484 QTAILQ_HEAD(, MemoryRegion) subregions;
485 QTAILQ_ENTRY(MemoryRegion) subregions_link;
486 QTAILQ_HEAD(, CoalescedMemoryRange) coalesced;
487 const char *name;
488 unsigned ioeventfd_nb;
489 MemoryRegionIoeventfd *ioeventfds;
490 };
491
492 struct IOMMUMemoryRegion {
493 MemoryRegion parent_obj;
494
495 QLIST_HEAD(, IOMMUNotifier) iommu_notify;
496 IOMMUNotifierFlag iommu_notify_flags;
497 };
498
499 #define IOMMU_NOTIFIER_FOREACH(n, mr) \
500 QLIST_FOREACH((n), &(mr)->iommu_notify, node)
501
502 /**
503 * struct MemoryListener: callbacks structure for updates to the physical memory map
504 *
505 * Allows a component to adjust to changes in the guest-visible memory map.
506 * Use with memory_listener_register() and memory_listener_unregister().
507 */
508 struct MemoryListener {
509 /**
510 * @begin:
511 *
512 * Called at the beginning of an address space update transaction.
513 * Followed by calls to #MemoryListener.region_add(),
514 * #MemoryListener.region_del(), #MemoryListener.region_nop(),
515 * #MemoryListener.log_start() and #MemoryListener.log_stop() in
516 * increasing address order.
517 *
518 * @listener: The #MemoryListener.
519 */
520 void (*begin)(MemoryListener *listener);
521
522 /**
523 * @commit:
524 *
525 * Called at the end of an address space update transaction,
526 * after the last call to #MemoryListener.region_add(),
527 * #MemoryListener.region_del() or #MemoryListener.region_nop(),
528 * #MemoryListener.log_start() and #MemoryListener.log_stop().
529 *
530 * @listener: The #MemoryListener.
531 */
532 void (*commit)(MemoryListener *listener);
533
534 /**
535 * @region_add:
536 *
537 * Called during an address space update transaction,
538 * for a section of the address space that is new in this address space
539 * space since the last transaction.
540 *
541 * @listener: The #MemoryListener.
542 * @section: The new #MemoryRegionSection.
543 */
544 void (*region_add)(MemoryListener *listener, MemoryRegionSection *section);
545
546 /**
547 * @region_del:
548 *
549 * Called during an address space update transaction,
550 * for a section of the address space that has disappeared in the address
551 * space since the last transaction.
552 *
553 * @listener: The #MemoryListener.
554 * @section: The old #MemoryRegionSection.
555 */
556 void (*region_del)(MemoryListener *listener, MemoryRegionSection *section);
557
558 /**
559 * @region_nop:
560 *
561 * Called during an address space update transaction,
562 * for a section of the address space that is in the same place in the address
563 * space as in the last transaction.
564 *
565 * @listener: The #MemoryListener.
566 * @section: The #MemoryRegionSection.
567 */
568 void (*region_nop)(MemoryListener *listener, MemoryRegionSection *section);
569
570 /**
571 * @log_start:
572 *
573 * Called during an address space update transaction, after
574 * one of #MemoryListener.region_add(),#MemoryListener.region_del() or
575 * #MemoryListener.region_nop(), if dirty memory logging clients have
576 * become active since the last transaction.
577 *
578 * @listener: The #MemoryListener.
579 * @section: The #MemoryRegionSection.
580 * @old: A bitmap of dirty memory logging clients that were active in
581 * the previous transaction.
582 * @new: A bitmap of dirty memory logging clients that are active in
583 * the current transaction.
584 */
585 void (*log_start)(MemoryListener *listener, MemoryRegionSection *section,
586 int old, int new);
587
588 /**
589 * @log_stop:
590 *
591 * Called during an address space update transaction, after
592 * one of #MemoryListener.region_add(), #MemoryListener.region_del() or
593 * #MemoryListener.region_nop() and possibly after
594 * #MemoryListener.log_start(), if dirty memory logging clients have
595 * become inactive since the last transaction.
596 *
597 * @listener: The #MemoryListener.
598 * @section: The #MemoryRegionSection.
599 * @old: A bitmap of dirty memory logging clients that were active in
600 * the previous transaction.
601 * @new: A bitmap of dirty memory logging clients that are active in
602 * the current transaction.
603 */
604 void (*log_stop)(MemoryListener *listener, MemoryRegionSection *section,
605 int old, int new);
606
607 /**
608 * @log_sync:
609 *
610 * Called by memory_region_snapshot_and_clear_dirty() and
611 * memory_global_dirty_log_sync(), before accessing QEMU's "official"
612 * copy of the dirty memory bitmap for a #MemoryRegionSection.
613 *
614 * @listener: The #MemoryListener.
615 * @section: The #MemoryRegionSection.
616 */
617 void (*log_sync)(MemoryListener *listener, MemoryRegionSection *section);
618
619 /**
620 * @log_clear:
621 *
622 * Called before reading the dirty memory bitmap for a
623 * #MemoryRegionSection.
624 *
625 * @listener: The #MemoryListener.
626 * @section: The #MemoryRegionSection.
627 */
628 void (*log_clear)(MemoryListener *listener, MemoryRegionSection *section);
629
630 /**
631 * @log_global_start:
632 *
633 * Called by memory_global_dirty_log_start(), which
634 * enables the %DIRTY_LOG_MIGRATION client on all memory regions in
635 * the address space. #MemoryListener.log_global_start() is also
636 * called when a #MemoryListener is added, if global dirty logging is
637 * active at that time.
638 *
639 * @listener: The #MemoryListener.
640 */
641 void (*log_global_start)(MemoryListener *listener);
642
643 /**
644 * @log_global_stop:
645 *
646 * Called by memory_global_dirty_log_stop(), which
647 * disables the %DIRTY_LOG_MIGRATION client on all memory regions in
648 * the address space.
649 *
650 * @listener: The #MemoryListener.
651 */
652 void (*log_global_stop)(MemoryListener *listener);
653
654 /**
655 * @log_global_after_sync:
656 *
657 * Called after reading the dirty memory bitmap
658 * for any #MemoryRegionSection.
659 *
660 * @listener: The #MemoryListener.
661 */
662 void (*log_global_after_sync)(MemoryListener *listener);
663
664 /**
665 * @eventfd_add:
666 *
667 * Called during an address space update transaction,
668 * for a section of the address space that has had a new ioeventfd
669 * registration since the last transaction.
670 *
671 * @listener: The #MemoryListener.
672 * @section: The new #MemoryRegionSection.
673 * @match_data: The @match_data parameter for the new ioeventfd.
674 * @data: The @data parameter for the new ioeventfd.
675 * @e: The #EventNotifier parameter for the new ioeventfd.
676 */
677 void (*eventfd_add)(MemoryListener *listener, MemoryRegionSection *section,
678 bool match_data, uint64_t data, EventNotifier *e);
679
680 /**
681 * @eventfd_del:
682 *
683 * Called during an address space update transaction,
684 * for a section of the address space that has dropped an ioeventfd
685 * registration since the last transaction.
686 *
687 * @listener: The #MemoryListener.
688 * @section: The new #MemoryRegionSection.
689 * @match_data: The @match_data parameter for the dropped ioeventfd.
690 * @data: The @data parameter for the dropped ioeventfd.
691 * @e: The #EventNotifier parameter for the dropped ioeventfd.
692 */
693 void (*eventfd_del)(MemoryListener *listener, MemoryRegionSection *section,
694 bool match_data, uint64_t data, EventNotifier *e);
695
696 /**
697 * @coalesced_io_add:
698 *
699 * Called during an address space update transaction,
700 * for a section of the address space that has had a new coalesced
701 * MMIO range registration since the last transaction.
702 *
703 * @listener: The #MemoryListener.
704 * @section: The new #MemoryRegionSection.
705 * @addr: The starting address for the coalesced MMIO range.
706 * @len: The length of the coalesced MMIO range.
707 */
708 void (*coalesced_io_add)(MemoryListener *listener, MemoryRegionSection *section,
709 hwaddr addr, hwaddr len);
710
711 /**
712 * @coalesced_io_del:
713 *
714 * Called during an address space update transaction,
715 * for a section of the address space that has dropped a coalesced
716 * MMIO range since the last transaction.
717 *
718 * @listener: The #MemoryListener.
719 * @section: The new #MemoryRegionSection.
720 * @addr: The starting address for the coalesced MMIO range.
721 * @len: The length of the coalesced MMIO range.
722 */
723 void (*coalesced_io_del)(MemoryListener *listener, MemoryRegionSection *section,
724 hwaddr addr, hwaddr len);
725 /**
726 * @priority:
727 *
728 * Govern the order in which memory listeners are invoked. Lower priorities
729 * are invoked earlier for "add" or "start" callbacks, and later for "delete"
730 * or "stop" callbacks.
731 */
732 unsigned priority;
733
734 /* private: */
735 AddressSpace *address_space;
736 QTAILQ_ENTRY(MemoryListener) link;
737 QTAILQ_ENTRY(MemoryListener) link_as;
738 };
739
740 /**
741 * struct AddressSpace: describes a mapping of addresses to #MemoryRegion objects
742 */
743 struct AddressSpace {
744 /* private: */
745 struct rcu_head rcu;
746 char *name;
747 MemoryRegion *root;
748
749 /* Accessed via RCU. */
750 struct FlatView *current_map;
751
752 int ioeventfd_nb;
753 struct MemoryRegionIoeventfd *ioeventfds;
754 QTAILQ_HEAD(, MemoryListener) listeners;
755 QTAILQ_ENTRY(AddressSpace) address_spaces_link;
756 };
757
758 typedef struct AddressSpaceDispatch AddressSpaceDispatch;
759 typedef struct FlatRange FlatRange;
760
761 /* Flattened global view of current active memory hierarchy. Kept in sorted
762 * order.
763 */
764 struct FlatView {
765 struct rcu_head rcu;
766 unsigned ref;
767 FlatRange *ranges;
768 unsigned nr;
769 unsigned nr_allocated;
770 struct AddressSpaceDispatch *dispatch;
771 MemoryRegion *root;
772 };
773
address_space_to_flatview(AddressSpace * as)774 static inline FlatView *address_space_to_flatview(AddressSpace *as)
775 {
776 return qatomic_rcu_read(&as->current_map);
777 }
778
779 /**
780 * typedef flatview_cb: callback for flatview_for_each_range()
781 *
782 * @start: start address of the range within the FlatView
783 * @len: length of the range in bytes
784 * @mr: MemoryRegion covering this range
785 * @offset_in_region: offset of the first byte of the range within @mr
786 * @opaque: data pointer passed to flatview_for_each_range()
787 *
788 * Returns: true to stop the iteration, false to keep going.
789 */
790 typedef bool (*flatview_cb)(Int128 start,
791 Int128 len,
792 const MemoryRegion *mr,
793 hwaddr offset_in_region,
794 void *opaque);
795
796 /**
797 * flatview_for_each_range: Iterate through a FlatView
798 * @fv: the FlatView to iterate through
799 * @cb: function to call for each range
800 * @opaque: opaque data pointer to pass to @cb
801 *
802 * A FlatView is made up of a list of non-overlapping ranges, each of
803 * which is a slice of a MemoryRegion. This function iterates through
804 * each range in @fv, calling @cb. The callback function can terminate
805 * iteration early by returning 'true'.
806 */
807 void flatview_for_each_range(FlatView *fv, flatview_cb cb, void *opaque);
808
809 /**
810 * struct MemoryRegionSection: describes a fragment of a #MemoryRegion
811 *
812 * @mr: the region, or %NULL if empty
813 * @fv: the flat view of the address space the region is mapped in
814 * @offset_within_region: the beginning of the section, relative to @mr's start
815 * @size: the size of the section; will not exceed @mr's boundaries
816 * @offset_within_address_space: the address of the first byte of the section
817 * relative to the region's address space
818 * @readonly: writes to this section are ignored
819 * @nonvolatile: this section is non-volatile
820 */
821 struct MemoryRegionSection {
822 Int128 size;
823 MemoryRegion *mr;
824 FlatView *fv;
825 hwaddr offset_within_region;
826 hwaddr offset_within_address_space;
827 bool readonly;
828 bool nonvolatile;
829 };
830
MemoryRegionSection_eq(MemoryRegionSection * a,MemoryRegionSection * b)831 static inline bool MemoryRegionSection_eq(MemoryRegionSection *a,
832 MemoryRegionSection *b)
833 {
834 return a->mr == b->mr &&
835 a->fv == b->fv &&
836 a->offset_within_region == b->offset_within_region &&
837 a->offset_within_address_space == b->offset_within_address_space &&
838 int128_eq(a->size, b->size) &&
839 a->readonly == b->readonly &&
840 a->nonvolatile == b->nonvolatile;
841 }
842
843 /**
844 * memory_region_init: Initialize a memory region
845 *
846 * The region typically acts as a container for other memory regions. Use
847 * memory_region_add_subregion() to add subregions.
848 *
849 * @mr: the #MemoryRegion to be initialized
850 * @owner: the object that tracks the region's reference count
851 * @name: used for debugging; not visible to the user or ABI
852 * @size: size of the region; any subregions beyond this size will be clipped
853 */
854 void memory_region_init(MemoryRegion *mr,
855 Object *owner,
856 const char *name,
857 uint64_t size);
858
859 /**
860 * memory_region_ref: Add 1 to a memory region's reference count
861 *
862 * Whenever memory regions are accessed outside the BQL, they need to be
863 * preserved against hot-unplug. MemoryRegions actually do not have their
864 * own reference count; they piggyback on a QOM object, their "owner".
865 * This function adds a reference to the owner.
866 *
867 * All MemoryRegions must have an owner if they can disappear, even if the
868 * device they belong to operates exclusively under the BQL. This is because
869 * the region could be returned at any time by memory_region_find, and this
870 * is usually under guest control.
871 *
872 * @mr: the #MemoryRegion
873 */
874 void memory_region_ref(MemoryRegion *mr);
875
876 /**
877 * memory_region_unref: Remove 1 to a memory region's reference count
878 *
879 * Whenever memory regions are accessed outside the BQL, they need to be
880 * preserved against hot-unplug. MemoryRegions actually do not have their
881 * own reference count; they piggyback on a QOM object, their "owner".
882 * This function removes a reference to the owner and possibly destroys it.
883 *
884 * @mr: the #MemoryRegion
885 */
886 void memory_region_unref(MemoryRegion *mr);
887
888 /**
889 * memory_region_init_io: Initialize an I/O memory region.
890 *
891 * Accesses into the region will cause the callbacks in @ops to be called.
892 * if @size is nonzero, subregions will be clipped to @size.
893 *
894 * @mr: the #MemoryRegion to be initialized.
895 * @owner: the object that tracks the region's reference count
896 * @ops: a structure containing read and write callbacks to be used when
897 * I/O is performed on the region.
898 * @opaque: passed to the read and write callbacks of the @ops structure.
899 * @name: used for debugging; not visible to the user or ABI
900 * @size: size of the region.
901 */
902 void memory_region_init_io(MemoryRegion *mr,
903 Object *owner,
904 const MemoryRegionOps *ops,
905 void *opaque,
906 const char *name,
907 uint64_t size);
908
909 /**
910 * memory_region_init_ram_nomigrate: Initialize RAM memory region. Accesses
911 * into the region will modify memory
912 * directly.
913 *
914 * @mr: the #MemoryRegion to be initialized.
915 * @owner: the object that tracks the region's reference count
916 * @name: Region name, becomes part of RAMBlock name used in migration stream
917 * must be unique within any device
918 * @size: size of the region.
919 * @errp: pointer to Error*, to store an error if it happens.
920 *
921 * Note that this function does not do anything to cause the data in the
922 * RAM memory region to be migrated; that is the responsibility of the caller.
923 */
924 void memory_region_init_ram_nomigrate(MemoryRegion *mr,
925 Object *owner,
926 const char *name,
927 uint64_t size,
928 Error **errp);
929
930 /**
931 * memory_region_init_ram_shared_nomigrate: Initialize RAM memory region.
932 * Accesses into the region will
933 * modify memory directly.
934 *
935 * @mr: the #MemoryRegion to be initialized.
936 * @owner: the object that tracks the region's reference count
937 * @name: Region name, becomes part of RAMBlock name used in migration stream
938 * must be unique within any device
939 * @size: size of the region.
940 * @share: allow remapping RAM to different addresses
941 * @errp: pointer to Error*, to store an error if it happens.
942 *
943 * Note that this function is similar to memory_region_init_ram_nomigrate.
944 * The only difference is part of the RAM region can be remapped.
945 */
946 void memory_region_init_ram_shared_nomigrate(MemoryRegion *mr,
947 Object *owner,
948 const char *name,
949 uint64_t size,
950 bool share,
951 Error **errp);
952
953 /**
954 * memory_region_init_resizeable_ram: Initialize memory region with resizeable
955 * RAM. Accesses into the region will
956 * modify memory directly. Only an initial
957 * portion of this RAM is actually used.
958 * The used size can change across reboots.
959 *
960 * @mr: the #MemoryRegion to be initialized.
961 * @owner: the object that tracks the region's reference count
962 * @name: Region name, becomes part of RAMBlock name used in migration stream
963 * must be unique within any device
964 * @size: used size of the region.
965 * @max_size: max size of the region.
966 * @resized: callback to notify owner about used size change.
967 * @errp: pointer to Error*, to store an error if it happens.
968 *
969 * Note that this function does not do anything to cause the data in the
970 * RAM memory region to be migrated; that is the responsibility of the caller.
971 */
972 void memory_region_init_resizeable_ram(MemoryRegion *mr,
973 Object *owner,
974 const char *name,
975 uint64_t size,
976 uint64_t max_size,
977 void (*resized)(const char*,
978 uint64_t length,
979 void *host),
980 Error **errp);
981 #ifdef CONFIG_POSIX
982
983 /**
984 * memory_region_init_ram_from_file: Initialize RAM memory region with a
985 * mmap-ed backend.
986 *
987 * @mr: the #MemoryRegion to be initialized.
988 * @owner: the object that tracks the region's reference count
989 * @name: Region name, becomes part of RAMBlock name used in migration stream
990 * must be unique within any device
991 * @size: size of the region.
992 * @align: alignment of the region base address; if 0, the default alignment
993 * (getpagesize()) will be used.
994 * @ram_flags: Memory region features:
995 * - RAM_SHARED: memory must be mmaped with the MAP_SHARED flag
996 * - RAM_PMEM: the memory is persistent memory
997 * Other bits are ignored now.
998 * @path: the path in which to allocate the RAM.
999 * @readonly: true to open @path for reading, false for read/write.
1000 * @errp: pointer to Error*, to store an error if it happens.
1001 *
1002 * Note that this function does not do anything to cause the data in the
1003 * RAM memory region to be migrated; that is the responsibility of the caller.
1004 */
1005 void memory_region_init_ram_from_file(MemoryRegion *mr,
1006 Object *owner,
1007 const char *name,
1008 uint64_t size,
1009 uint64_t align,
1010 uint32_t ram_flags,
1011 const char *path,
1012 bool readonly,
1013 Error **errp);
1014
1015 /**
1016 * memory_region_init_ram_from_fd: Initialize RAM memory region with a
1017 * mmap-ed backend.
1018 *
1019 * @mr: the #MemoryRegion to be initialized.
1020 * @owner: the object that tracks the region's reference count
1021 * @name: the name of the region.
1022 * @size: size of the region.
1023 * @share: %true if memory must be mmaped with the MAP_SHARED flag
1024 * @fd: the fd to mmap.
1025 * @offset: offset within the file referenced by fd
1026 * @errp: pointer to Error*, to store an error if it happens.
1027 *
1028 * Note that this function does not do anything to cause the data in the
1029 * RAM memory region to be migrated; that is the responsibility of the caller.
1030 */
1031 void memory_region_init_ram_from_fd(MemoryRegion *mr,
1032 Object *owner,
1033 const char *name,
1034 uint64_t size,
1035 bool share,
1036 int fd,
1037 ram_addr_t offset,
1038 Error **errp);
1039 #endif
1040
1041 /**
1042 * memory_region_init_ram_ptr: Initialize RAM memory region from a
1043 * user-provided pointer. Accesses into the
1044 * region will modify memory directly.
1045 *
1046 * @mr: the #MemoryRegion to be initialized.
1047 * @owner: the object that tracks the region's reference count
1048 * @name: Region name, becomes part of RAMBlock name used in migration stream
1049 * must be unique within any device
1050 * @size: size of the region.
1051 * @ptr: memory to be mapped; must contain at least @size bytes.
1052 *
1053 * Note that this function does not do anything to cause the data in the
1054 * RAM memory region to be migrated; that is the responsibility of the caller.
1055 */
1056 void memory_region_init_ram_ptr(MemoryRegion *mr,
1057 Object *owner,
1058 const char *name,
1059 uint64_t size,
1060 void *ptr);
1061
1062 /**
1063 * memory_region_init_ram_device_ptr: Initialize RAM device memory region from
1064 * a user-provided pointer.
1065 *
1066 * A RAM device represents a mapping to a physical device, such as to a PCI
1067 * MMIO BAR of an vfio-pci assigned device. The memory region may be mapped
1068 * into the VM address space and access to the region will modify memory
1069 * directly. However, the memory region should not be included in a memory
1070 * dump (device may not be enabled/mapped at the time of the dump), and
1071 * operations incompatible with manipulating MMIO should be avoided. Replaces
1072 * skip_dump flag.
1073 *
1074 * @mr: the #MemoryRegion to be initialized.
1075 * @owner: the object that tracks the region's reference count
1076 * @name: the name of the region.
1077 * @size: size of the region.
1078 * @ptr: memory to be mapped; must contain at least @size bytes.
1079 *
1080 * Note that this function does not do anything to cause the data in the
1081 * RAM memory region to be migrated; that is the responsibility of the caller.
1082 * (For RAM device memory regions, migrating the contents rarely makes sense.)
1083 */
1084 void memory_region_init_ram_device_ptr(MemoryRegion *mr,
1085 Object *owner,
1086 const char *name,
1087 uint64_t size,
1088 void *ptr);
1089
1090 /**
1091 * memory_region_init_alias: Initialize a memory region that aliases all or a
1092 * part of another memory region.
1093 *
1094 * @mr: the #MemoryRegion to be initialized.
1095 * @owner: the object that tracks the region's reference count
1096 * @name: used for debugging; not visible to the user or ABI
1097 * @orig: the region to be referenced; @mr will be equivalent to
1098 * @orig between @offset and @offset + @size - 1.
1099 * @offset: start of the section in @orig to be referenced.
1100 * @size: size of the region.
1101 */
1102 void memory_region_init_alias(MemoryRegion *mr,
1103 Object *owner,
1104 const char *name,
1105 MemoryRegion *orig,
1106 hwaddr offset,
1107 uint64_t size);
1108
1109 /**
1110 * memory_region_init_rom_nomigrate: Initialize a ROM memory region.
1111 *
1112 * This has the same effect as calling memory_region_init_ram_nomigrate()
1113 * and then marking the resulting region read-only with
1114 * memory_region_set_readonly().
1115 *
1116 * Note that this function does not do anything to cause the data in the
1117 * RAM side of the memory region to be migrated; that is the responsibility
1118 * of the caller.
1119 *
1120 * @mr: the #MemoryRegion to be initialized.
1121 * @owner: the object that tracks the region's reference count
1122 * @name: Region name, becomes part of RAMBlock name used in migration stream
1123 * must be unique within any device
1124 * @size: size of the region.
1125 * @errp: pointer to Error*, to store an error if it happens.
1126 */
1127 void memory_region_init_rom_nomigrate(MemoryRegion *mr,
1128 Object *owner,
1129 const char *name,
1130 uint64_t size,
1131 Error **errp);
1132
1133 /**
1134 * memory_region_init_rom_device_nomigrate: Initialize a ROM memory region.
1135 * Writes are handled via callbacks.
1136 *
1137 * Note that this function does not do anything to cause the data in the
1138 * RAM side of the memory region to be migrated; that is the responsibility
1139 * of the caller.
1140 *
1141 * @mr: the #MemoryRegion to be initialized.
1142 * @owner: the object that tracks the region's reference count
1143 * @ops: callbacks for write access handling (must not be NULL).
1144 * @opaque: passed to the read and write callbacks of the @ops structure.
1145 * @name: Region name, becomes part of RAMBlock name used in migration stream
1146 * must be unique within any device
1147 * @size: size of the region.
1148 * @errp: pointer to Error*, to store an error if it happens.
1149 */
1150 void memory_region_init_rom_device_nomigrate(MemoryRegion *mr,
1151 Object *owner,
1152 const MemoryRegionOps *ops,
1153 void *opaque,
1154 const char *name,
1155 uint64_t size,
1156 Error **errp);
1157
1158 /**
1159 * memory_region_init_iommu: Initialize a memory region of a custom type
1160 * that translates addresses
1161 *
1162 * An IOMMU region translates addresses and forwards accesses to a target
1163 * memory region.
1164 *
1165 * The IOMMU implementation must define a subclass of TYPE_IOMMU_MEMORY_REGION.
1166 * @_iommu_mr should be a pointer to enough memory for an instance of
1167 * that subclass, @instance_size is the size of that subclass, and
1168 * @mrtypename is its name. This function will initialize @_iommu_mr as an
1169 * instance of the subclass, and its methods will then be called to handle
1170 * accesses to the memory region. See the documentation of
1171 * #IOMMUMemoryRegionClass for further details.
1172 *
1173 * @_iommu_mr: the #IOMMUMemoryRegion to be initialized
1174 * @instance_size: the IOMMUMemoryRegion subclass instance size
1175 * @mrtypename: the type name of the #IOMMUMemoryRegion
1176 * @owner: the object that tracks the region's reference count
1177 * @name: used for debugging; not visible to the user or ABI
1178 * @size: size of the region.
1179 */
1180 void memory_region_init_iommu(void *_iommu_mr,
1181 size_t instance_size,
1182 const char *mrtypename,
1183 Object *owner,
1184 const char *name,
1185 uint64_t size);
1186
1187 /**
1188 * memory_region_init_ram - Initialize RAM memory region. Accesses into the
1189 * region will modify memory directly.
1190 *
1191 * @mr: the #MemoryRegion to be initialized
1192 * @owner: the object that tracks the region's reference count (must be
1193 * TYPE_DEVICE or a subclass of TYPE_DEVICE, or NULL)
1194 * @name: name of the memory region
1195 * @size: size of the region in bytes
1196 * @errp: pointer to Error*, to store an error if it happens.
1197 *
1198 * This function allocates RAM for a board model or device, and
1199 * arranges for it to be migrated (by calling vmstate_register_ram()
1200 * if @owner is a DeviceState, or vmstate_register_ram_global() if
1201 * @owner is NULL).
1202 *
1203 * TODO: Currently we restrict @owner to being either NULL (for
1204 * global RAM regions with no owner) or devices, so that we can
1205 * give the RAM block a unique name for migration purposes.
1206 * We should lift this restriction and allow arbitrary Objects.
1207 * If you pass a non-NULL non-device @owner then we will assert.
1208 */
1209 void memory_region_init_ram(MemoryRegion *mr,
1210 Object *owner,
1211 const char *name,
1212 uint64_t size,
1213 Error **errp);
1214
1215 /**
1216 * memory_region_init_rom: Initialize a ROM memory region.
1217 *
1218 * This has the same effect as calling memory_region_init_ram()
1219 * and then marking the resulting region read-only with
1220 * memory_region_set_readonly(). This includes arranging for the
1221 * contents to be migrated.
1222 *
1223 * TODO: Currently we restrict @owner to being either NULL (for
1224 * global RAM regions with no owner) or devices, so that we can
1225 * give the RAM block a unique name for migration purposes.
1226 * We should lift this restriction and allow arbitrary Objects.
1227 * If you pass a non-NULL non-device @owner then we will assert.
1228 *
1229 * @mr: the #MemoryRegion to be initialized.
1230 * @owner: the object that tracks the region's reference count
1231 * @name: Region name, becomes part of RAMBlock name used in migration stream
1232 * must be unique within any device
1233 * @size: size of the region.
1234 * @errp: pointer to Error*, to store an error if it happens.
1235 */
1236 void memory_region_init_rom(MemoryRegion *mr,
1237 Object *owner,
1238 const char *name,
1239 uint64_t size,
1240 Error **errp);
1241
1242 /**
1243 * memory_region_init_rom_device: Initialize a ROM memory region.
1244 * Writes are handled via callbacks.
1245 *
1246 * This function initializes a memory region backed by RAM for reads
1247 * and callbacks for writes, and arranges for the RAM backing to
1248 * be migrated (by calling vmstate_register_ram()
1249 * if @owner is a DeviceState, or vmstate_register_ram_global() if
1250 * @owner is NULL).
1251 *
1252 * TODO: Currently we restrict @owner to being either NULL (for
1253 * global RAM regions with no owner) or devices, so that we can
1254 * give the RAM block a unique name for migration purposes.
1255 * We should lift this restriction and allow arbitrary Objects.
1256 * If you pass a non-NULL non-device @owner then we will assert.
1257 *
1258 * @mr: the #MemoryRegion to be initialized.
1259 * @owner: the object that tracks the region's reference count
1260 * @ops: callbacks for write access handling (must not be NULL).
1261 * @opaque: passed to the read and write callbacks of the @ops structure.
1262 * @name: Region name, becomes part of RAMBlock name used in migration stream
1263 * must be unique within any device
1264 * @size: size of the region.
1265 * @errp: pointer to Error*, to store an error if it happens.
1266 */
1267 void memory_region_init_rom_device(MemoryRegion *mr,
1268 Object *owner,
1269 const MemoryRegionOps *ops,
1270 void *opaque,
1271 const char *name,
1272 uint64_t size,
1273 Error **errp);
1274
1275
1276 /**
1277 * memory_region_owner: get a memory region's owner.
1278 *
1279 * @mr: the memory region being queried.
1280 */
1281 Object *memory_region_owner(MemoryRegion *mr);
1282
1283 /**
1284 * memory_region_size: get a memory region's size.
1285 *
1286 * @mr: the memory region being queried.
1287 */
1288 uint64_t memory_region_size(MemoryRegion *mr);
1289
1290 /**
1291 * memory_region_is_ram: check whether a memory region is random access
1292 *
1293 * Returns %true if a memory region is random access.
1294 *
1295 * @mr: the memory region being queried
1296 */
memory_region_is_ram(MemoryRegion * mr)1297 static inline bool memory_region_is_ram(MemoryRegion *mr)
1298 {
1299 return mr->ram;
1300 }
1301
1302 /**
1303 * memory_region_is_ram_device: check whether a memory region is a ram device
1304 *
1305 * Returns %true if a memory region is a device backed ram region
1306 *
1307 * @mr: the memory region being queried
1308 */
1309 bool memory_region_is_ram_device(MemoryRegion *mr);
1310
1311 /**
1312 * memory_region_is_romd: check whether a memory region is in ROMD mode
1313 *
1314 * Returns %true if a memory region is a ROM device and currently set to allow
1315 * direct reads.
1316 *
1317 * @mr: the memory region being queried
1318 */
memory_region_is_romd(MemoryRegion * mr)1319 static inline bool memory_region_is_romd(MemoryRegion *mr)
1320 {
1321 return mr->rom_device && mr->romd_mode;
1322 }
1323
1324 /**
1325 * memory_region_get_iommu: check whether a memory region is an iommu
1326 *
1327 * Returns pointer to IOMMUMemoryRegion if a memory region is an iommu,
1328 * otherwise NULL.
1329 *
1330 * @mr: the memory region being queried
1331 */
memory_region_get_iommu(MemoryRegion * mr)1332 static inline IOMMUMemoryRegion *memory_region_get_iommu(MemoryRegion *mr)
1333 {
1334 if (mr->alias) {
1335 return memory_region_get_iommu(mr->alias);
1336 }
1337 if (mr->is_iommu) {
1338 return (IOMMUMemoryRegion *) mr;
1339 }
1340 return NULL;
1341 }
1342
1343 /**
1344 * memory_region_get_iommu_class_nocheck: returns iommu memory region class
1345 * if an iommu or NULL if not
1346 *
1347 * Returns pointer to IOMMUMemoryRegionClass if a memory region is an iommu,
1348 * otherwise NULL. This is fast path avoiding QOM checking, use with caution.
1349 *
1350 * @iommu_mr: the memory region being queried
1351 */
memory_region_get_iommu_class_nocheck(IOMMUMemoryRegion * iommu_mr)1352 static inline IOMMUMemoryRegionClass *memory_region_get_iommu_class_nocheck(
1353 IOMMUMemoryRegion *iommu_mr)
1354 {
1355 return (IOMMUMemoryRegionClass *) (((Object *)iommu_mr)->class);
1356 }
1357
1358 #define memory_region_is_iommu(mr) (memory_region_get_iommu(mr) != NULL)
1359
1360 /**
1361 * memory_region_iommu_get_min_page_size: get minimum supported page size
1362 * for an iommu
1363 *
1364 * Returns minimum supported page size for an iommu.
1365 *
1366 * @iommu_mr: the memory region being queried
1367 */
1368 uint64_t memory_region_iommu_get_min_page_size(IOMMUMemoryRegion *iommu_mr);
1369
1370 /**
1371 * memory_region_notify_iommu: notify a change in an IOMMU translation entry.
1372 *
1373 * Note: for any IOMMU implementation, an in-place mapping change
1374 * should be notified with an UNMAP followed by a MAP.
1375 *
1376 * @iommu_mr: the memory region that was changed
1377 * @iommu_idx: the IOMMU index for the translation table which has changed
1378 * @event: TLB event with the new entry in the IOMMU translation table.
1379 * The entry replaces all old entries for the same virtual I/O address
1380 * range.
1381 */
1382 void memory_region_notify_iommu(IOMMUMemoryRegion *iommu_mr,
1383 int iommu_idx,
1384 IOMMUTLBEvent event);
1385
1386 /**
1387 * memory_region_notify_iommu_one: notify a change in an IOMMU translation
1388 * entry to a single notifier
1389 *
1390 * This works just like memory_region_notify_iommu(), but it only
1391 * notifies a specific notifier, not all of them.
1392 *
1393 * @notifier: the notifier to be notified
1394 * @event: TLB event with the new entry in the IOMMU translation table.
1395 * The entry replaces all old entries for the same virtual I/O address
1396 * range.
1397 */
1398 void memory_region_notify_iommu_one(IOMMUNotifier *notifier,
1399 IOMMUTLBEvent *event);
1400
1401 /**
1402 * memory_region_register_iommu_notifier: register a notifier for changes to
1403 * IOMMU translation entries.
1404 *
1405 * Returns 0 on success, or a negative errno otherwise. In particular,
1406 * -EINVAL indicates that at least one of the attributes of the notifier
1407 * is not supported (flag/range) by the IOMMU memory region. In case of error
1408 * the error object must be created.
1409 *
1410 * @mr: the memory region to observe
1411 * @n: the IOMMUNotifier to be added; the notify callback receives a
1412 * pointer to an #IOMMUTLBEntry as the opaque value; the pointer
1413 * ceases to be valid on exit from the notifier.
1414 * @errp: pointer to Error*, to store an error if it happens.
1415 */
1416 int memory_region_register_iommu_notifier(MemoryRegion *mr,
1417 IOMMUNotifier *n, Error **errp);
1418
1419 /**
1420 * memory_region_iommu_replay: replay existing IOMMU translations to
1421 * a notifier with the minimum page granularity returned by
1422 * mr->iommu_ops->get_page_size().
1423 *
1424 * Note: this is not related to record-and-replay functionality.
1425 *
1426 * @iommu_mr: the memory region to observe
1427 * @n: the notifier to which to replay iommu mappings
1428 */
1429 void memory_region_iommu_replay(IOMMUMemoryRegion *iommu_mr, IOMMUNotifier *n);
1430
1431 /**
1432 * memory_region_unregister_iommu_notifier: unregister a notifier for
1433 * changes to IOMMU translation entries.
1434 *
1435 * @mr: the memory region which was observed and for which notity_stopped()
1436 * needs to be called
1437 * @n: the notifier to be removed.
1438 */
1439 void memory_region_unregister_iommu_notifier(MemoryRegion *mr,
1440 IOMMUNotifier *n);
1441
1442 /**
1443 * memory_region_iommu_get_attr: return an IOMMU attr if get_attr() is
1444 * defined on the IOMMU.
1445 *
1446 * Returns 0 on success, or a negative errno otherwise. In particular,
1447 * -EINVAL indicates that the IOMMU does not support the requested
1448 * attribute.
1449 *
1450 * @iommu_mr: the memory region
1451 * @attr: the requested attribute
1452 * @data: a pointer to the requested attribute data
1453 */
1454 int memory_region_iommu_get_attr(IOMMUMemoryRegion *iommu_mr,
1455 enum IOMMUMemoryRegionAttr attr,
1456 void *data);
1457
1458 /**
1459 * memory_region_iommu_attrs_to_index: return the IOMMU index to
1460 * use for translations with the given memory transaction attributes.
1461 *
1462 * @iommu_mr: the memory region
1463 * @attrs: the memory transaction attributes
1464 */
1465 int memory_region_iommu_attrs_to_index(IOMMUMemoryRegion *iommu_mr,
1466 MemTxAttrs attrs);
1467
1468 /**
1469 * memory_region_iommu_num_indexes: return the total number of IOMMU
1470 * indexes that this IOMMU supports.
1471 *
1472 * @iommu_mr: the memory region
1473 */
1474 int memory_region_iommu_num_indexes(IOMMUMemoryRegion *iommu_mr);
1475
1476 /**
1477 * memory_region_iommu_set_page_size_mask: set the supported page
1478 * sizes for a given IOMMU memory region
1479 *
1480 * @iommu_mr: IOMMU memory region
1481 * @page_size_mask: supported page size mask
1482 * @errp: pointer to Error*, to store an error if it happens.
1483 */
1484 int memory_region_iommu_set_page_size_mask(IOMMUMemoryRegion *iommu_mr,
1485 uint64_t page_size_mask,
1486 Error **errp);
1487
1488 /**
1489 * memory_region_name: get a memory region's name
1490 *
1491 * Returns the string that was used to initialize the memory region.
1492 *
1493 * @mr: the memory region being queried
1494 */
1495 const char *memory_region_name(const MemoryRegion *mr);
1496
1497 /**
1498 * memory_region_is_logging: return whether a memory region is logging writes
1499 *
1500 * Returns %true if the memory region is logging writes for the given client
1501 *
1502 * @mr: the memory region being queried
1503 * @client: the client being queried
1504 */
1505 bool memory_region_is_logging(MemoryRegion *mr, uint8_t client);
1506
1507 /**
1508 * memory_region_get_dirty_log_mask: return the clients for which a
1509 * memory region is logging writes.
1510 *
1511 * Returns a bitmap of clients, in which the DIRTY_MEMORY_* constants
1512 * are the bit indices.
1513 *
1514 * @mr: the memory region being queried
1515 */
1516 uint8_t memory_region_get_dirty_log_mask(MemoryRegion *mr);
1517
1518 /**
1519 * memory_region_is_rom: check whether a memory region is ROM
1520 *
1521 * Returns %true if a memory region is read-only memory.
1522 *
1523 * @mr: the memory region being queried
1524 */
memory_region_is_rom(MemoryRegion * mr)1525 static inline bool memory_region_is_rom(MemoryRegion *mr)
1526 {
1527 return mr->ram && mr->readonly;
1528 }
1529
1530 /**
1531 * memory_region_is_nonvolatile: check whether a memory region is non-volatile
1532 *
1533 * Returns %true is a memory region is non-volatile memory.
1534 *
1535 * @mr: the memory region being queried
1536 */
memory_region_is_nonvolatile(MemoryRegion * mr)1537 static inline bool memory_region_is_nonvolatile(MemoryRegion *mr)
1538 {
1539 return mr->nonvolatile;
1540 }
1541
1542 /**
1543 * memory_region_get_fd: Get a file descriptor backing a RAM memory region.
1544 *
1545 * Returns a file descriptor backing a file-based RAM memory region,
1546 * or -1 if the region is not a file-based RAM memory region.
1547 *
1548 * @mr: the RAM or alias memory region being queried.
1549 */
1550 int memory_region_get_fd(MemoryRegion *mr);
1551
1552 /**
1553 * memory_region_from_host: Convert a pointer into a RAM memory region
1554 * and an offset within it.
1555 *
1556 * Given a host pointer inside a RAM memory region (created with
1557 * memory_region_init_ram() or memory_region_init_ram_ptr()), return
1558 * the MemoryRegion and the offset within it.
1559 *
1560 * Use with care; by the time this function returns, the returned pointer is
1561 * not protected by RCU anymore. If the caller is not within an RCU critical
1562 * section and does not hold the iothread lock, it must have other means of
1563 * protecting the pointer, such as a reference to the region that includes
1564 * the incoming ram_addr_t.
1565 *
1566 * @ptr: the host pointer to be converted
1567 * @offset: the offset within memory region
1568 */
1569 MemoryRegion *memory_region_from_host(void *ptr, ram_addr_t *offset);
1570
1571 /**
1572 * memory_region_get_ram_ptr: Get a pointer into a RAM memory region.
1573 *
1574 * Returns a host pointer to a RAM memory region (created with
1575 * memory_region_init_ram() or memory_region_init_ram_ptr()).
1576 *
1577 * Use with care; by the time this function returns, the returned pointer is
1578 * not protected by RCU anymore. If the caller is not within an RCU critical
1579 * section and does not hold the iothread lock, it must have other means of
1580 * protecting the pointer, such as a reference to the region that includes
1581 * the incoming ram_addr_t.
1582 *
1583 * @mr: the memory region being queried.
1584 */
1585 void *memory_region_get_ram_ptr(MemoryRegion *mr);
1586
1587 /* memory_region_ram_resize: Resize a RAM region.
1588 *
1589 * Only legal before guest might have detected the memory size: e.g. on
1590 * incoming migration, or right after reset.
1591 *
1592 * @mr: a memory region created with @memory_region_init_resizeable_ram.
1593 * @newsize: the new size the region
1594 * @errp: pointer to Error*, to store an error if it happens.
1595 */
1596 void memory_region_ram_resize(MemoryRegion *mr, ram_addr_t newsize,
1597 Error **errp);
1598
1599 /**
1600 * memory_region_msync: Synchronize selected address range of
1601 * a memory mapped region
1602 *
1603 * @mr: the memory region to be msync
1604 * @addr: the initial address of the range to be sync
1605 * @size: the size of the range to be sync
1606 */
1607 void memory_region_msync(MemoryRegion *mr, hwaddr addr, hwaddr size);
1608
1609 /**
1610 * memory_region_writeback: Trigger cache writeback for
1611 * selected address range
1612 *
1613 * @mr: the memory region to be updated
1614 * @addr: the initial address of the range to be written back
1615 * @size: the size of the range to be written back
1616 */
1617 void memory_region_writeback(MemoryRegion *mr, hwaddr addr, hwaddr size);
1618
1619 /**
1620 * memory_region_set_log: Turn dirty logging on or off for a region.
1621 *
1622 * Turns dirty logging on or off for a specified client (display, migration).
1623 * Only meaningful for RAM regions.
1624 *
1625 * @mr: the memory region being updated.
1626 * @log: whether dirty logging is to be enabled or disabled.
1627 * @client: the user of the logging information; %DIRTY_MEMORY_VGA only.
1628 */
1629 void memory_region_set_log(MemoryRegion *mr, bool log, unsigned client);
1630
1631 /**
1632 * memory_region_set_dirty: Mark a range of bytes as dirty in a memory region.
1633 *
1634 * Marks a range of bytes as dirty, after it has been dirtied outside
1635 * guest code.
1636 *
1637 * @mr: the memory region being dirtied.
1638 * @addr: the address (relative to the start of the region) being dirtied.
1639 * @size: size of the range being dirtied.
1640 */
1641 void memory_region_set_dirty(MemoryRegion *mr, hwaddr addr,
1642 hwaddr size);
1643
1644 /**
1645 * memory_region_clear_dirty_bitmap - clear dirty bitmap for memory range
1646 *
1647 * This function is called when the caller wants to clear the remote
1648 * dirty bitmap of a memory range within the memory region. This can
1649 * be used by e.g. KVM to manually clear dirty log when
1650 * KVM_CAP_MANUAL_DIRTY_LOG_PROTECT is declared support by the host
1651 * kernel.
1652 *
1653 * @mr: the memory region to clear the dirty log upon
1654 * @start: start address offset within the memory region
1655 * @len: length of the memory region to clear dirty bitmap
1656 */
1657 void memory_region_clear_dirty_bitmap(MemoryRegion *mr, hwaddr start,
1658 hwaddr len);
1659
1660 /**
1661 * memory_region_snapshot_and_clear_dirty: Get a snapshot of the dirty
1662 * bitmap and clear it.
1663 *
1664 * Creates a snapshot of the dirty bitmap, clears the dirty bitmap and
1665 * returns the snapshot. The snapshot can then be used to query dirty
1666 * status, using memory_region_snapshot_get_dirty. Snapshotting allows
1667 * querying the same page multiple times, which is especially useful for
1668 * display updates where the scanlines often are not page aligned.
1669 *
1670 * The dirty bitmap region which gets copyed into the snapshot (and
1671 * cleared afterwards) can be larger than requested. The boundaries
1672 * are rounded up/down so complete bitmap longs (covering 64 pages on
1673 * 64bit hosts) can be copied over into the bitmap snapshot. Which
1674 * isn't a problem for display updates as the extra pages are outside
1675 * the visible area, and in case the visible area changes a full
1676 * display redraw is due anyway. Should other use cases for this
1677 * function emerge we might have to revisit this implementation
1678 * detail.
1679 *
1680 * Use g_free to release DirtyBitmapSnapshot.
1681 *
1682 * @mr: the memory region being queried.
1683 * @addr: the address (relative to the start of the region) being queried.
1684 * @size: the size of the range being queried.
1685 * @client: the user of the logging information; typically %DIRTY_MEMORY_VGA.
1686 */
1687 DirtyBitmapSnapshot *memory_region_snapshot_and_clear_dirty(MemoryRegion *mr,
1688 hwaddr addr,
1689 hwaddr size,
1690 unsigned client);
1691
1692 /**
1693 * memory_region_snapshot_get_dirty: Check whether a range of bytes is dirty
1694 * in the specified dirty bitmap snapshot.
1695 *
1696 * @mr: the memory region being queried.
1697 * @snap: the dirty bitmap snapshot
1698 * @addr: the address (relative to the start of the region) being queried.
1699 * @size: the size of the range being queried.
1700 */
1701 bool memory_region_snapshot_get_dirty(MemoryRegion *mr,
1702 DirtyBitmapSnapshot *snap,
1703 hwaddr addr, hwaddr size);
1704
1705 /**
1706 * memory_region_reset_dirty: Mark a range of pages as clean, for a specified
1707 * client.
1708 *
1709 * Marks a range of pages as no longer dirty.
1710 *
1711 * @mr: the region being updated.
1712 * @addr: the start of the subrange being cleaned.
1713 * @size: the size of the subrange being cleaned.
1714 * @client: the user of the logging information; %DIRTY_MEMORY_MIGRATION or
1715 * %DIRTY_MEMORY_VGA.
1716 */
1717 void memory_region_reset_dirty(MemoryRegion *mr, hwaddr addr,
1718 hwaddr size, unsigned client);
1719
1720 /**
1721 * memory_region_flush_rom_device: Mark a range of pages dirty and invalidate
1722 * TBs (for self-modifying code).
1723 *
1724 * The MemoryRegionOps->write() callback of a ROM device must use this function
1725 * to mark byte ranges that have been modified internally, such as by directly
1726 * accessing the memory returned by memory_region_get_ram_ptr().
1727 *
1728 * This function marks the range dirty and invalidates TBs so that TCG can
1729 * detect self-modifying code.
1730 *
1731 * @mr: the region being flushed.
1732 * @addr: the start, relative to the start of the region, of the range being
1733 * flushed.
1734 * @size: the size, in bytes, of the range being flushed.
1735 */
1736 void memory_region_flush_rom_device(MemoryRegion *mr, hwaddr addr, hwaddr size);
1737
1738 /**
1739 * memory_region_set_readonly: Turn a memory region read-only (or read-write)
1740 *
1741 * Allows a memory region to be marked as read-only (turning it into a ROM).
1742 * only useful on RAM regions.
1743 *
1744 * @mr: the region being updated.
1745 * @readonly: whether rhe region is to be ROM or RAM.
1746 */
1747 void memory_region_set_readonly(MemoryRegion *mr, bool readonly);
1748
1749 /**
1750 * memory_region_set_nonvolatile: Turn a memory region non-volatile
1751 *
1752 * Allows a memory region to be marked as non-volatile.
1753 * only useful on RAM regions.
1754 *
1755 * @mr: the region being updated.
1756 * @nonvolatile: whether rhe region is to be non-volatile.
1757 */
1758 void memory_region_set_nonvolatile(MemoryRegion *mr, bool nonvolatile);
1759
1760 /**
1761 * memory_region_rom_device_set_romd: enable/disable ROMD mode
1762 *
1763 * Allows a ROM device (initialized with memory_region_init_rom_device() to
1764 * set to ROMD mode (default) or MMIO mode. When it is in ROMD mode, the
1765 * device is mapped to guest memory and satisfies read access directly.
1766 * When in MMIO mode, reads are forwarded to the #MemoryRegion.read function.
1767 * Writes are always handled by the #MemoryRegion.write function.
1768 *
1769 * @mr: the memory region to be updated
1770 * @romd_mode: %true to put the region into ROMD mode
1771 */
1772 void memory_region_rom_device_set_romd(MemoryRegion *mr, bool romd_mode);
1773
1774 /**
1775 * memory_region_set_coalescing: Enable memory coalescing for the region.
1776 *
1777 * Enabled writes to a region to be queued for later processing. MMIO ->write
1778 * callbacks may be delayed until a non-coalesced MMIO is issued.
1779 * Only useful for IO regions. Roughly similar to write-combining hardware.
1780 *
1781 * @mr: the memory region to be write coalesced
1782 */
1783 void memory_region_set_coalescing(MemoryRegion *mr);
1784
1785 /**
1786 * memory_region_add_coalescing: Enable memory coalescing for a sub-range of
1787 * a region.
1788 *
1789 * Like memory_region_set_coalescing(), but works on a sub-range of a region.
1790 * Multiple calls can be issued coalesced disjoint ranges.
1791 *
1792 * @mr: the memory region to be updated.
1793 * @offset: the start of the range within the region to be coalesced.
1794 * @size: the size of the subrange to be coalesced.
1795 */
1796 void memory_region_add_coalescing(MemoryRegion *mr,
1797 hwaddr offset,
1798 uint64_t size);
1799
1800 /**
1801 * memory_region_clear_coalescing: Disable MMIO coalescing for the region.
1802 *
1803 * Disables any coalescing caused by memory_region_set_coalescing() or
1804 * memory_region_add_coalescing(). Roughly equivalent to uncacheble memory
1805 * hardware.
1806 *
1807 * @mr: the memory region to be updated.
1808 */
1809 void memory_region_clear_coalescing(MemoryRegion *mr);
1810
1811 /**
1812 * memory_region_set_flush_coalesced: Enforce memory coalescing flush before
1813 * accesses.
1814 *
1815 * Ensure that pending coalesced MMIO request are flushed before the memory
1816 * region is accessed. This property is automatically enabled for all regions
1817 * passed to memory_region_set_coalescing() and memory_region_add_coalescing().
1818 *
1819 * @mr: the memory region to be updated.
1820 */
1821 void memory_region_set_flush_coalesced(MemoryRegion *mr);
1822
1823 /**
1824 * memory_region_clear_flush_coalesced: Disable memory coalescing flush before
1825 * accesses.
1826 *
1827 * Clear the automatic coalesced MMIO flushing enabled via
1828 * memory_region_set_flush_coalesced. Note that this service has no effect on
1829 * memory regions that have MMIO coalescing enabled for themselves. For them,
1830 * automatic flushing will stop once coalescing is disabled.
1831 *
1832 * @mr: the memory region to be updated.
1833 */
1834 void memory_region_clear_flush_coalesced(MemoryRegion *mr);
1835
1836 /**
1837 * memory_region_add_eventfd: Request an eventfd to be triggered when a word
1838 * is written to a location.
1839 *
1840 * Marks a word in an IO region (initialized with memory_region_init_io())
1841 * as a trigger for an eventfd event. The I/O callback will not be called.
1842 * The caller must be prepared to handle failure (that is, take the required
1843 * action if the callback _is_ called).
1844 *
1845 * @mr: the memory region being updated.
1846 * @addr: the address within @mr that is to be monitored
1847 * @size: the size of the access to trigger the eventfd
1848 * @match_data: whether to match against @data, instead of just @addr
1849 * @data: the data to match against the guest write
1850 * @e: event notifier to be triggered when @addr, @size, and @data all match.
1851 **/
1852 void memory_region_add_eventfd(MemoryRegion *mr,
1853 hwaddr addr,
1854 unsigned size,
1855 bool match_data,
1856 uint64_t data,
1857 EventNotifier *e);
1858
1859 /**
1860 * memory_region_del_eventfd: Cancel an eventfd.
1861 *
1862 * Cancels an eventfd trigger requested by a previous
1863 * memory_region_add_eventfd() call.
1864 *
1865 * @mr: the memory region being updated.
1866 * @addr: the address within @mr that is to be monitored
1867 * @size: the size of the access to trigger the eventfd
1868 * @match_data: whether to match against @data, instead of just @addr
1869 * @data: the data to match against the guest write
1870 * @e: event notifier to be triggered when @addr, @size, and @data all match.
1871 */
1872 void memory_region_del_eventfd(MemoryRegion *mr,
1873 hwaddr addr,
1874 unsigned size,
1875 bool match_data,
1876 uint64_t data,
1877 EventNotifier *e);
1878
1879 /**
1880 * memory_region_add_subregion: Add a subregion to a container.
1881 *
1882 * Adds a subregion at @offset. The subregion may not overlap with other
1883 * subregions (except for those explicitly marked as overlapping). A region
1884 * may only be added once as a subregion (unless removed with
1885 * memory_region_del_subregion()); use memory_region_init_alias() if you
1886 * want a region to be a subregion in multiple locations.
1887 *
1888 * @mr: the region to contain the new subregion; must be a container
1889 * initialized with memory_region_init().
1890 * @offset: the offset relative to @mr where @subregion is added.
1891 * @subregion: the subregion to be added.
1892 */
1893 void memory_region_add_subregion(MemoryRegion *mr,
1894 hwaddr offset,
1895 MemoryRegion *subregion);
1896 /**
1897 * memory_region_add_subregion_overlap: Add a subregion to a container
1898 * with overlap.
1899 *
1900 * Adds a subregion at @offset. The subregion may overlap with other
1901 * subregions. Conflicts are resolved by having a higher @priority hide a
1902 * lower @priority. Subregions without priority are taken as @priority 0.
1903 * A region may only be added once as a subregion (unless removed with
1904 * memory_region_del_subregion()); use memory_region_init_alias() if you
1905 * want a region to be a subregion in multiple locations.
1906 *
1907 * @mr: the region to contain the new subregion; must be a container
1908 * initialized with memory_region_init().
1909 * @offset: the offset relative to @mr where @subregion is added.
1910 * @subregion: the subregion to be added.
1911 * @priority: used for resolving overlaps; highest priority wins.
1912 */
1913 void memory_region_add_subregion_overlap(MemoryRegion *mr,
1914 hwaddr offset,
1915 MemoryRegion *subregion,
1916 int priority);
1917
1918 /**
1919 * memory_region_get_ram_addr: Get the ram address associated with a memory
1920 * region
1921 *
1922 * @mr: the region to be queried
1923 */
1924 ram_addr_t memory_region_get_ram_addr(MemoryRegion *mr);
1925
1926 uint64_t memory_region_get_alignment(const MemoryRegion *mr);
1927 /**
1928 * memory_region_del_subregion: Remove a subregion.
1929 *
1930 * Removes a subregion from its container.
1931 *
1932 * @mr: the container to be updated.
1933 * @subregion: the region being removed; must be a current subregion of @mr.
1934 */
1935 void memory_region_del_subregion(MemoryRegion *mr,
1936 MemoryRegion *subregion);
1937
1938 /*
1939 * memory_region_set_enabled: dynamically enable or disable a region
1940 *
1941 * Enables or disables a memory region. A disabled memory region
1942 * ignores all accesses to itself and its subregions. It does not
1943 * obscure sibling subregions with lower priority - it simply behaves as
1944 * if it was removed from the hierarchy.
1945 *
1946 * Regions default to being enabled.
1947 *
1948 * @mr: the region to be updated
1949 * @enabled: whether to enable or disable the region
1950 */
1951 void memory_region_set_enabled(MemoryRegion *mr, bool enabled);
1952
1953 /*
1954 * memory_region_set_address: dynamically update the address of a region
1955 *
1956 * Dynamically updates the address of a region, relative to its container.
1957 * May be used on regions are currently part of a memory hierarchy.
1958 *
1959 * @mr: the region to be updated
1960 * @addr: new address, relative to container region
1961 */
1962 void memory_region_set_address(MemoryRegion *mr, hwaddr addr);
1963
1964 /*
1965 * memory_region_set_size: dynamically update the size of a region.
1966 *
1967 * Dynamically updates the size of a region.
1968 *
1969 * @mr: the region to be updated
1970 * @size: used size of the region.
1971 */
1972 void memory_region_set_size(MemoryRegion *mr, uint64_t size);
1973
1974 /*
1975 * memory_region_set_alias_offset: dynamically update a memory alias's offset
1976 *
1977 * Dynamically updates the offset into the target region that an alias points
1978 * to, as if the fourth argument to memory_region_init_alias() has changed.
1979 *
1980 * @mr: the #MemoryRegion to be updated; should be an alias.
1981 * @offset: the new offset into the target memory region
1982 */
1983 void memory_region_set_alias_offset(MemoryRegion *mr,
1984 hwaddr offset);
1985
1986 /**
1987 * memory_region_present: checks if an address relative to a @container
1988 * translates into #MemoryRegion within @container
1989 *
1990 * Answer whether a #MemoryRegion within @container covers the address
1991 * @addr.
1992 *
1993 * @container: a #MemoryRegion within which @addr is a relative address
1994 * @addr: the area within @container to be searched
1995 */
1996 bool memory_region_present(MemoryRegion *container, hwaddr addr);
1997
1998 /**
1999 * memory_region_is_mapped: returns true if #MemoryRegion is mapped
2000 * into any address space.
2001 *
2002 * @mr: a #MemoryRegion which should be checked if it's mapped
2003 */
2004 bool memory_region_is_mapped(MemoryRegion *mr);
2005
2006 /**
2007 * memory_region_find: translate an address/size relative to a
2008 * MemoryRegion into a #MemoryRegionSection.
2009 *
2010 * Locates the first #MemoryRegion within @mr that overlaps the range
2011 * given by @addr and @size.
2012 *
2013 * Returns a #MemoryRegionSection that describes a contiguous overlap.
2014 * It will have the following characteristics:
2015 * - @size = 0 iff no overlap was found
2016 * - @mr is non-%NULL iff an overlap was found
2017 *
2018 * Remember that in the return value the @offset_within_region is
2019 * relative to the returned region (in the .@mr field), not to the
2020 * @mr argument.
2021 *
2022 * Similarly, the .@offset_within_address_space is relative to the
2023 * address space that contains both regions, the passed and the
2024 * returned one. However, in the special case where the @mr argument
2025 * has no container (and thus is the root of the address space), the
2026 * following will hold:
2027 * - @offset_within_address_space >= @addr
2028 * - @offset_within_address_space + .@size <= @addr + @size
2029 *
2030 * @mr: a MemoryRegion within which @addr is a relative address
2031 * @addr: start of the area within @as to be searched
2032 * @size: size of the area to be searched
2033 */
2034 MemoryRegionSection memory_region_find(MemoryRegion *mr,
2035 hwaddr addr, uint64_t size);
2036
2037 /**
2038 * memory_global_dirty_log_sync: synchronize the dirty log for all memory
2039 *
2040 * Synchronizes the dirty page log for all address spaces.
2041 */
2042 void memory_global_dirty_log_sync(void);
2043
2044 /**
2045 * memory_global_dirty_log_sync: synchronize the dirty log for all memory
2046 *
2047 * Synchronizes the vCPUs with a thread that is reading the dirty bitmap.
2048 * This function must be called after the dirty log bitmap is cleared, and
2049 * before dirty guest memory pages are read. If you are using
2050 * #DirtyBitmapSnapshot, memory_region_snapshot_and_clear_dirty() takes
2051 * care of doing this.
2052 */
2053 void memory_global_after_dirty_log_sync(void);
2054
2055 /**
2056 * memory_region_transaction_begin: Start a transaction.
2057 *
2058 * During a transaction, changes will be accumulated and made visible
2059 * only when the transaction ends (is committed).
2060 */
2061 void memory_region_transaction_begin(void);
2062
2063 /**
2064 * memory_region_transaction_commit: Commit a transaction and make changes
2065 * visible to the guest.
2066 */
2067 void memory_region_transaction_commit(void);
2068
2069 /**
2070 * memory_listener_register: register callbacks to be called when memory
2071 * sections are mapped or unmapped into an address
2072 * space
2073 *
2074 * @listener: an object containing the callbacks to be called
2075 * @filter: if non-%NULL, only regions in this address space will be observed
2076 */
2077 void memory_listener_register(MemoryListener *listener, AddressSpace *filter);
2078
2079 /**
2080 * memory_listener_unregister: undo the effect of memory_listener_register()
2081 *
2082 * @listener: an object containing the callbacks to be removed
2083 */
2084 void memory_listener_unregister(MemoryListener *listener);
2085
2086 /**
2087 * memory_global_dirty_log_start: begin dirty logging for all regions
2088 */
2089 void memory_global_dirty_log_start(void);
2090
2091 /**
2092 * memory_global_dirty_log_stop: end dirty logging for all regions
2093 */
2094 void memory_global_dirty_log_stop(void);
2095
2096 void mtree_info(bool flatview, bool dispatch_tree, bool owner, bool disabled);
2097
2098 /**
2099 * memory_region_dispatch_read: perform a read directly to the specified
2100 * MemoryRegion.
2101 *
2102 * @mr: #MemoryRegion to access
2103 * @addr: address within that region
2104 * @pval: pointer to uint64_t which the data is written to
2105 * @op: size, sign, and endianness of the memory operation
2106 * @attrs: memory transaction attributes to use for the access
2107 */
2108 MemTxResult memory_region_dispatch_read(MemoryRegion *mr,
2109 hwaddr addr,
2110 uint64_t *pval,
2111 MemOp op,
2112 MemTxAttrs attrs);
2113 /**
2114 * memory_region_dispatch_write: perform a write directly to the specified
2115 * MemoryRegion.
2116 *
2117 * @mr: #MemoryRegion to access
2118 * @addr: address within that region
2119 * @data: data to write
2120 * @op: size, sign, and endianness of the memory operation
2121 * @attrs: memory transaction attributes to use for the access
2122 */
2123 MemTxResult memory_region_dispatch_write(MemoryRegion *mr,
2124 hwaddr addr,
2125 uint64_t data,
2126 MemOp op,
2127 MemTxAttrs attrs);
2128
2129 /**
2130 * address_space_init: initializes an address space
2131 *
2132 * @as: an uninitialized #AddressSpace
2133 * @root: a #MemoryRegion that routes addresses for the address space
2134 * @name: an address space name. The name is only used for debugging
2135 * output.
2136 */
2137 void address_space_init(AddressSpace *as, MemoryRegion *root, const char *name);
2138
2139 /**
2140 * address_space_destroy: destroy an address space
2141 *
2142 * Releases all resources associated with an address space. After an address space
2143 * is destroyed, its root memory region (given by address_space_init()) may be destroyed
2144 * as well.
2145 *
2146 * @as: address space to be destroyed
2147 */
2148 void address_space_destroy(AddressSpace *as);
2149
2150 /**
2151 * address_space_remove_listeners: unregister all listeners of an address space
2152 *
2153 * Removes all callbacks previously registered with memory_listener_register()
2154 * for @as.
2155 *
2156 * @as: an initialized #AddressSpace
2157 */
2158 void address_space_remove_listeners(AddressSpace *as);
2159
2160 /**
2161 * address_space_rw: read from or write to an address space.
2162 *
2163 * Return a MemTxResult indicating whether the operation succeeded
2164 * or failed (eg unassigned memory, device rejected the transaction,
2165 * IOMMU fault).
2166 *
2167 * @as: #AddressSpace to be accessed
2168 * @addr: address within that address space
2169 * @attrs: memory transaction attributes
2170 * @buf: buffer with the data transferred
2171 * @len: the number of bytes to read or write
2172 * @is_write: indicates the transfer direction
2173 */
2174 MemTxResult address_space_rw(AddressSpace *as, hwaddr addr,
2175 MemTxAttrs attrs, void *buf,
2176 hwaddr len, bool is_write);
2177
2178 /**
2179 * address_space_write: write to address space.
2180 *
2181 * Return a MemTxResult indicating whether the operation succeeded
2182 * or failed (eg unassigned memory, device rejected the transaction,
2183 * IOMMU fault).
2184 *
2185 * @as: #AddressSpace to be accessed
2186 * @addr: address within that address space
2187 * @attrs: memory transaction attributes
2188 * @buf: buffer with the data transferred
2189 * @len: the number of bytes to write
2190 */
2191 MemTxResult address_space_write(AddressSpace *as, hwaddr addr,
2192 MemTxAttrs attrs,
2193 const void *buf, hwaddr len);
2194
2195 /**
2196 * address_space_write_rom: write to address space, including ROM.
2197 *
2198 * This function writes to the specified address space, but will
2199 * write data to both ROM and RAM. This is used for non-guest
2200 * writes like writes from the gdb debug stub or initial loading
2201 * of ROM contents.
2202 *
2203 * Note that portions of the write which attempt to write data to
2204 * a device will be silently ignored -- only real RAM and ROM will
2205 * be written to.
2206 *
2207 * Return a MemTxResult indicating whether the operation succeeded
2208 * or failed (eg unassigned memory, device rejected the transaction,
2209 * IOMMU fault).
2210 *
2211 * @as: #AddressSpace to be accessed
2212 * @addr: address within that address space
2213 * @attrs: memory transaction attributes
2214 * @buf: buffer with the data transferred
2215 * @len: the number of bytes to write
2216 */
2217 MemTxResult address_space_write_rom(AddressSpace *as, hwaddr addr,
2218 MemTxAttrs attrs,
2219 const void *buf, hwaddr len);
2220
2221 /* address_space_ld*: load from an address space
2222 * address_space_st*: store to an address space
2223 *
2224 * These functions perform a load or store of the byte, word,
2225 * longword or quad to the specified address within the AddressSpace.
2226 * The _le suffixed functions treat the data as little endian;
2227 * _be indicates big endian; no suffix indicates "same endianness
2228 * as guest CPU".
2229 *
2230 * The "guest CPU endianness" accessors are deprecated for use outside
2231 * target-* code; devices should be CPU-agnostic and use either the LE
2232 * or the BE accessors.
2233 *
2234 * @as #AddressSpace to be accessed
2235 * @addr: address within that address space
2236 * @val: data value, for stores
2237 * @attrs: memory transaction attributes
2238 * @result: location to write the success/failure of the transaction;
2239 * if NULL, this information is discarded
2240 */
2241
2242 #define SUFFIX
2243 #define ARG1 as
2244 #define ARG1_DECL AddressSpace *as
2245 #include "exec/memory_ldst.h.inc"
2246
2247 #define SUFFIX
2248 #define ARG1 as
2249 #define ARG1_DECL AddressSpace *as
2250 #include "exec/memory_ldst_phys.h.inc"
2251
2252 struct MemoryRegionCache {
2253 void *ptr;
2254 hwaddr xlat;
2255 hwaddr len;
2256 FlatView *fv;
2257 MemoryRegionSection mrs;
2258 bool is_write;
2259 };
2260
2261 #define MEMORY_REGION_CACHE_INVALID ((MemoryRegionCache) { .mrs.mr = NULL })
2262
2263
2264 /* address_space_ld*_cached: load from a cached #MemoryRegion
2265 * address_space_st*_cached: store into a cached #MemoryRegion
2266 *
2267 * These functions perform a load or store of the byte, word,
2268 * longword or quad to the specified address. The address is
2269 * a physical address in the AddressSpace, but it must lie within
2270 * a #MemoryRegion that was mapped with address_space_cache_init.
2271 *
2272 * The _le suffixed functions treat the data as little endian;
2273 * _be indicates big endian; no suffix indicates "same endianness
2274 * as guest CPU".
2275 *
2276 * The "guest CPU endianness" accessors are deprecated for use outside
2277 * target-* code; devices should be CPU-agnostic and use either the LE
2278 * or the BE accessors.
2279 *
2280 * @cache: previously initialized #MemoryRegionCache to be accessed
2281 * @addr: address within the address space
2282 * @val: data value, for stores
2283 * @attrs: memory transaction attributes
2284 * @result: location to write the success/failure of the transaction;
2285 * if NULL, this information is discarded
2286 */
2287
2288 #define SUFFIX _cached_slow
2289 #define ARG1 cache
2290 #define ARG1_DECL MemoryRegionCache *cache
2291 #include "exec/memory_ldst.h.inc"
2292
2293 /* Inline fast path for direct RAM access. */
address_space_ldub_cached(MemoryRegionCache * cache,hwaddr addr,MemTxAttrs attrs,MemTxResult * result)2294 static inline uint8_t address_space_ldub_cached(MemoryRegionCache *cache,
2295 hwaddr addr, MemTxAttrs attrs, MemTxResult *result)
2296 {
2297 assert(addr < cache->len);
2298 if (likely(cache->ptr)) {
2299 return ldub_p(cache->ptr + addr);
2300 } else {
2301 return address_space_ldub_cached_slow(cache, addr, attrs, result);
2302 }
2303 }
2304
address_space_stb_cached(MemoryRegionCache * cache,hwaddr addr,uint32_t val,MemTxAttrs attrs,MemTxResult * result)2305 static inline void address_space_stb_cached(MemoryRegionCache *cache,
2306 hwaddr addr, uint32_t val, MemTxAttrs attrs, MemTxResult *result)
2307 {
2308 assert(addr < cache->len);
2309 if (likely(cache->ptr)) {
2310 stb_p(cache->ptr + addr, val);
2311 } else {
2312 address_space_stb_cached_slow(cache, addr, val, attrs, result);
2313 }
2314 }
2315
2316 #define ENDIANNESS _le
2317 #include "exec/memory_ldst_cached.h.inc"
2318
2319 #define ENDIANNESS _be
2320 #include "exec/memory_ldst_cached.h.inc"
2321
2322 #define SUFFIX _cached
2323 #define ARG1 cache
2324 #define ARG1_DECL MemoryRegionCache *cache
2325 #include "exec/memory_ldst_phys.h.inc"
2326
2327 /* address_space_cache_init: prepare for repeated access to a physical
2328 * memory region
2329 *
2330 * @cache: #MemoryRegionCache to be filled
2331 * @as: #AddressSpace to be accessed
2332 * @addr: address within that address space
2333 * @len: length of buffer
2334 * @is_write: indicates the transfer direction
2335 *
2336 * Will only work with RAM, and may map a subset of the requested range by
2337 * returning a value that is less than @len. On failure, return a negative
2338 * errno value.
2339 *
2340 * Because it only works with RAM, this function can be used for
2341 * read-modify-write operations. In this case, is_write should be %true.
2342 *
2343 * Note that addresses passed to the address_space_*_cached functions
2344 * are relative to @addr.
2345 */
2346 int64_t address_space_cache_init(MemoryRegionCache *cache,
2347 AddressSpace *as,
2348 hwaddr addr,
2349 hwaddr len,
2350 bool is_write);
2351
2352 /**
2353 * address_space_cache_invalidate: complete a write to a #MemoryRegionCache
2354 *
2355 * @cache: The #MemoryRegionCache to operate on.
2356 * @addr: The first physical address that was written, relative to the
2357 * address that was passed to @address_space_cache_init.
2358 * @access_len: The number of bytes that were written starting at @addr.
2359 */
2360 void address_space_cache_invalidate(MemoryRegionCache *cache,
2361 hwaddr addr,
2362 hwaddr access_len);
2363
2364 /**
2365 * address_space_cache_destroy: free a #MemoryRegionCache
2366 *
2367 * @cache: The #MemoryRegionCache whose memory should be released.
2368 */
2369 void address_space_cache_destroy(MemoryRegionCache *cache);
2370
2371 /* address_space_get_iotlb_entry: translate an address into an IOTLB
2372 * entry. Should be called from an RCU critical section.
2373 */
2374 IOMMUTLBEntry address_space_get_iotlb_entry(AddressSpace *as, hwaddr addr,
2375 bool is_write, MemTxAttrs attrs);
2376
2377 /* address_space_translate: translate an address range into an address space
2378 * into a MemoryRegion and an address range into that section. Should be
2379 * called from an RCU critical section, to avoid that the last reference
2380 * to the returned region disappears after address_space_translate returns.
2381 *
2382 * @fv: #FlatView to be accessed
2383 * @addr: address within that address space
2384 * @xlat: pointer to address within the returned memory region section's
2385 * #MemoryRegion.
2386 * @len: pointer to length
2387 * @is_write: indicates the transfer direction
2388 * @attrs: memory attributes
2389 */
2390 MemoryRegion *flatview_translate(FlatView *fv,
2391 hwaddr addr, hwaddr *xlat,
2392 hwaddr *len, bool is_write,
2393 MemTxAttrs attrs);
2394
address_space_translate(AddressSpace * as,hwaddr addr,hwaddr * xlat,hwaddr * len,bool is_write,MemTxAttrs attrs)2395 static inline MemoryRegion *address_space_translate(AddressSpace *as,
2396 hwaddr addr, hwaddr *xlat,
2397 hwaddr *len, bool is_write,
2398 MemTxAttrs attrs)
2399 {
2400 return flatview_translate(address_space_to_flatview(as),
2401 addr, xlat, len, is_write, attrs);
2402 }
2403
2404 /* address_space_access_valid: check for validity of accessing an address
2405 * space range
2406 *
2407 * Check whether memory is assigned to the given address space range, and
2408 * access is permitted by any IOMMU regions that are active for the address
2409 * space.
2410 *
2411 * For now, addr and len should be aligned to a page size. This limitation
2412 * will be lifted in the future.
2413 *
2414 * @as: #AddressSpace to be accessed
2415 * @addr: address within that address space
2416 * @len: length of the area to be checked
2417 * @is_write: indicates the transfer direction
2418 * @attrs: memory attributes
2419 */
2420 bool address_space_access_valid(AddressSpace *as, hwaddr addr, hwaddr len,
2421 bool is_write, MemTxAttrs attrs);
2422
2423 /* address_space_map: map a physical memory region into a host virtual address
2424 *
2425 * May map a subset of the requested range, given by and returned in @plen.
2426 * May return %NULL and set *@plen to zero(0), if resources needed to perform
2427 * the mapping are exhausted.
2428 * Use only for reads OR writes - not for read-modify-write operations.
2429 * Use cpu_register_map_client() to know when retrying the map operation is
2430 * likely to succeed.
2431 *
2432 * @as: #AddressSpace to be accessed
2433 * @addr: address within that address space
2434 * @plen: pointer to length of buffer; updated on return
2435 * @is_write: indicates the transfer direction
2436 * @attrs: memory attributes
2437 */
2438 void *address_space_map(AddressSpace *as, hwaddr addr,
2439 hwaddr *plen, bool is_write, MemTxAttrs attrs);
2440
2441 /* address_space_unmap: Unmaps a memory region previously mapped by address_space_map()
2442 *
2443 * Will also mark the memory as dirty if @is_write == %true. @access_len gives
2444 * the amount of memory that was actually read or written by the caller.
2445 *
2446 * @as: #AddressSpace used
2447 * @buffer: host pointer as returned by address_space_map()
2448 * @len: buffer length as returned by address_space_map()
2449 * @access_len: amount of data actually transferred
2450 * @is_write: indicates the transfer direction
2451 */
2452 void address_space_unmap(AddressSpace *as, void *buffer, hwaddr len,
2453 bool is_write, hwaddr access_len);
2454
2455
2456 /* Internal functions, part of the implementation of address_space_read. */
2457 MemTxResult address_space_read_full(AddressSpace *as, hwaddr addr,
2458 MemTxAttrs attrs, void *buf, hwaddr len);
2459 MemTxResult flatview_read_continue(FlatView *fv, hwaddr addr,
2460 MemTxAttrs attrs, void *buf,
2461 hwaddr len, hwaddr addr1, hwaddr l,
2462 MemoryRegion *mr);
2463 void *qemu_map_ram_ptr(RAMBlock *ram_block, ram_addr_t addr);
2464
2465 /* Internal functions, part of the implementation of address_space_read_cached
2466 * and address_space_write_cached. */
2467 MemTxResult address_space_read_cached_slow(MemoryRegionCache *cache,
2468 hwaddr addr, void *buf, hwaddr len);
2469 MemTxResult address_space_write_cached_slow(MemoryRegionCache *cache,
2470 hwaddr addr, const void *buf,
2471 hwaddr len);
2472
memory_access_is_direct(MemoryRegion * mr,bool is_write)2473 static inline bool memory_access_is_direct(MemoryRegion *mr, bool is_write)
2474 {
2475 if (is_write) {
2476 return memory_region_is_ram(mr) && !mr->readonly &&
2477 !mr->rom_device && !memory_region_is_ram_device(mr);
2478 } else {
2479 return (memory_region_is_ram(mr) && !memory_region_is_ram_device(mr)) ||
2480 memory_region_is_romd(mr);
2481 }
2482 }
2483
2484 /**
2485 * address_space_read: read from an address space.
2486 *
2487 * Return a MemTxResult indicating whether the operation succeeded
2488 * or failed (eg unassigned memory, device rejected the transaction,
2489 * IOMMU fault). Called within RCU critical section.
2490 *
2491 * @as: #AddressSpace to be accessed
2492 * @addr: address within that address space
2493 * @attrs: memory transaction attributes
2494 * @buf: buffer with the data transferred
2495 * @len: length of the data transferred
2496 */
2497 static inline __attribute__((__always_inline__))
address_space_read(AddressSpace * as,hwaddr addr,MemTxAttrs attrs,void * buf,hwaddr len)2498 MemTxResult address_space_read(AddressSpace *as, hwaddr addr,
2499 MemTxAttrs attrs, void *buf,
2500 hwaddr len)
2501 {
2502 MemTxResult result = MEMTX_OK;
2503 hwaddr l, addr1;
2504 void *ptr;
2505 MemoryRegion *mr;
2506 FlatView *fv;
2507
2508 if (__builtin_constant_p(len)) {
2509 if (len) {
2510 RCU_READ_LOCK_GUARD();
2511 fv = address_space_to_flatview(as);
2512 l = len;
2513 mr = flatview_translate(fv, addr, &addr1, &l, false, attrs);
2514 if (len == l && memory_access_is_direct(mr, false)) {
2515 ptr = qemu_map_ram_ptr(mr->ram_block, addr1);
2516 memcpy(buf, ptr, len);
2517 } else {
2518 result = flatview_read_continue(fv, addr, attrs, buf, len,
2519 addr1, l, mr);
2520 }
2521 }
2522 } else {
2523 result = address_space_read_full(as, addr, attrs, buf, len);
2524 }
2525 return result;
2526 }
2527
2528 /**
2529 * address_space_read_cached: read from a cached RAM region
2530 *
2531 * @cache: Cached region to be addressed
2532 * @addr: address relative to the base of the RAM region
2533 * @buf: buffer with the data transferred
2534 * @len: length of the data transferred
2535 */
2536 static inline MemTxResult
address_space_read_cached(MemoryRegionCache * cache,hwaddr addr,void * buf,hwaddr len)2537 address_space_read_cached(MemoryRegionCache *cache, hwaddr addr,
2538 void *buf, hwaddr len)
2539 {
2540 assert(addr < cache->len && len <= cache->len - addr);
2541 fuzz_dma_read_cb(cache->xlat + addr, len, cache->mrs.mr);
2542 if (likely(cache->ptr)) {
2543 memcpy(buf, cache->ptr + addr, len);
2544 return MEMTX_OK;
2545 } else {
2546 return address_space_read_cached_slow(cache, addr, buf, len);
2547 }
2548 }
2549
2550 /**
2551 * address_space_write_cached: write to a cached RAM region
2552 *
2553 * @cache: Cached region to be addressed
2554 * @addr: address relative to the base of the RAM region
2555 * @buf: buffer with the data transferred
2556 * @len: length of the data transferred
2557 */
2558 static inline MemTxResult
address_space_write_cached(MemoryRegionCache * cache,hwaddr addr,const void * buf,hwaddr len)2559 address_space_write_cached(MemoryRegionCache *cache, hwaddr addr,
2560 const void *buf, hwaddr len)
2561 {
2562 assert(addr < cache->len && len <= cache->len - addr);
2563 if (likely(cache->ptr)) {
2564 memcpy(cache->ptr + addr, buf, len);
2565 return MEMTX_OK;
2566 } else {
2567 return address_space_write_cached_slow(cache, addr, buf, len);
2568 }
2569 }
2570
2571 #ifdef NEED_CPU_H
2572 /* enum device_endian to MemOp. */
devend_memop(enum device_endian end)2573 static inline MemOp devend_memop(enum device_endian end)
2574 {
2575 QEMU_BUILD_BUG_ON(DEVICE_HOST_ENDIAN != DEVICE_LITTLE_ENDIAN &&
2576 DEVICE_HOST_ENDIAN != DEVICE_BIG_ENDIAN);
2577
2578 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
2579 /* Swap if non-host endianness or native (target) endianness */
2580 return (end == DEVICE_HOST_ENDIAN) ? 0 : MO_BSWAP;
2581 #else
2582 const int non_host_endianness =
2583 DEVICE_LITTLE_ENDIAN ^ DEVICE_BIG_ENDIAN ^ DEVICE_HOST_ENDIAN;
2584
2585 /* In this case, native (target) endianness needs no swap. */
2586 return (end == non_host_endianness) ? MO_BSWAP : 0;
2587 #endif
2588 }
2589 #endif
2590
2591 /*
2592 * Inhibit technologies that require discarding of pages in RAM blocks, e.g.,
2593 * to manage the actual amount of memory consumed by the VM (then, the memory
2594 * provided by RAM blocks might be bigger than the desired memory consumption).
2595 * This *must* be set if:
2596 * - Discarding parts of a RAM blocks does not result in the change being
2597 * reflected in the VM and the pages getting freed.
2598 * - All memory in RAM blocks is pinned or duplicated, invaldiating any previous
2599 * discards blindly.
2600 * - Discarding parts of a RAM blocks will result in integrity issues (e.g.,
2601 * encrypted VMs).
2602 * Technologies that only temporarily pin the current working set of a
2603 * driver are fine, because we don't expect such pages to be discarded
2604 * (esp. based on guest action like balloon inflation).
2605 *
2606 * This is *not* to be used to protect from concurrent discards (esp.,
2607 * postcopy).
2608 *
2609 * Returns 0 if successful. Returns -EBUSY if a technology that relies on
2610 * discards to work reliably is active.
2611 */
2612 int ram_block_discard_disable(bool state);
2613
2614 /*
2615 * Inhibit technologies that disable discarding of pages in RAM blocks.
2616 *
2617 * Returns 0 if successful. Returns -EBUSY if discards are already set to
2618 * broken.
2619 */
2620 int ram_block_discard_require(bool state);
2621
2622 /*
2623 * Test if discarding of memory in ram blocks is disabled.
2624 */
2625 bool ram_block_discard_is_disabled(void);
2626
2627 /*
2628 * Test if discarding of memory in ram blocks is required to work reliably.
2629 */
2630 bool ram_block_discard_is_required(void);
2631
2632 #endif
2633
2634 #endif
2635