1 /* 2 * Declarations for functions which are internal to the memory subsystem. 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 or 10 * later. See the COPYING file in the top-level directory. 11 * 12 */ 13 14 /* 15 * This header is for use by exec.c, memory.c and accel/tcg/cputlb.c ONLY, 16 * for declarations which are shared between the memory subsystem's 17 * internals and the TCG TLB code. Do not include it from elsewhere. 18 */ 19 20 #ifndef MEMORY_INTERNAL_H 21 #define MEMORY_INTERNAL_H 22 23 #ifndef CONFIG_USER_ONLY 24 static inline AddressSpaceDispatch *flatview_to_dispatch(FlatView *fv) 25 { 26 return fv->dispatch; 27 } 28 29 static inline AddressSpaceDispatch *address_space_to_dispatch(AddressSpace *as) 30 { 31 return flatview_to_dispatch(address_space_to_flatview(as)); 32 } 33 34 FlatView *address_space_get_flatview(AddressSpace *as); 35 void flatview_unref(FlatView *view); 36 37 extern const MemoryRegionOps unassigned_mem_ops; 38 39 bool memory_region_access_valid(MemoryRegion *mr, hwaddr addr, 40 unsigned size, bool is_write, 41 MemTxAttrs attrs); 42 43 void flatview_add_to_dispatch(FlatView *fv, MemoryRegionSection *section); 44 AddressSpaceDispatch *address_space_dispatch_new(FlatView *fv); 45 void address_space_dispatch_compact(AddressSpaceDispatch *d); 46 void address_space_dispatch_free(AddressSpaceDispatch *d); 47 48 void mtree_print_dispatch(fprintf_function mon, void *f, 49 struct AddressSpaceDispatch *d, 50 MemoryRegion *root); 51 52 struct page_collection; 53 54 /* Opaque struct for passing info from memory_notdirty_write_prepare() 55 * to memory_notdirty_write_complete(). Callers should treat all fields 56 * as private, with the exception of @active. 57 * 58 * @active is a field which is not touched by either the prepare or 59 * complete functions, but which the caller can use if it wishes to 60 * track whether it has called prepare for this struct and so needs 61 * to later call the complete function. 62 */ 63 typedef struct { 64 CPUState *cpu; 65 struct page_collection *pages; 66 ram_addr_t ram_addr; 67 vaddr mem_vaddr; 68 unsigned size; 69 bool active; 70 } NotDirtyInfo; 71 72 /** 73 * memory_notdirty_write_prepare: call before writing to non-dirty memory 74 * @ndi: pointer to opaque NotDirtyInfo struct 75 * @cpu: CPU doing the write 76 * @mem_vaddr: virtual address of write 77 * @ram_addr: the ram address of the write 78 * @size: size of write in bytes 79 * 80 * Any code which writes to the host memory corresponding to 81 * guest RAM which has been marked as NOTDIRTY must wrap those 82 * writes in calls to memory_notdirty_write_prepare() and 83 * memory_notdirty_write_complete(): 84 * 85 * NotDirtyInfo ndi; 86 * memory_notdirty_write_prepare(&ndi, ....); 87 * ... perform write here ... 88 * memory_notdirty_write_complete(&ndi); 89 * 90 * These calls will ensure that we flush any TCG translated code for 91 * the memory being written, update the dirty bits and (if possible) 92 * remove the slowpath callback for writing to the memory. 93 * 94 * This must only be called if we are using TCG; it will assert otherwise. 95 * 96 * We may take locks in the prepare call, so callers must ensure that 97 * they don't exit (via longjump or otherwise) without calling complete. 98 * 99 * This call must only be made inside an RCU critical section. 100 * (Note that while we're executing a TCG TB we're always in an 101 * RCU critical section, which is likely to be the case for callers 102 * of these functions.) 103 */ 104 void memory_notdirty_write_prepare(NotDirtyInfo *ndi, 105 CPUState *cpu, 106 vaddr mem_vaddr, 107 ram_addr_t ram_addr, 108 unsigned size); 109 /** 110 * memory_notdirty_write_complete: finish write to non-dirty memory 111 * @ndi: pointer to the opaque NotDirtyInfo struct which was initialized 112 * by memory_not_dirty_write_prepare(). 113 */ 114 void memory_notdirty_write_complete(NotDirtyInfo *ndi); 115 116 #endif 117 #endif 118