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 #define DIRTY_MEMORY_VGA 0 20 #define DIRTY_MEMORY_CODE 1 21 #define DIRTY_MEMORY_MIGRATION 2 22 #define DIRTY_MEMORY_NUM 3 /* num of dirty bits */ 23 24 #include "exec/cpu-common.h" 25 #ifndef CONFIG_USER_ONLY 26 #include "exec/hwaddr.h" 27 #endif 28 #include "exec/memattrs.h" 29 #include "qemu/queue.h" 30 #include "qemu/int128.h" 31 #include "qemu/notify.h" 32 #include "qom/object.h" 33 #include "qemu/rcu.h" 34 #include "qemu/typedefs.h" 35 36 #define MAX_PHYS_ADDR_SPACE_BITS 62 37 #define MAX_PHYS_ADDR (((hwaddr)1 << MAX_PHYS_ADDR_SPACE_BITS) - 1) 38 39 #define TYPE_MEMORY_REGION "qemu:memory-region" 40 #define MEMORY_REGION(obj) \ 41 OBJECT_CHECK(MemoryRegion, (obj), TYPE_MEMORY_REGION) 42 43 typedef struct MemoryRegionOps MemoryRegionOps; 44 typedef struct MemoryRegionMmio MemoryRegionMmio; 45 46 struct MemoryRegionMmio { 47 CPUReadMemoryFunc *read[3]; 48 CPUWriteMemoryFunc *write[3]; 49 }; 50 51 typedef struct IOMMUTLBEntry IOMMUTLBEntry; 52 53 /* See address_space_translate: bit 0 is read, bit 1 is write. */ 54 typedef enum { 55 IOMMU_NONE = 0, 56 IOMMU_RO = 1, 57 IOMMU_WO = 2, 58 IOMMU_RW = 3, 59 } IOMMUAccessFlags; 60 61 struct IOMMUTLBEntry { 62 AddressSpace *target_as; 63 hwaddr iova; 64 hwaddr translated_addr; 65 hwaddr addr_mask; /* 0xfff = 4k translation */ 66 IOMMUAccessFlags perm; 67 }; 68 69 /* New-style MMIO accessors can indicate that the transaction failed. 70 * A zero (MEMTX_OK) response means success; anything else is a failure 71 * of some kind. The memory subsystem will bitwise-OR together results 72 * if it is synthesizing an operation from multiple smaller accesses. 73 */ 74 #define MEMTX_OK 0 75 #define MEMTX_ERROR (1U << 0) /* device returned an error */ 76 #define MEMTX_DECODE_ERROR (1U << 1) /* nothing at that address */ 77 typedef uint32_t MemTxResult; 78 79 /* 80 * Memory region callbacks 81 */ 82 struct MemoryRegionOps { 83 /* Read from the memory region. @addr is relative to @mr; @size is 84 * in bytes. */ 85 uint64_t (*read)(void *opaque, 86 hwaddr addr, 87 unsigned size); 88 /* Write to the memory region. @addr is relative to @mr; @size is 89 * in bytes. */ 90 void (*write)(void *opaque, 91 hwaddr addr, 92 uint64_t data, 93 unsigned size); 94 95 MemTxResult (*read_with_attrs)(void *opaque, 96 hwaddr addr, 97 uint64_t *data, 98 unsigned size, 99 MemTxAttrs attrs); 100 MemTxResult (*write_with_attrs)(void *opaque, 101 hwaddr addr, 102 uint64_t data, 103 unsigned size, 104 MemTxAttrs attrs); 105 106 enum device_endian endianness; 107 /* Guest-visible constraints: */ 108 struct { 109 /* If nonzero, specify bounds on access sizes beyond which a machine 110 * check is thrown. 111 */ 112 unsigned min_access_size; 113 unsigned max_access_size; 114 /* If true, unaligned accesses are supported. Otherwise unaligned 115 * accesses throw machine checks. 116 */ 117 bool unaligned; 118 /* 119 * If present, and returns #false, the transaction is not accepted 120 * by the device (and results in machine dependent behaviour such 121 * as a machine check exception). 122 */ 123 bool (*accepts)(void *opaque, hwaddr addr, 124 unsigned size, bool is_write); 125 } valid; 126 /* Internal implementation constraints: */ 127 struct { 128 /* If nonzero, specifies the minimum size implemented. Smaller sizes 129 * will be rounded upwards and a partial result will be returned. 130 */ 131 unsigned min_access_size; 132 /* If nonzero, specifies the maximum size implemented. Larger sizes 133 * will be done as a series of accesses with smaller sizes. 134 */ 135 unsigned max_access_size; 136 /* If true, unaligned accesses are supported. Otherwise all accesses 137 * are converted to (possibly multiple) naturally aligned accesses. 138 */ 139 bool unaligned; 140 } impl; 141 142 /* If .read and .write are not present, old_mmio may be used for 143 * backwards compatibility with old mmio registration 144 */ 145 const MemoryRegionMmio old_mmio; 146 }; 147 148 typedef struct MemoryRegionIOMMUOps MemoryRegionIOMMUOps; 149 150 struct MemoryRegionIOMMUOps { 151 /* Return a TLB entry that contains a given address. */ 152 IOMMUTLBEntry (*translate)(MemoryRegion *iommu, hwaddr addr, bool is_write); 153 }; 154 155 typedef struct CoalescedMemoryRange CoalescedMemoryRange; 156 typedef struct MemoryRegionIoeventfd MemoryRegionIoeventfd; 157 158 struct MemoryRegion { 159 Object parent_obj; 160 161 /* All fields are private - violators will be prosecuted */ 162 163 /* The following fields should fit in a cache line */ 164 bool romd_mode; 165 bool ram; 166 bool subpage; 167 bool readonly; /* For RAM regions */ 168 bool rom_device; 169 bool flush_coalesced_mmio; 170 bool global_locking; 171 uint8_t dirty_log_mask; 172 RAMBlock *ram_block; 173 Object *owner; 174 const MemoryRegionIOMMUOps *iommu_ops; 175 176 const MemoryRegionOps *ops; 177 void *opaque; 178 MemoryRegion *container; 179 Int128 size; 180 hwaddr addr; 181 void (*destructor)(MemoryRegion *mr); 182 uint64_t align; 183 bool terminates; 184 bool skip_dump; 185 bool enabled; 186 bool warning_printed; /* For reservations */ 187 uint8_t vga_logging_count; 188 MemoryRegion *alias; 189 hwaddr alias_offset; 190 int32_t priority; 191 bool may_overlap; 192 QTAILQ_HEAD(subregions, MemoryRegion) subregions; 193 QTAILQ_ENTRY(MemoryRegion) subregions_link; 194 QTAILQ_HEAD(coalesced_ranges, CoalescedMemoryRange) coalesced; 195 const char *name; 196 unsigned ioeventfd_nb; 197 MemoryRegionIoeventfd *ioeventfds; 198 NotifierList iommu_notify; 199 }; 200 201 /** 202 * MemoryListener: callbacks structure for updates to the physical memory map 203 * 204 * Allows a component to adjust to changes in the guest-visible memory map. 205 * Use with memory_listener_register() and memory_listener_unregister(). 206 */ 207 struct MemoryListener { 208 void (*begin)(MemoryListener *listener); 209 void (*commit)(MemoryListener *listener); 210 void (*region_add)(MemoryListener *listener, MemoryRegionSection *section); 211 void (*region_del)(MemoryListener *listener, MemoryRegionSection *section); 212 void (*region_nop)(MemoryListener *listener, MemoryRegionSection *section); 213 void (*log_start)(MemoryListener *listener, MemoryRegionSection *section, 214 int old, int new); 215 void (*log_stop)(MemoryListener *listener, MemoryRegionSection *section, 216 int old, int new); 217 void (*log_sync)(MemoryListener *listener, MemoryRegionSection *section); 218 void (*log_global_start)(MemoryListener *listener); 219 void (*log_global_stop)(MemoryListener *listener); 220 void (*eventfd_add)(MemoryListener *listener, MemoryRegionSection *section, 221 bool match_data, uint64_t data, EventNotifier *e); 222 void (*eventfd_del)(MemoryListener *listener, MemoryRegionSection *section, 223 bool match_data, uint64_t data, EventNotifier *e); 224 void (*coalesced_mmio_add)(MemoryListener *listener, MemoryRegionSection *section, 225 hwaddr addr, hwaddr len); 226 void (*coalesced_mmio_del)(MemoryListener *listener, MemoryRegionSection *section, 227 hwaddr addr, hwaddr len); 228 /* Lower = earlier (during add), later (during del) */ 229 unsigned priority; 230 AddressSpace *address_space_filter; 231 QTAILQ_ENTRY(MemoryListener) link; 232 }; 233 234 /** 235 * AddressSpace: describes a mapping of addresses to #MemoryRegion objects 236 */ 237 struct AddressSpace { 238 /* All fields are private. */ 239 struct rcu_head rcu; 240 char *name; 241 MemoryRegion *root; 242 int ref_count; 243 bool malloced; 244 245 /* Accessed via RCU. */ 246 struct FlatView *current_map; 247 248 int ioeventfd_nb; 249 struct MemoryRegionIoeventfd *ioeventfds; 250 struct AddressSpaceDispatch *dispatch; 251 struct AddressSpaceDispatch *next_dispatch; 252 MemoryListener dispatch_listener; 253 254 QTAILQ_ENTRY(AddressSpace) address_spaces_link; 255 }; 256 257 /** 258 * MemoryRegionSection: describes a fragment of a #MemoryRegion 259 * 260 * @mr: the region, or %NULL if empty 261 * @address_space: the address space the region is mapped in 262 * @offset_within_region: the beginning of the section, relative to @mr's start 263 * @size: the size of the section; will not exceed @mr's boundaries 264 * @offset_within_address_space: the address of the first byte of the section 265 * relative to the region's address space 266 * @readonly: writes to this section are ignored 267 */ 268 struct MemoryRegionSection { 269 MemoryRegion *mr; 270 AddressSpace *address_space; 271 hwaddr offset_within_region; 272 Int128 size; 273 hwaddr offset_within_address_space; 274 bool readonly; 275 }; 276 277 /** 278 * memory_region_init: Initialize a memory region 279 * 280 * The region typically acts as a container for other memory regions. Use 281 * memory_region_add_subregion() to add subregions. 282 * 283 * @mr: the #MemoryRegion to be initialized 284 * @owner: the object that tracks the region's reference count 285 * @name: used for debugging; not visible to the user or ABI 286 * @size: size of the region; any subregions beyond this size will be clipped 287 */ 288 void memory_region_init(MemoryRegion *mr, 289 struct Object *owner, 290 const char *name, 291 uint64_t size); 292 293 /** 294 * memory_region_ref: Add 1 to a memory region's reference count 295 * 296 * Whenever memory regions are accessed outside the BQL, they need to be 297 * preserved against hot-unplug. MemoryRegions actually do not have their 298 * own reference count; they piggyback on a QOM object, their "owner". 299 * This function adds a reference to the owner. 300 * 301 * All MemoryRegions must have an owner if they can disappear, even if the 302 * device they belong to operates exclusively under the BQL. This is because 303 * the region could be returned at any time by memory_region_find, and this 304 * is usually under guest control. 305 * 306 * @mr: the #MemoryRegion 307 */ 308 void memory_region_ref(MemoryRegion *mr); 309 310 /** 311 * memory_region_unref: Remove 1 to a memory region's reference count 312 * 313 * Whenever memory regions are accessed outside the BQL, they need to be 314 * preserved against hot-unplug. MemoryRegions actually do not have their 315 * own reference count; they piggyback on a QOM object, their "owner". 316 * This function removes a reference to the owner and possibly destroys it. 317 * 318 * @mr: the #MemoryRegion 319 */ 320 void memory_region_unref(MemoryRegion *mr); 321 322 /** 323 * memory_region_init_io: Initialize an I/O memory region. 324 * 325 * Accesses into the region will cause the callbacks in @ops to be called. 326 * if @size is nonzero, subregions will be clipped to @size. 327 * 328 * @mr: the #MemoryRegion to be initialized. 329 * @owner: the object that tracks the region's reference count 330 * @ops: a structure containing read and write callbacks to be used when 331 * I/O is performed on the region. 332 * @opaque: passed to the read and write callbacks of the @ops structure. 333 * @name: used for debugging; not visible to the user or ABI 334 * @size: size of the region. 335 */ 336 void memory_region_init_io(MemoryRegion *mr, 337 struct Object *owner, 338 const MemoryRegionOps *ops, 339 void *opaque, 340 const char *name, 341 uint64_t size); 342 343 /** 344 * memory_region_init_ram: Initialize RAM memory region. Accesses into the 345 * region will modify memory directly. 346 * 347 * @mr: the #MemoryRegion to be initialized. 348 * @owner: the object that tracks the region's reference count 349 * @name: the name of the region. 350 * @size: size of the region. 351 * @errp: pointer to Error*, to store an error if it happens. 352 */ 353 void memory_region_init_ram(MemoryRegion *mr, 354 struct Object *owner, 355 const char *name, 356 uint64_t size, 357 Error **errp); 358 359 /** 360 * memory_region_init_resizeable_ram: Initialize memory region with resizeable 361 * RAM. Accesses into the region will 362 * modify memory directly. Only an initial 363 * portion of this RAM is actually used. 364 * The used size can change across reboots. 365 * 366 * @mr: the #MemoryRegion to be initialized. 367 * @owner: the object that tracks the region's reference count 368 * @name: the name of the region. 369 * @size: used size of the region. 370 * @max_size: max size of the region. 371 * @resized: callback to notify owner about used size change. 372 * @errp: pointer to Error*, to store an error if it happens. 373 */ 374 void memory_region_init_resizeable_ram(MemoryRegion *mr, 375 struct Object *owner, 376 const char *name, 377 uint64_t size, 378 uint64_t max_size, 379 void (*resized)(const char*, 380 uint64_t length, 381 void *host), 382 Error **errp); 383 #ifdef __linux__ 384 /** 385 * memory_region_init_ram_from_file: Initialize RAM memory region with a 386 * mmap-ed backend. 387 * 388 * @mr: the #MemoryRegion to be initialized. 389 * @owner: the object that tracks the region's reference count 390 * @name: the name of the region. 391 * @size: size of the region. 392 * @share: %true if memory must be mmaped with the MAP_SHARED flag 393 * @path: the path in which to allocate the RAM. 394 * @errp: pointer to Error*, to store an error if it happens. 395 */ 396 void memory_region_init_ram_from_file(MemoryRegion *mr, 397 struct Object *owner, 398 const char *name, 399 uint64_t size, 400 bool share, 401 const char *path, 402 Error **errp); 403 #endif 404 405 /** 406 * memory_region_init_ram_ptr: Initialize RAM memory region from a 407 * user-provided pointer. Accesses into the 408 * region will modify memory directly. 409 * 410 * @mr: the #MemoryRegion to be initialized. 411 * @owner: the object that tracks the region's reference count 412 * @name: the name of the region. 413 * @size: size of the region. 414 * @ptr: memory to be mapped; must contain at least @size bytes. 415 */ 416 void memory_region_init_ram_ptr(MemoryRegion *mr, 417 struct Object *owner, 418 const char *name, 419 uint64_t size, 420 void *ptr); 421 422 /** 423 * memory_region_init_alias: Initialize a memory region that aliases all or a 424 * part of another memory region. 425 * 426 * @mr: the #MemoryRegion to be initialized. 427 * @owner: the object that tracks the region's reference count 428 * @name: used for debugging; not visible to the user or ABI 429 * @orig: the region to be referenced; @mr will be equivalent to 430 * @orig between @offset and @offset + @size - 1. 431 * @offset: start of the section in @orig to be referenced. 432 * @size: size of the region. 433 */ 434 void memory_region_init_alias(MemoryRegion *mr, 435 struct Object *owner, 436 const char *name, 437 MemoryRegion *orig, 438 hwaddr offset, 439 uint64_t size); 440 441 /** 442 * memory_region_init_rom_device: Initialize a ROM memory region. Writes are 443 * handled via callbacks. 444 * 445 * If NULL callbacks pointer is given, then I/O space is not supposed to be 446 * handled by QEMU itself. Any access via the memory API will cause an abort(). 447 * 448 * @mr: the #MemoryRegion to be initialized. 449 * @owner: the object that tracks the region's reference count 450 * @ops: callbacks for write access handling. 451 * @name: the name of the region. 452 * @size: size of the region. 453 * @errp: pointer to Error*, to store an error if it happens. 454 */ 455 void memory_region_init_rom_device(MemoryRegion *mr, 456 struct Object *owner, 457 const MemoryRegionOps *ops, 458 void *opaque, 459 const char *name, 460 uint64_t size, 461 Error **errp); 462 463 /** 464 * memory_region_init_reservation: Initialize a memory region that reserves 465 * I/O space. 466 * 467 * A reservation region primariy serves debugging purposes. It claims I/O 468 * space that is not supposed to be handled by QEMU itself. Any access via 469 * the memory API will cause an abort(). 470 * This function is deprecated. Use memory_region_init_io() with NULL 471 * callbacks instead. 472 * 473 * @mr: the #MemoryRegion to be initialized 474 * @owner: the object that tracks the region's reference count 475 * @name: used for debugging; not visible to the user or ABI 476 * @size: size of the region. 477 */ 478 static inline void memory_region_init_reservation(MemoryRegion *mr, 479 Object *owner, 480 const char *name, 481 uint64_t size) 482 { 483 memory_region_init_io(mr, owner, NULL, mr, name, size); 484 } 485 486 /** 487 * memory_region_init_iommu: Initialize a memory region that translates 488 * addresses 489 * 490 * An IOMMU region translates addresses and forwards accesses to a target 491 * memory region. 492 * 493 * @mr: the #MemoryRegion to be initialized 494 * @owner: the object that tracks the region's reference count 495 * @ops: a function that translates addresses into the @target region 496 * @name: used for debugging; not visible to the user or ABI 497 * @size: size of the region. 498 */ 499 void memory_region_init_iommu(MemoryRegion *mr, 500 struct Object *owner, 501 const MemoryRegionIOMMUOps *ops, 502 const char *name, 503 uint64_t size); 504 505 /** 506 * memory_region_owner: get a memory region's owner. 507 * 508 * @mr: the memory region being queried. 509 */ 510 struct Object *memory_region_owner(MemoryRegion *mr); 511 512 /** 513 * memory_region_size: get a memory region's size. 514 * 515 * @mr: the memory region being queried. 516 */ 517 uint64_t memory_region_size(MemoryRegion *mr); 518 519 /** 520 * memory_region_is_ram: check whether a memory region is random access 521 * 522 * Returns %true is a memory region is random access. 523 * 524 * @mr: the memory region being queried 525 */ 526 static inline bool memory_region_is_ram(MemoryRegion *mr) 527 { 528 return mr->ram; 529 } 530 531 /** 532 * memory_region_is_skip_dump: check whether a memory region should not be 533 * dumped 534 * 535 * Returns %true is a memory region should not be dumped(e.g. VFIO BAR MMAP). 536 * 537 * @mr: the memory region being queried 538 */ 539 bool memory_region_is_skip_dump(MemoryRegion *mr); 540 541 /** 542 * memory_region_set_skip_dump: Set skip_dump flag, dump will ignore this memory 543 * region 544 * 545 * @mr: the memory region being queried 546 */ 547 void memory_region_set_skip_dump(MemoryRegion *mr); 548 549 /** 550 * memory_region_is_romd: check whether a memory region is in ROMD mode 551 * 552 * Returns %true if a memory region is a ROM device and currently set to allow 553 * direct reads. 554 * 555 * @mr: the memory region being queried 556 */ 557 static inline bool memory_region_is_romd(MemoryRegion *mr) 558 { 559 return mr->rom_device && mr->romd_mode; 560 } 561 562 /** 563 * memory_region_is_iommu: check whether a memory region is an iommu 564 * 565 * Returns %true is a memory region is an iommu. 566 * 567 * @mr: the memory region being queried 568 */ 569 static inline bool memory_region_is_iommu(MemoryRegion *mr) 570 { 571 return mr->iommu_ops; 572 } 573 574 575 /** 576 * memory_region_notify_iommu: notify a change in an IOMMU translation entry. 577 * 578 * @mr: the memory region that was changed 579 * @entry: the new entry in the IOMMU translation table. The entry 580 * replaces all old entries for the same virtual I/O address range. 581 * Deleted entries have .@perm == 0. 582 */ 583 void memory_region_notify_iommu(MemoryRegion *mr, 584 IOMMUTLBEntry entry); 585 586 /** 587 * memory_region_register_iommu_notifier: register a notifier for changes to 588 * IOMMU translation entries. 589 * 590 * @mr: the memory region to observe 591 * @n: the notifier to be added; the notifier receives a pointer to an 592 * #IOMMUTLBEntry as the opaque value; the pointer ceases to be 593 * valid on exit from the notifier. 594 */ 595 void memory_region_register_iommu_notifier(MemoryRegion *mr, Notifier *n); 596 597 /** 598 * memory_region_iommu_replay: replay existing IOMMU translations to 599 * a notifier 600 * 601 * @mr: the memory region to observe 602 * @n: the notifier to which to replay iommu mappings 603 * @granularity: Minimum page granularity to replay notifications for 604 * @is_write: Whether to treat the replay as a translate "write" 605 * through the iommu 606 */ 607 void memory_region_iommu_replay(MemoryRegion *mr, Notifier *n, 608 hwaddr granularity, bool is_write); 609 610 /** 611 * memory_region_unregister_iommu_notifier: unregister a notifier for 612 * changes to IOMMU translation entries. 613 * 614 * @n: the notifier to be removed. 615 */ 616 void memory_region_unregister_iommu_notifier(Notifier *n); 617 618 /** 619 * memory_region_name: get a memory region's name 620 * 621 * Returns the string that was used to initialize the memory region. 622 * 623 * @mr: the memory region being queried 624 */ 625 const char *memory_region_name(const MemoryRegion *mr); 626 627 /** 628 * memory_region_is_logging: return whether a memory region is logging writes 629 * 630 * Returns %true if the memory region is logging writes for the given client 631 * 632 * @mr: the memory region being queried 633 * @client: the client being queried 634 */ 635 bool memory_region_is_logging(MemoryRegion *mr, uint8_t client); 636 637 /** 638 * memory_region_get_dirty_log_mask: return the clients for which a 639 * memory region is logging writes. 640 * 641 * Returns a bitmap of clients, in which the DIRTY_MEMORY_* constants 642 * are the bit indices. 643 * 644 * @mr: the memory region being queried 645 */ 646 uint8_t memory_region_get_dirty_log_mask(MemoryRegion *mr); 647 648 /** 649 * memory_region_is_rom: check whether a memory region is ROM 650 * 651 * Returns %true is a memory region is read-only memory. 652 * 653 * @mr: the memory region being queried 654 */ 655 static inline bool memory_region_is_rom(MemoryRegion *mr) 656 { 657 return mr->ram && mr->readonly; 658 } 659 660 661 /** 662 * memory_region_get_fd: Get a file descriptor backing a RAM memory region. 663 * 664 * Returns a file descriptor backing a file-based RAM memory region, 665 * or -1 if the region is not a file-based RAM memory region. 666 * 667 * @mr: the RAM or alias memory region being queried. 668 */ 669 int memory_region_get_fd(MemoryRegion *mr); 670 671 /** 672 * memory_region_get_ram_ptr: Get a pointer into a RAM memory region. 673 * 674 * Returns a host pointer to a RAM memory region (created with 675 * memory_region_init_ram() or memory_region_init_ram_ptr()). 676 * 677 * Use with care; by the time this function returns, the returned pointer is 678 * not protected by RCU anymore. If the caller is not within an RCU critical 679 * section and does not hold the iothread lock, it must have other means of 680 * protecting the pointer, such as a reference to the region that includes 681 * the incoming ram_addr_t. 682 * 683 * @mr: the memory region being queried. 684 */ 685 void *memory_region_get_ram_ptr(MemoryRegion *mr); 686 687 /* memory_region_ram_resize: Resize a RAM region. 688 * 689 * Only legal before guest might have detected the memory size: e.g. on 690 * incoming migration, or right after reset. 691 * 692 * @mr: a memory region created with @memory_region_init_resizeable_ram. 693 * @newsize: the new size the region 694 * @errp: pointer to Error*, to store an error if it happens. 695 */ 696 void memory_region_ram_resize(MemoryRegion *mr, ram_addr_t newsize, 697 Error **errp); 698 699 /** 700 * memory_region_set_log: Turn dirty logging on or off for a region. 701 * 702 * Turns dirty logging on or off for a specified client (display, migration). 703 * Only meaningful for RAM regions. 704 * 705 * @mr: the memory region being updated. 706 * @log: whether dirty logging is to be enabled or disabled. 707 * @client: the user of the logging information; %DIRTY_MEMORY_VGA only. 708 */ 709 void memory_region_set_log(MemoryRegion *mr, bool log, unsigned client); 710 711 /** 712 * memory_region_get_dirty: Check whether a range of bytes is dirty 713 * for a specified client. 714 * 715 * Checks whether a range of bytes has been written to since the last 716 * call to memory_region_reset_dirty() with the same @client. Dirty logging 717 * must be enabled. 718 * 719 * @mr: the memory region being queried. 720 * @addr: the address (relative to the start of the region) being queried. 721 * @size: the size of the range being queried. 722 * @client: the user of the logging information; %DIRTY_MEMORY_MIGRATION or 723 * %DIRTY_MEMORY_VGA. 724 */ 725 bool memory_region_get_dirty(MemoryRegion *mr, hwaddr addr, 726 hwaddr size, unsigned client); 727 728 /** 729 * memory_region_set_dirty: Mark a range of bytes as dirty in a memory region. 730 * 731 * Marks a range of bytes as dirty, after it has been dirtied outside 732 * guest code. 733 * 734 * @mr: the memory region being dirtied. 735 * @addr: the address (relative to the start of the region) being dirtied. 736 * @size: size of the range being dirtied. 737 */ 738 void memory_region_set_dirty(MemoryRegion *mr, hwaddr addr, 739 hwaddr size); 740 741 /** 742 * memory_region_test_and_clear_dirty: Check whether a range of bytes is dirty 743 * for a specified client. It clears them. 744 * 745 * Checks whether a range of bytes has been written to since the last 746 * call to memory_region_reset_dirty() with the same @client. Dirty logging 747 * must be enabled. 748 * 749 * @mr: the memory region being queried. 750 * @addr: the address (relative to the start of the region) being queried. 751 * @size: the size of the range being queried. 752 * @client: the user of the logging information; %DIRTY_MEMORY_MIGRATION or 753 * %DIRTY_MEMORY_VGA. 754 */ 755 bool memory_region_test_and_clear_dirty(MemoryRegion *mr, hwaddr addr, 756 hwaddr size, unsigned client); 757 /** 758 * memory_region_sync_dirty_bitmap: Synchronize a region's dirty bitmap with 759 * any external TLBs (e.g. kvm) 760 * 761 * Flushes dirty information from accelerators such as kvm and vhost-net 762 * and makes it available to users of the memory API. 763 * 764 * @mr: the region being flushed. 765 */ 766 void memory_region_sync_dirty_bitmap(MemoryRegion *mr); 767 768 /** 769 * memory_region_reset_dirty: Mark a range of pages as clean, for a specified 770 * client. 771 * 772 * Marks a range of pages as no longer dirty. 773 * 774 * @mr: the region being updated. 775 * @addr: the start of the subrange being cleaned. 776 * @size: the size of the subrange being cleaned. 777 * @client: the user of the logging information; %DIRTY_MEMORY_MIGRATION or 778 * %DIRTY_MEMORY_VGA. 779 */ 780 void memory_region_reset_dirty(MemoryRegion *mr, hwaddr addr, 781 hwaddr size, unsigned client); 782 783 /** 784 * memory_region_set_readonly: Turn a memory region read-only (or read-write) 785 * 786 * Allows a memory region to be marked as read-only (turning it into a ROM). 787 * only useful on RAM regions. 788 * 789 * @mr: the region being updated. 790 * @readonly: whether rhe region is to be ROM or RAM. 791 */ 792 void memory_region_set_readonly(MemoryRegion *mr, bool readonly); 793 794 /** 795 * memory_region_rom_device_set_romd: enable/disable ROMD mode 796 * 797 * Allows a ROM device (initialized with memory_region_init_rom_device() to 798 * set to ROMD mode (default) or MMIO mode. When it is in ROMD mode, the 799 * device is mapped to guest memory and satisfies read access directly. 800 * When in MMIO mode, reads are forwarded to the #MemoryRegion.read function. 801 * Writes are always handled by the #MemoryRegion.write function. 802 * 803 * @mr: the memory region to be updated 804 * @romd_mode: %true to put the region into ROMD mode 805 */ 806 void memory_region_rom_device_set_romd(MemoryRegion *mr, bool romd_mode); 807 808 /** 809 * memory_region_set_coalescing: Enable memory coalescing for the region. 810 * 811 * Enabled writes to a region to be queued for later processing. MMIO ->write 812 * callbacks may be delayed until a non-coalesced MMIO is issued. 813 * Only useful for IO regions. Roughly similar to write-combining hardware. 814 * 815 * @mr: the memory region to be write coalesced 816 */ 817 void memory_region_set_coalescing(MemoryRegion *mr); 818 819 /** 820 * memory_region_add_coalescing: Enable memory coalescing for a sub-range of 821 * a region. 822 * 823 * Like memory_region_set_coalescing(), but works on a sub-range of a region. 824 * Multiple calls can be issued coalesced disjoint ranges. 825 * 826 * @mr: the memory region to be updated. 827 * @offset: the start of the range within the region to be coalesced. 828 * @size: the size of the subrange to be coalesced. 829 */ 830 void memory_region_add_coalescing(MemoryRegion *mr, 831 hwaddr offset, 832 uint64_t size); 833 834 /** 835 * memory_region_clear_coalescing: Disable MMIO coalescing for the region. 836 * 837 * Disables any coalescing caused by memory_region_set_coalescing() or 838 * memory_region_add_coalescing(). Roughly equivalent to uncacheble memory 839 * hardware. 840 * 841 * @mr: the memory region to be updated. 842 */ 843 void memory_region_clear_coalescing(MemoryRegion *mr); 844 845 /** 846 * memory_region_set_flush_coalesced: Enforce memory coalescing flush before 847 * accesses. 848 * 849 * Ensure that pending coalesced MMIO request are flushed before the memory 850 * region is accessed. This property is automatically enabled for all regions 851 * passed to memory_region_set_coalescing() and memory_region_add_coalescing(). 852 * 853 * @mr: the memory region to be updated. 854 */ 855 void memory_region_set_flush_coalesced(MemoryRegion *mr); 856 857 /** 858 * memory_region_clear_flush_coalesced: Disable memory coalescing flush before 859 * accesses. 860 * 861 * Clear the automatic coalesced MMIO flushing enabled via 862 * memory_region_set_flush_coalesced. Note that this service has no effect on 863 * memory regions that have MMIO coalescing enabled for themselves. For them, 864 * automatic flushing will stop once coalescing is disabled. 865 * 866 * @mr: the memory region to be updated. 867 */ 868 void memory_region_clear_flush_coalesced(MemoryRegion *mr); 869 870 /** 871 * memory_region_set_global_locking: Declares the access processing requires 872 * QEMU's global lock. 873 * 874 * When this is invoked, accesses to the memory region will be processed while 875 * holding the global lock of QEMU. This is the default behavior of memory 876 * regions. 877 * 878 * @mr: the memory region to be updated. 879 */ 880 void memory_region_set_global_locking(MemoryRegion *mr); 881 882 /** 883 * memory_region_clear_global_locking: Declares that access processing does 884 * not depend on the QEMU global lock. 885 * 886 * By clearing this property, accesses to the memory region will be processed 887 * outside of QEMU's global lock (unless the lock is held on when issuing the 888 * access request). In this case, the device model implementing the access 889 * handlers is responsible for synchronization of concurrency. 890 * 891 * @mr: the memory region to be updated. 892 */ 893 void memory_region_clear_global_locking(MemoryRegion *mr); 894 895 /** 896 * memory_region_add_eventfd: Request an eventfd to be triggered when a word 897 * is written to a location. 898 * 899 * Marks a word in an IO region (initialized with memory_region_init_io()) 900 * as a trigger for an eventfd event. The I/O callback will not be called. 901 * The caller must be prepared to handle failure (that is, take the required 902 * action if the callback _is_ called). 903 * 904 * @mr: the memory region being updated. 905 * @addr: the address within @mr that is to be monitored 906 * @size: the size of the access to trigger the eventfd 907 * @match_data: whether to match against @data, instead of just @addr 908 * @data: the data to match against the guest write 909 * @fd: the eventfd to be triggered when @addr, @size, and @data all match. 910 **/ 911 void memory_region_add_eventfd(MemoryRegion *mr, 912 hwaddr addr, 913 unsigned size, 914 bool match_data, 915 uint64_t data, 916 EventNotifier *e); 917 918 /** 919 * memory_region_del_eventfd: Cancel an eventfd. 920 * 921 * Cancels an eventfd trigger requested by a previous 922 * memory_region_add_eventfd() call. 923 * 924 * @mr: the memory region being updated. 925 * @addr: the address within @mr that is to be monitored 926 * @size: the size of the access to trigger the eventfd 927 * @match_data: whether to match against @data, instead of just @addr 928 * @data: the data to match against the guest write 929 * @fd: the eventfd to be triggered when @addr, @size, and @data all match. 930 */ 931 void memory_region_del_eventfd(MemoryRegion *mr, 932 hwaddr addr, 933 unsigned size, 934 bool match_data, 935 uint64_t data, 936 EventNotifier *e); 937 938 /** 939 * memory_region_add_subregion: Add a subregion to a container. 940 * 941 * Adds a subregion at @offset. The subregion may not overlap with other 942 * subregions (except for those explicitly marked as overlapping). A region 943 * may only be added once as a subregion (unless removed with 944 * memory_region_del_subregion()); use memory_region_init_alias() if you 945 * want a region to be a subregion in multiple locations. 946 * 947 * @mr: the region to contain the new subregion; must be a container 948 * initialized with memory_region_init(). 949 * @offset: the offset relative to @mr where @subregion is added. 950 * @subregion: the subregion to be added. 951 */ 952 void memory_region_add_subregion(MemoryRegion *mr, 953 hwaddr offset, 954 MemoryRegion *subregion); 955 /** 956 * memory_region_add_subregion_overlap: Add a subregion to a container 957 * with overlap. 958 * 959 * Adds a subregion at @offset. The subregion may overlap with other 960 * subregions. Conflicts are resolved by having a higher @priority hide a 961 * lower @priority. Subregions without priority are taken as @priority 0. 962 * A region may only be added once as a subregion (unless removed with 963 * memory_region_del_subregion()); use memory_region_init_alias() if you 964 * want a region to be a subregion in multiple locations. 965 * 966 * @mr: the region to contain the new subregion; must be a container 967 * initialized with memory_region_init(). 968 * @offset: the offset relative to @mr where @subregion is added. 969 * @subregion: the subregion to be added. 970 * @priority: used for resolving overlaps; highest priority wins. 971 */ 972 void memory_region_add_subregion_overlap(MemoryRegion *mr, 973 hwaddr offset, 974 MemoryRegion *subregion, 975 int priority); 976 977 /** 978 * memory_region_get_ram_addr: Get the ram address associated with a memory 979 * region 980 */ 981 ram_addr_t memory_region_get_ram_addr(MemoryRegion *mr); 982 983 uint64_t memory_region_get_alignment(const MemoryRegion *mr); 984 /** 985 * memory_region_del_subregion: Remove a subregion. 986 * 987 * Removes a subregion from its container. 988 * 989 * @mr: the container to be updated. 990 * @subregion: the region being removed; must be a current subregion of @mr. 991 */ 992 void memory_region_del_subregion(MemoryRegion *mr, 993 MemoryRegion *subregion); 994 995 /* 996 * memory_region_set_enabled: dynamically enable or disable a region 997 * 998 * Enables or disables a memory region. A disabled memory region 999 * ignores all accesses to itself and its subregions. It does not 1000 * obscure sibling subregions with lower priority - it simply behaves as 1001 * if it was removed from the hierarchy. 1002 * 1003 * Regions default to being enabled. 1004 * 1005 * @mr: the region to be updated 1006 * @enabled: whether to enable or disable the region 1007 */ 1008 void memory_region_set_enabled(MemoryRegion *mr, bool enabled); 1009 1010 /* 1011 * memory_region_set_address: dynamically update the address of a region 1012 * 1013 * Dynamically updates the address of a region, relative to its container. 1014 * May be used on regions are currently part of a memory hierarchy. 1015 * 1016 * @mr: the region to be updated 1017 * @addr: new address, relative to container region 1018 */ 1019 void memory_region_set_address(MemoryRegion *mr, hwaddr addr); 1020 1021 /* 1022 * memory_region_set_size: dynamically update the size of a region. 1023 * 1024 * Dynamically updates the size of a region. 1025 * 1026 * @mr: the region to be updated 1027 * @size: used size of the region. 1028 */ 1029 void memory_region_set_size(MemoryRegion *mr, uint64_t size); 1030 1031 /* 1032 * memory_region_set_alias_offset: dynamically update a memory alias's offset 1033 * 1034 * Dynamically updates the offset into the target region that an alias points 1035 * to, as if the fourth argument to memory_region_init_alias() has changed. 1036 * 1037 * @mr: the #MemoryRegion to be updated; should be an alias. 1038 * @offset: the new offset into the target memory region 1039 */ 1040 void memory_region_set_alias_offset(MemoryRegion *mr, 1041 hwaddr offset); 1042 1043 /** 1044 * memory_region_present: checks if an address relative to a @container 1045 * translates into #MemoryRegion within @container 1046 * 1047 * Answer whether a #MemoryRegion within @container covers the address 1048 * @addr. 1049 * 1050 * @container: a #MemoryRegion within which @addr is a relative address 1051 * @addr: the area within @container to be searched 1052 */ 1053 bool memory_region_present(MemoryRegion *container, hwaddr addr); 1054 1055 /** 1056 * memory_region_is_mapped: returns true if #MemoryRegion is mapped 1057 * into any address space. 1058 * 1059 * @mr: a #MemoryRegion which should be checked if it's mapped 1060 */ 1061 bool memory_region_is_mapped(MemoryRegion *mr); 1062 1063 /** 1064 * memory_region_find: translate an address/size relative to a 1065 * MemoryRegion into a #MemoryRegionSection. 1066 * 1067 * Locates the first #MemoryRegion within @mr that overlaps the range 1068 * given by @addr and @size. 1069 * 1070 * Returns a #MemoryRegionSection that describes a contiguous overlap. 1071 * It will have the following characteristics: 1072 * .@size = 0 iff no overlap was found 1073 * .@mr is non-%NULL iff an overlap was found 1074 * 1075 * Remember that in the return value the @offset_within_region is 1076 * relative to the returned region (in the .@mr field), not to the 1077 * @mr argument. 1078 * 1079 * Similarly, the .@offset_within_address_space is relative to the 1080 * address space that contains both regions, the passed and the 1081 * returned one. However, in the special case where the @mr argument 1082 * has no container (and thus is the root of the address space), the 1083 * following will hold: 1084 * .@offset_within_address_space >= @addr 1085 * .@offset_within_address_space + .@size <= @addr + @size 1086 * 1087 * @mr: a MemoryRegion within which @addr is a relative address 1088 * @addr: start of the area within @as to be searched 1089 * @size: size of the area to be searched 1090 */ 1091 MemoryRegionSection memory_region_find(MemoryRegion *mr, 1092 hwaddr addr, uint64_t size); 1093 1094 /** 1095 * address_space_sync_dirty_bitmap: synchronize the dirty log for all memory 1096 * 1097 * Synchronizes the dirty page log for an entire address space. 1098 * @as: the address space that contains the memory being synchronized 1099 */ 1100 void address_space_sync_dirty_bitmap(AddressSpace *as); 1101 1102 /** 1103 * memory_region_transaction_begin: Start a transaction. 1104 * 1105 * During a transaction, changes will be accumulated and made visible 1106 * only when the transaction ends (is committed). 1107 */ 1108 void memory_region_transaction_begin(void); 1109 1110 /** 1111 * memory_region_transaction_commit: Commit a transaction and make changes 1112 * visible to the guest. 1113 */ 1114 void memory_region_transaction_commit(void); 1115 1116 /** 1117 * memory_listener_register: register callbacks to be called when memory 1118 * sections are mapped or unmapped into an address 1119 * space 1120 * 1121 * @listener: an object containing the callbacks to be called 1122 * @filter: if non-%NULL, only regions in this address space will be observed 1123 */ 1124 void memory_listener_register(MemoryListener *listener, AddressSpace *filter); 1125 1126 /** 1127 * memory_listener_unregister: undo the effect of memory_listener_register() 1128 * 1129 * @listener: an object containing the callbacks to be removed 1130 */ 1131 void memory_listener_unregister(MemoryListener *listener); 1132 1133 /** 1134 * memory_global_dirty_log_start: begin dirty logging for all regions 1135 */ 1136 void memory_global_dirty_log_start(void); 1137 1138 /** 1139 * memory_global_dirty_log_stop: end dirty logging for all regions 1140 */ 1141 void memory_global_dirty_log_stop(void); 1142 1143 void mtree_info(fprintf_function mon_printf, void *f); 1144 1145 /** 1146 * memory_region_dispatch_read: perform a read directly to the specified 1147 * MemoryRegion. 1148 * 1149 * @mr: #MemoryRegion to access 1150 * @addr: address within that region 1151 * @pval: pointer to uint64_t which the data is written to 1152 * @size: size of the access in bytes 1153 * @attrs: memory transaction attributes to use for the access 1154 */ 1155 MemTxResult memory_region_dispatch_read(MemoryRegion *mr, 1156 hwaddr addr, 1157 uint64_t *pval, 1158 unsigned size, 1159 MemTxAttrs attrs); 1160 /** 1161 * memory_region_dispatch_write: perform a write directly to the specified 1162 * MemoryRegion. 1163 * 1164 * @mr: #MemoryRegion to access 1165 * @addr: address within that region 1166 * @data: data to write 1167 * @size: size of the access in bytes 1168 * @attrs: memory transaction attributes to use for the access 1169 */ 1170 MemTxResult memory_region_dispatch_write(MemoryRegion *mr, 1171 hwaddr addr, 1172 uint64_t data, 1173 unsigned size, 1174 MemTxAttrs attrs); 1175 1176 /** 1177 * address_space_init: initializes an address space 1178 * 1179 * @as: an uninitialized #AddressSpace 1180 * @root: a #MemoryRegion that routes addresses for the address space 1181 * @name: an address space name. The name is only used for debugging 1182 * output. 1183 */ 1184 void address_space_init(AddressSpace *as, MemoryRegion *root, const char *name); 1185 1186 /** 1187 * address_space_init_shareable: return an address space for a memory region, 1188 * creating it if it does not already exist 1189 * 1190 * @root: a #MemoryRegion that routes addresses for the address space 1191 * @name: an address space name. The name is only used for debugging 1192 * output. 1193 * 1194 * This function will return a pointer to an existing AddressSpace 1195 * which was initialized with the specified MemoryRegion, or it will 1196 * create and initialize one if it does not already exist. The ASes 1197 * are reference-counted, so the memory will be freed automatically 1198 * when the AddressSpace is destroyed via address_space_destroy. 1199 */ 1200 AddressSpace *address_space_init_shareable(MemoryRegion *root, 1201 const char *name); 1202 1203 /** 1204 * address_space_destroy: destroy an address space 1205 * 1206 * Releases all resources associated with an address space. After an address space 1207 * is destroyed, its root memory region (given by address_space_init()) may be destroyed 1208 * as well. 1209 * 1210 * @as: address space to be destroyed 1211 */ 1212 void address_space_destroy(AddressSpace *as); 1213 1214 /** 1215 * address_space_rw: read from or write to an address space. 1216 * 1217 * Return a MemTxResult indicating whether the operation succeeded 1218 * or failed (eg unassigned memory, device rejected the transaction, 1219 * IOMMU fault). 1220 * 1221 * @as: #AddressSpace to be accessed 1222 * @addr: address within that address space 1223 * @attrs: memory transaction attributes 1224 * @buf: buffer with the data transferred 1225 * @is_write: indicates the transfer direction 1226 */ 1227 MemTxResult address_space_rw(AddressSpace *as, hwaddr addr, 1228 MemTxAttrs attrs, uint8_t *buf, 1229 int len, bool is_write); 1230 1231 /** 1232 * address_space_write: write to address space. 1233 * 1234 * Return a MemTxResult indicating whether the operation succeeded 1235 * or failed (eg unassigned memory, device rejected the transaction, 1236 * IOMMU fault). 1237 * 1238 * @as: #AddressSpace to be accessed 1239 * @addr: address within that address space 1240 * @attrs: memory transaction attributes 1241 * @buf: buffer with the data transferred 1242 */ 1243 MemTxResult address_space_write(AddressSpace *as, hwaddr addr, 1244 MemTxAttrs attrs, 1245 const uint8_t *buf, int len); 1246 1247 /* address_space_ld*: load from an address space 1248 * address_space_st*: store to an address space 1249 * 1250 * These functions perform a load or store of the byte, word, 1251 * longword or quad to the specified address within the AddressSpace. 1252 * The _le suffixed functions treat the data as little endian; 1253 * _be indicates big endian; no suffix indicates "same endianness 1254 * as guest CPU". 1255 * 1256 * The "guest CPU endianness" accessors are deprecated for use outside 1257 * target-* code; devices should be CPU-agnostic and use either the LE 1258 * or the BE accessors. 1259 * 1260 * @as #AddressSpace to be accessed 1261 * @addr: address within that address space 1262 * @val: data value, for stores 1263 * @attrs: memory transaction attributes 1264 * @result: location to write the success/failure of the transaction; 1265 * if NULL, this information is discarded 1266 */ 1267 uint32_t address_space_ldub(AddressSpace *as, hwaddr addr, 1268 MemTxAttrs attrs, MemTxResult *result); 1269 uint32_t address_space_lduw_le(AddressSpace *as, hwaddr addr, 1270 MemTxAttrs attrs, MemTxResult *result); 1271 uint32_t address_space_lduw_be(AddressSpace *as, hwaddr addr, 1272 MemTxAttrs attrs, MemTxResult *result); 1273 uint32_t address_space_ldl_le(AddressSpace *as, hwaddr addr, 1274 MemTxAttrs attrs, MemTxResult *result); 1275 uint32_t address_space_ldl_be(AddressSpace *as, hwaddr addr, 1276 MemTxAttrs attrs, MemTxResult *result); 1277 uint64_t address_space_ldq_le(AddressSpace *as, hwaddr addr, 1278 MemTxAttrs attrs, MemTxResult *result); 1279 uint64_t address_space_ldq_be(AddressSpace *as, hwaddr addr, 1280 MemTxAttrs attrs, MemTxResult *result); 1281 void address_space_stb(AddressSpace *as, hwaddr addr, uint32_t val, 1282 MemTxAttrs attrs, MemTxResult *result); 1283 void address_space_stw_le(AddressSpace *as, hwaddr addr, uint32_t val, 1284 MemTxAttrs attrs, MemTxResult *result); 1285 void address_space_stw_be(AddressSpace *as, hwaddr addr, uint32_t val, 1286 MemTxAttrs attrs, MemTxResult *result); 1287 void address_space_stl_le(AddressSpace *as, hwaddr addr, uint32_t val, 1288 MemTxAttrs attrs, MemTxResult *result); 1289 void address_space_stl_be(AddressSpace *as, hwaddr addr, uint32_t val, 1290 MemTxAttrs attrs, MemTxResult *result); 1291 void address_space_stq_le(AddressSpace *as, hwaddr addr, uint64_t val, 1292 MemTxAttrs attrs, MemTxResult *result); 1293 void address_space_stq_be(AddressSpace *as, hwaddr addr, uint64_t val, 1294 MemTxAttrs attrs, MemTxResult *result); 1295 1296 #ifdef NEED_CPU_H 1297 uint32_t address_space_lduw(AddressSpace *as, hwaddr addr, 1298 MemTxAttrs attrs, MemTxResult *result); 1299 uint32_t address_space_ldl(AddressSpace *as, hwaddr addr, 1300 MemTxAttrs attrs, MemTxResult *result); 1301 uint64_t address_space_ldq(AddressSpace *as, hwaddr addr, 1302 MemTxAttrs attrs, MemTxResult *result); 1303 void address_space_stl_notdirty(AddressSpace *as, hwaddr addr, uint32_t val, 1304 MemTxAttrs attrs, MemTxResult *result); 1305 void address_space_stw(AddressSpace *as, hwaddr addr, uint32_t val, 1306 MemTxAttrs attrs, MemTxResult *result); 1307 void address_space_stl(AddressSpace *as, hwaddr addr, uint32_t val, 1308 MemTxAttrs attrs, MemTxResult *result); 1309 void address_space_stq(AddressSpace *as, hwaddr addr, uint64_t val, 1310 MemTxAttrs attrs, MemTxResult *result); 1311 #endif 1312 1313 /* address_space_translate: translate an address range into an address space 1314 * into a MemoryRegion and an address range into that section. Should be 1315 * called from an RCU critical section, to avoid that the last reference 1316 * to the returned region disappears after address_space_translate returns. 1317 * 1318 * @as: #AddressSpace to be accessed 1319 * @addr: address within that address space 1320 * @xlat: pointer to address within the returned memory region section's 1321 * #MemoryRegion. 1322 * @len: pointer to length 1323 * @is_write: indicates the transfer direction 1324 */ 1325 MemoryRegion *address_space_translate(AddressSpace *as, hwaddr addr, 1326 hwaddr *xlat, hwaddr *len, 1327 bool is_write); 1328 1329 /* address_space_access_valid: check for validity of accessing an address 1330 * space range 1331 * 1332 * Check whether memory is assigned to the given address space range, and 1333 * access is permitted by any IOMMU regions that are active for the address 1334 * space. 1335 * 1336 * For now, addr and len should be aligned to a page size. This limitation 1337 * will be lifted in the future. 1338 * 1339 * @as: #AddressSpace to be accessed 1340 * @addr: address within that address space 1341 * @len: length of the area to be checked 1342 * @is_write: indicates the transfer direction 1343 */ 1344 bool address_space_access_valid(AddressSpace *as, hwaddr addr, int len, bool is_write); 1345 1346 /* address_space_map: map a physical memory region into a host virtual address 1347 * 1348 * May map a subset of the requested range, given by and returned in @plen. 1349 * May return %NULL if resources needed to perform the mapping are exhausted. 1350 * Use only for reads OR writes - not for read-modify-write operations. 1351 * Use cpu_register_map_client() to know when retrying the map operation is 1352 * likely to succeed. 1353 * 1354 * @as: #AddressSpace to be accessed 1355 * @addr: address within that address space 1356 * @plen: pointer to length of buffer; updated on return 1357 * @is_write: indicates the transfer direction 1358 */ 1359 void *address_space_map(AddressSpace *as, hwaddr addr, 1360 hwaddr *plen, bool is_write); 1361 1362 /* address_space_unmap: Unmaps a memory region previously mapped by address_space_map() 1363 * 1364 * Will also mark the memory as dirty if @is_write == %true. @access_len gives 1365 * the amount of memory that was actually read or written by the caller. 1366 * 1367 * @as: #AddressSpace used 1368 * @addr: address within that address space 1369 * @len: buffer length as returned by address_space_map() 1370 * @access_len: amount of data actually transferred 1371 * @is_write: indicates the transfer direction 1372 */ 1373 void address_space_unmap(AddressSpace *as, void *buffer, hwaddr len, 1374 int is_write, hwaddr access_len); 1375 1376 1377 /* Internal functions, part of the implementation of address_space_read. */ 1378 MemTxResult address_space_read_continue(AddressSpace *as, hwaddr addr, 1379 MemTxAttrs attrs, uint8_t *buf, 1380 int len, hwaddr addr1, hwaddr l, 1381 MemoryRegion *mr); 1382 MemTxResult address_space_read_full(AddressSpace *as, hwaddr addr, 1383 MemTxAttrs attrs, uint8_t *buf, int len); 1384 void *qemu_get_ram_ptr(RAMBlock *ram_block, ram_addr_t addr); 1385 1386 static inline bool memory_access_is_direct(MemoryRegion *mr, bool is_write) 1387 { 1388 if (is_write) { 1389 return memory_region_is_ram(mr) && !mr->readonly; 1390 } else { 1391 return memory_region_is_ram(mr) || memory_region_is_romd(mr); 1392 } 1393 } 1394 1395 /** 1396 * address_space_read: read from an address space. 1397 * 1398 * Return a MemTxResult indicating whether the operation succeeded 1399 * or failed (eg unassigned memory, device rejected the transaction, 1400 * IOMMU fault). 1401 * 1402 * @as: #AddressSpace to be accessed 1403 * @addr: address within that address space 1404 * @attrs: memory transaction attributes 1405 * @buf: buffer with the data transferred 1406 */ 1407 static inline __attribute__((__always_inline__)) 1408 MemTxResult address_space_read(AddressSpace *as, hwaddr addr, MemTxAttrs attrs, 1409 uint8_t *buf, int len) 1410 { 1411 MemTxResult result = MEMTX_OK; 1412 hwaddr l, addr1; 1413 void *ptr; 1414 MemoryRegion *mr; 1415 1416 if (__builtin_constant_p(len)) { 1417 if (len) { 1418 rcu_read_lock(); 1419 l = len; 1420 mr = address_space_translate(as, addr, &addr1, &l, false); 1421 if (len == l && memory_access_is_direct(mr, false)) { 1422 addr1 += memory_region_get_ram_addr(mr); 1423 ptr = qemu_get_ram_ptr(mr->ram_block, addr1); 1424 memcpy(buf, ptr, len); 1425 } else { 1426 result = address_space_read_continue(as, addr, attrs, buf, len, 1427 addr1, l, mr); 1428 } 1429 rcu_read_unlock(); 1430 } 1431 } else { 1432 result = address_space_read_full(as, addr, attrs, buf, len); 1433 } 1434 return result; 1435 } 1436 1437 #endif 1438 1439 #endif 1440