1 #-
2 # Copyright (c) 2005 Peter Grehan
3 # All rights reserved.
4 #
5 # Redistribution and use in source and binary forms, with or without
6 # modification, are permitted provided that the following conditions
7 # are met:
8 # 1. Redistributions of source code must retain the above copyright
9 # notice, this list of conditions and the following disclaimer.
10 # 2. Redistributions in binary form must reproduce the above copyright
11 # notice, this list of conditions and the following disclaimer in the
12 # documentation and/or other materials provided with the distribution.
13 #
14 # THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 # ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 # FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 # OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 # HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 # OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 # SUCH DAMAGE.
25 #
26 # $FreeBSD: releng/10.2/sys/powerpc/powerpc/mmu_if.m 270920 2014-09-01 07:58:15Z kib $
27 #
28
29 #include <sys/param.h>
30 #include <sys/lock.h>
31 #include <sys/mutex.h>
32 #include <sys/systm.h>
33
34 #include <vm/vm.h>
35 #include <vm/vm_page.h>
36
37 #include <machine/mmuvar.h>
38
39 /**
40 * @defgroup MMU mmu - KObj methods for PowerPC MMU implementations
41 * @brief A set of methods required by all MMU implementations. These
42 * are basically direct call-thru's from the pmap machine-dependent
43 * code.
44 * Thanks to Bruce M Simpson's pmap man pages for routine descriptions.
45 *@{
46 */
47
48 INTERFACE mmu;
49
50 #
51 # Default implementations of some methods
52 #
53 CODE {
54 static void mmu_null_copy(mmu_t mmu, pmap_t dst_pmap, pmap_t src_pmap,
55 vm_offset_t dst_addr, vm_size_t len, vm_offset_t src_addr)
56 {
57 return;
58 }
59
60 static void mmu_null_growkernel(mmu_t mmu, vm_offset_t addr)
61 {
62 return;
63 }
64
65 static void mmu_null_init(mmu_t mmu)
66 {
67 return;
68 }
69
70 static boolean_t mmu_null_is_prefaultable(mmu_t mmu, pmap_t pmap,
71 vm_offset_t va)
72 {
73 return (FALSE);
74 }
75
76 static void mmu_null_object_init_pt(mmu_t mmu, pmap_t pmap,
77 vm_offset_t addr, vm_object_t object, vm_pindex_t index,
78 vm_size_t size)
79 {
80 return;
81 }
82
83 static void mmu_null_page_init(mmu_t mmu, vm_page_t m)
84 {
85 return;
86 }
87
88 static void mmu_null_remove_pages(mmu_t mmu, pmap_t pmap)
89 {
90 return;
91 }
92
93 static int mmu_null_mincore(mmu_t mmu, pmap_t pmap, vm_offset_t addr,
94 vm_paddr_t *locked_pa)
95 {
96 return (0);
97 }
98
99 static void mmu_null_deactivate(struct thread *td)
100 {
101 return;
102 }
103
104 static void mmu_null_align_superpage(mmu_t mmu, vm_object_t object,
105 vm_ooffset_t offset, vm_offset_t *addr, vm_size_t size)
106 {
107 return;
108 }
109
110 static struct pmap_md *mmu_null_scan_md(mmu_t mmu, struct pmap_md *p)
111 {
112 return (NULL);
113 }
114
115 static void *mmu_null_mapdev_attr(mmu_t mmu, vm_offset_t pa,
116 vm_size_t size, vm_memattr_t ma)
117 {
118 return MMU_MAPDEV(mmu, pa, size);
119 }
120
121 static void mmu_null_kenter_attr(mmu_t mmu, vm_offset_t va,
122 vm_offset_t pa, vm_memattr_t ma)
123 {
124 MMU_KENTER(mmu, va, pa);
125 }
126
127 static void mmu_null_page_set_memattr(mmu_t mmu, vm_page_t m,
128 vm_memattr_t ma)
129 {
130 return;
131 }
132 };
133
134
135 /**
136 * @brief Apply the given advice to the specified range of addresses within
137 * the given pmap. Depending on the advice, clear the referenced and/or
138 * modified flags in each mapping and set the mapped page's dirty field.
139 *
140 * @param _pmap physical map
141 * @param _start virtual range start
142 * @param _end virtual range end
143 * @param _advice advice to apply
144 */
145 METHOD void advise {
146 mmu_t _mmu;
147 pmap_t _pmap;
148 vm_offset_t _start;
149 vm_offset_t _end;
150 int _advice;
151 };
152
153
154 /**
155 * @brief Clear the 'modified' bit on the given physical page
156 *
157 * @param _pg physical page
158 */
159 METHOD void clear_modify {
160 mmu_t _mmu;
161 vm_page_t _pg;
162 };
163
164
165 /**
166 * @brief Clear the write and modified bits in each of the given
167 * physical page's mappings
168 *
169 * @param _pg physical page
170 */
171 METHOD void remove_write {
172 mmu_t _mmu;
173 vm_page_t _pg;
174 };
175
176
177 /**
178 * @brief Copy the address range given by the source physical map, virtual
179 * address and length to the destination physical map and virtual address.
180 * This routine is optional (xxx default null implementation ?)
181 *
182 * @param _dst_pmap destination physical map
183 * @param _src_pmap source physical map
184 * @param _dst_addr destination virtual address
185 * @param _len size of range
186 * @param _src_addr source virtual address
187 */
188 METHOD void copy {
189 mmu_t _mmu;
190 pmap_t _dst_pmap;
191 pmap_t _src_pmap;
192 vm_offset_t _dst_addr;
193 vm_size_t _len;
194 vm_offset_t _src_addr;
195 } DEFAULT mmu_null_copy;
196
197
198 /**
199 * @brief Copy the source physical page to the destination physical page
200 *
201 * @param _src source physical page
202 * @param _dst destination physical page
203 */
204 METHOD void copy_page {
205 mmu_t _mmu;
206 vm_page_t _src;
207 vm_page_t _dst;
208 };
209
210 METHOD void copy_pages {
211 mmu_t _mmu;
212 vm_page_t *_ma;
213 vm_offset_t _a_offset;
214 vm_page_t *_mb;
215 vm_offset_t _b_offset;
216 int _xfersize;
217 };
218
219 /**
220 * @brief Create a mapping between a virtual/physical address pair in the
221 * passed physical map with the specified protection and wiring
222 *
223 * @param _pmap physical map
224 * @param _va mapping virtual address
225 * @param _p mapping physical page
226 * @param _prot mapping page protection
227 * @param _flags pmap_enter flags
228 * @param _psind superpage size index
229 */
230 METHOD int enter {
231 mmu_t _mmu;
232 pmap_t _pmap;
233 vm_offset_t _va;
234 vm_page_t _p;
235 vm_prot_t _prot;
236 u_int _flags;
237 int8_t _psind;
238 };
239
240
241 /**
242 * @brief Maps a sequence of resident pages belonging to the same object.
243 *
244 * @param _pmap physical map
245 * @param _start virtual range start
246 * @param _end virtual range end
247 * @param _m_start physical page mapped at start
248 * @param _prot mapping page protection
249 */
250 METHOD void enter_object {
251 mmu_t _mmu;
252 pmap_t _pmap;
253 vm_offset_t _start;
254 vm_offset_t _end;
255 vm_page_t _m_start;
256 vm_prot_t _prot;
257 };
258
259
260 /**
261 * @brief A faster entry point for page mapping where it is possible
262 * to short-circuit some of the tests in pmap_enter.
263 *
264 * @param _pmap physical map (and also currently active pmap)
265 * @param _va mapping virtual address
266 * @param _pg mapping physical page
267 * @param _prot new page protection - used to see if page is exec.
268 */
269 METHOD void enter_quick {
270 mmu_t _mmu;
271 pmap_t _pmap;
272 vm_offset_t _va;
273 vm_page_t _pg;
274 vm_prot_t _prot;
275 };
276
277
278 /**
279 * @brief Reverse map the given virtual address, returning the physical
280 * page associated with the address if a mapping exists.
281 *
282 * @param _pmap physical map
283 * @param _va mapping virtual address
284 *
285 * @retval 0 No mapping found
286 * @retval addr The mapping physical address
287 */
288 METHOD vm_paddr_t extract {
289 mmu_t _mmu;
290 pmap_t _pmap;
291 vm_offset_t _va;
292 };
293
294
295 /**
296 * @brief Reverse map the given virtual address, returning the
297 * physical page if found. The page must be held (by calling
298 * vm_page_hold) if the page protection matches the given protection
299 *
300 * @param _pmap physical map
301 * @param _va mapping virtual address
302 * @param _prot protection used to determine if physical page
303 * should be locked
304 *
305 * @retval NULL No mapping found
306 * @retval page Pointer to physical page. Held if protections match
307 */
308 METHOD vm_page_t extract_and_hold {
309 mmu_t _mmu;
310 pmap_t _pmap;
311 vm_offset_t _va;
312 vm_prot_t _prot;
313 };
314
315
316 /**
317 * @brief Increase kernel virtual address space to the given virtual address.
318 * Not really required for PowerPC, so optional unless the MMU implementation
319 * can use it.
320 *
321 * @param _va new upper limit for kernel virtual address space
322 */
323 METHOD void growkernel {
324 mmu_t _mmu;
325 vm_offset_t _va;
326 } DEFAULT mmu_null_growkernel;
327
328
329 /**
330 * @brief Called from vm_mem_init. Zone allocation is available at
331 * this stage so a convenient time to create zones. This routine is
332 * for MMU-implementation convenience and is optional.
333 */
334 METHOD void init {
335 mmu_t _mmu;
336 } DEFAULT mmu_null_init;
337
338
339 /**
340 * @brief Return if the page has been marked by MMU hardware to have been
341 * modified
342 *
343 * @param _pg physical page to test
344 *
345 * @retval boolean TRUE if page has been modified
346 */
347 METHOD boolean_t is_modified {
348 mmu_t _mmu;
349 vm_page_t _pg;
350 };
351
352
353 /**
354 * @brief Return whether the specified virtual address is a candidate to be
355 * prefaulted in. This routine is optional.
356 *
357 * @param _pmap physical map
358 * @param _va virtual address to test
359 *
360 * @retval boolean TRUE if the address is a candidate.
361 */
362 METHOD boolean_t is_prefaultable {
363 mmu_t _mmu;
364 pmap_t _pmap;
365 vm_offset_t _va;
366 } DEFAULT mmu_null_is_prefaultable;
367
368
369 /**
370 * @brief Return whether or not the specified physical page was referenced
371 * in any physical maps.
372 *
373 * @params _pg physical page
374 *
375 * @retval boolean TRUE if page has been referenced
376 */
377 METHOD boolean_t is_referenced {
378 mmu_t _mmu;
379 vm_page_t _pg;
380 };
381
382
383 /**
384 * @brief Return a count of referenced bits for a page, clearing those bits.
385 * Not all referenced bits need to be cleared, but it is necessary that 0
386 * only be returned when there are none set.
387 *
388 * @params _m physical page
389 *
390 * @retval int count of referenced bits
391 */
392 METHOD int ts_referenced {
393 mmu_t _mmu;
394 vm_page_t _pg;
395 };
396
397
398 /**
399 * @brief Map the requested physical address range into kernel virtual
400 * address space. The value in _virt is taken as a hint. The virtual
401 * address of the range is returned, or NULL if the mapping could not
402 * be created. The range can be direct-mapped if that is supported.
403 *
404 * @param *_virt Hint for start virtual address, and also return
405 * value
406 * @param _start physical address range start
407 * @param _end physical address range end
408 * @param _prot protection of range (currently ignored)
409 *
410 * @retval NULL could not map the area
411 * @retval addr, *_virt mapping start virtual address
412 */
413 METHOD vm_offset_t map {
414 mmu_t _mmu;
415 vm_offset_t *_virt;
416 vm_paddr_t _start;
417 vm_paddr_t _end;
418 int _prot;
419 };
420
421
422 /**
423 * @brief Used to create a contiguous set of read-only mappings for a
424 * given object to try and eliminate a cascade of on-demand faults as
425 * the object is accessed sequentially. This routine is optional.
426 *
427 * @param _pmap physical map
428 * @param _addr mapping start virtual address
429 * @param _object device-backed V.M. object to be mapped
430 * @param _pindex page-index within object of mapping start
431 * @param _size size in bytes of mapping
432 */
433 METHOD void object_init_pt {
434 mmu_t _mmu;
435 pmap_t _pmap;
436 vm_offset_t _addr;
437 vm_object_t _object;
438 vm_pindex_t _pindex;
439 vm_size_t _size;
440 } DEFAULT mmu_null_object_init_pt;
441
442
443 /**
444 * @brief Used to determine if the specified page has a mapping for the
445 * given physical map, by scanning the list of reverse-mappings from the
446 * page. The list is scanned to a maximum of 16 entries.
447 *
448 * @param _pmap physical map
449 * @param _pg physical page
450 *
451 * @retval bool TRUE if the physical map was found in the first 16
452 * reverse-map list entries off the physical page.
453 */
454 METHOD boolean_t page_exists_quick {
455 mmu_t _mmu;
456 pmap_t _pmap;
457 vm_page_t _pg;
458 };
459
460
461 /**
462 * @brief Initialise the machine-dependent section of the physical page
463 * data structure. This routine is optional.
464 *
465 * @param _pg physical page
466 */
467 METHOD void page_init {
468 mmu_t _mmu;
469 vm_page_t _pg;
470 } DEFAULT mmu_null_page_init;
471
472
473 /**
474 * @brief Count the number of managed mappings to the given physical
475 * page that are wired.
476 *
477 * @param _pg physical page
478 *
479 * @retval int the number of wired, managed mappings to the
480 * given physical page
481 */
482 METHOD int page_wired_mappings {
483 mmu_t _mmu;
484 vm_page_t _pg;
485 };
486
487
488 /**
489 * @brief Initialise a physical map data structure
490 *
491 * @param _pmap physical map
492 */
493 METHOD void pinit {
494 mmu_t _mmu;
495 pmap_t _pmap;
496 };
497
498
499 /**
500 * @brief Initialise the physical map for process 0, the initial process
501 * in the system.
502 * XXX default to pinit ?
503 *
504 * @param _pmap physical map
505 */
506 METHOD void pinit0 {
507 mmu_t _mmu;
508 pmap_t _pmap;
509 };
510
511
512 /**
513 * @brief Set the protection for physical pages in the given virtual address
514 * range to the given value.
515 *
516 * @param _pmap physical map
517 * @param _start virtual range start
518 * @param _end virtual range end
519 * @param _prot new page protection
520 */
521 METHOD void protect {
522 mmu_t _mmu;
523 pmap_t _pmap;
524 vm_offset_t _start;
525 vm_offset_t _end;
526 vm_prot_t _prot;
527 };
528
529
530 /**
531 * @brief Create a mapping in kernel virtual address space for the given array
532 * of wired physical pages.
533 *
534 * @param _start mapping virtual address start
535 * @param *_m array of physical page pointers
536 * @param _count array elements
537 */
538 METHOD void qenter {
539 mmu_t _mmu;
540 vm_offset_t _start;
541 vm_page_t *_pg;
542 int _count;
543 };
544
545
546 /**
547 * @brief Remove the temporary mappings created by qenter.
548 *
549 * @param _start mapping virtual address start
550 * @param _count number of pages in mapping
551 */
552 METHOD void qremove {
553 mmu_t _mmu;
554 vm_offset_t _start;
555 int _count;
556 };
557
558
559 /**
560 * @brief Release per-pmap resources, e.g. mutexes, allocated memory etc. There
561 * should be no existing mappings for the physical map at this point
562 *
563 * @param _pmap physical map
564 */
565 METHOD void release {
566 mmu_t _mmu;
567 pmap_t _pmap;
568 };
569
570
571 /**
572 * @brief Remove all mappings in the given physical map for the start/end
573 * virtual address range. The range will be page-aligned.
574 *
575 * @param _pmap physical map
576 * @param _start mapping virtual address start
577 * @param _end mapping virtual address end
578 */
579 METHOD void remove {
580 mmu_t _mmu;
581 pmap_t _pmap;
582 vm_offset_t _start;
583 vm_offset_t _end;
584 };
585
586
587 /**
588 * @brief Traverse the reverse-map list off the given physical page and
589 * remove all mappings. Clear the PGA_WRITEABLE attribute from the page.
590 *
591 * @param _pg physical page
592 */
593 METHOD void remove_all {
594 mmu_t _mmu;
595 vm_page_t _pg;
596 };
597
598
599 /**
600 * @brief Remove all mappings in the given start/end virtual address range
601 * for the given physical map. Similar to the remove method, but it used
602 * when tearing down all mappings in an address space. This method is
603 * optional, since pmap_remove will be called for each valid vm_map in
604 * the address space later.
605 *
606 * @param _pmap physical map
607 * @param _start mapping virtual address start
608 * @param _end mapping virtual address end
609 */
610 METHOD void remove_pages {
611 mmu_t _mmu;
612 pmap_t _pmap;
613 } DEFAULT mmu_null_remove_pages;
614
615
616 /**
617 * @brief Clear the wired attribute from the mappings for the specified range
618 * of addresses in the given pmap.
619 *
620 * @param _pmap physical map
621 * @param _start virtual range start
622 * @param _end virtual range end
623 */
624 METHOD void unwire {
625 mmu_t _mmu;
626 pmap_t _pmap;
627 vm_offset_t _start;
628 vm_offset_t _end;
629 };
630
631
632 /**
633 * @brief Zero a physical page. It is not assumed that the page is mapped,
634 * so a temporary (or direct) mapping may need to be used.
635 *
636 * @param _pg physical page
637 */
638 METHOD void zero_page {
639 mmu_t _mmu;
640 vm_page_t _pg;
641 };
642
643
644 /**
645 * @brief Zero a portion of a physical page, starting at a given offset and
646 * for a given size (multiples of 512 bytes for 4k pages).
647 *
648 * @param _pg physical page
649 * @param _off byte offset from start of page
650 * @param _size size of area to zero
651 */
652 METHOD void zero_page_area {
653 mmu_t _mmu;
654 vm_page_t _pg;
655 int _off;
656 int _size;
657 };
658
659
660 /**
661 * @brief Called from the idle loop to zero pages. XXX I think locking
662 * constraints might be different here compared to zero_page.
663 *
664 * @param _pg physical page
665 */
666 METHOD void zero_page_idle {
667 mmu_t _mmu;
668 vm_page_t _pg;
669 };
670
671
672 /**
673 * @brief Extract mincore(2) information from a mapping.
674 *
675 * @param _pmap physical map
676 * @param _addr page virtual address
677 * @param _locked_pa page physical address
678 *
679 * @retval 0 no result
680 * @retval non-zero mincore(2) flag values
681 */
682 METHOD int mincore {
683 mmu_t _mmu;
684 pmap_t _pmap;
685 vm_offset_t _addr;
686 vm_paddr_t *_locked_pa;
687 } DEFAULT mmu_null_mincore;
688
689
690 /**
691 * @brief Perform any operations required to allow a physical map to be used
692 * before it's address space is accessed.
693 *
694 * @param _td thread associated with physical map
695 */
696 METHOD void activate {
697 mmu_t _mmu;
698 struct thread *_td;
699 };
700
701 /**
702 * @brief Perform any operations required to deactivate a physical map,
703 * for instance as it is context-switched out.
704 *
705 * @param _td thread associated with physical map
706 */
707 METHOD void deactivate {
708 mmu_t _mmu;
709 struct thread *_td;
710 } DEFAULT mmu_null_deactivate;
711
712 /**
713 * @brief Return a hint for the best virtual address to map a tentative
714 * virtual address range in a given VM object. The default is to just
715 * return the given tentative start address.
716 *
717 * @param _obj VM backing object
718 * @param _offset starting offset with the VM object
719 * @param _addr initial guess at virtual address
720 * @param _size size of virtual address range
721 */
722 METHOD void align_superpage {
723 mmu_t _mmu;
724 vm_object_t _obj;
725 vm_ooffset_t _offset;
726 vm_offset_t *_addr;
727 vm_size_t _size;
728 } DEFAULT mmu_null_align_superpage;
729
730
731
732
733 /**
734 * INTERNAL INTERFACES
735 */
736
737 /**
738 * @brief Bootstrap the VM system. At the completion of this routine, the
739 * kernel will be running in it's own address space with full control over
740 * paging.
741 *
742 * @param _start start of reserved memory (obsolete ???)
743 * @param _end end of reserved memory (obsolete ???)
744 * XXX I think the intent of these was to allow
745 * the memory used by kernel text+data+bss and
746 * loader variables/load-time kld's to be carved out
747 * of available physical mem.
748 *
749 */
750 METHOD void bootstrap {
751 mmu_t _mmu;
752 vm_offset_t _start;
753 vm_offset_t _end;
754 };
755
756 /**
757 * @brief Set up the MMU on the current CPU. Only called by the PMAP layer
758 * for alternate CPUs on SMP systems.
759 *
760 * @param _ap Set to 1 if the CPU being set up is an AP
761 *
762 */
763 METHOD void cpu_bootstrap {
764 mmu_t _mmu;
765 int _ap;
766 };
767
768
769 /**
770 * @brief Create a kernel mapping for a given physical address range.
771 * Called by bus code on behalf of device drivers. The mapping does not
772 * have to be a virtual address: it can be a direct-mapped physical address
773 * if that is supported by the MMU.
774 *
775 * @param _pa start physical address
776 * @param _size size in bytes of mapping
777 *
778 * @retval addr address of mapping.
779 */
780 METHOD void * mapdev {
781 mmu_t _mmu;
782 vm_paddr_t _pa;
783 vm_size_t _size;
784 };
785
786 /**
787 * @brief Create a kernel mapping for a given physical address range.
788 * Called by bus code on behalf of device drivers. The mapping does not
789 * have to be a virtual address: it can be a direct-mapped physical address
790 * if that is supported by the MMU.
791 *
792 * @param _pa start physical address
793 * @param _size size in bytes of mapping
794 * @param _attr cache attributes
795 *
796 * @retval addr address of mapping.
797 */
798 METHOD void * mapdev_attr {
799 mmu_t _mmu;
800 vm_offset_t _pa;
801 vm_size_t _size;
802 vm_memattr_t _attr;
803 } DEFAULT mmu_null_mapdev_attr;
804
805 /**
806 * @brief Change cache control attributes for a page. Should modify all
807 * mappings for that page.
808 *
809 * @param _m page to modify
810 * @param _ma new cache control attributes
811 */
812 METHOD void page_set_memattr {
813 mmu_t _mmu;
814 vm_page_t _pg;
815 vm_memattr_t _ma;
816 } DEFAULT mmu_null_page_set_memattr;
817
818 /**
819 * @brief Remove the mapping created by mapdev. Called when a driver
820 * is unloaded.
821 *
822 * @param _va Mapping address returned from mapdev
823 * @param _size size in bytes of mapping
824 */
825 METHOD void unmapdev {
826 mmu_t _mmu;
827 vm_offset_t _va;
828 vm_size_t _size;
829 };
830
831
832 /**
833 * @brief Reverse-map a kernel virtual address
834 *
835 * @param _va kernel virtual address to reverse-map
836 *
837 * @retval pa physical address corresponding to mapping
838 */
839 METHOD vm_paddr_t kextract {
840 mmu_t _mmu;
841 vm_offset_t _va;
842 };
843
844
845 /**
846 * @brief Map a wired page into kernel virtual address space
847 *
848 * @param _va mapping virtual address
849 * @param _pa mapping physical address
850 */
851 METHOD void kenter {
852 mmu_t _mmu;
853 vm_offset_t _va;
854 vm_paddr_t _pa;
855 };
856
857 /**
858 * @brief Map a wired page into kernel virtual address space
859 *
860 * @param _va mapping virtual address
861 * @param _pa mapping physical address
862 * @param _ma mapping cache control attributes
863 */
864 METHOD void kenter_attr {
865 mmu_t _mmu;
866 vm_offset_t _va;
867 vm_offset_t _pa;
868 vm_memattr_t _ma;
869 } DEFAULT mmu_null_kenter_attr;
870
871 /**
872 * @brief Determine if the given physical address range has been direct-mapped.
873 *
874 * @param _pa physical address start
875 * @param _size physical address range size
876 *
877 * @retval bool TRUE if the range is direct-mapped.
878 */
879 METHOD boolean_t dev_direct_mapped {
880 mmu_t _mmu;
881 vm_paddr_t _pa;
882 vm_size_t _size;
883 };
884
885
886 /**
887 * @brief Enforce instruction cache coherency. Typically called after a
888 * region of memory has been modified and before execution of or within
889 * that region is attempted. Setting breakpoints in a process through
890 * ptrace(2) is one example of when the instruction cache needs to be
891 * made coherent.
892 *
893 * @param _pm the physical map of the virtual address
894 * @param _va the virtual address of the modified region
895 * @param _sz the size of the modified region
896 */
897 METHOD void sync_icache {
898 mmu_t _mmu;
899 pmap_t _pm;
900 vm_offset_t _va;
901 vm_size_t _sz;
902 };
903
904
905 /**
906 * @brief Create temporary memory mapping for use by dumpsys().
907 *
908 * @param _md The memory chunk in which the mapping lies.
909 * @param _ofs The offset within the chunk of the mapping.
910 * @param _sz The requested size of the mapping.
911 *
912 * @retval vm_offset_t The virtual address of the mapping.
913 *
914 * The sz argument is modified to reflect the actual size of the
915 * mapping.
916 */
917 METHOD vm_offset_t dumpsys_map {
918 mmu_t _mmu;
919 struct pmap_md *_md;
920 vm_size_t _ofs;
921 vm_size_t *_sz;
922 };
923
924
925 /**
926 * @brief Remove temporary dumpsys() mapping.
927 *
928 * @param _md The memory chunk in which the mapping lies.
929 * @param _ofs The offset within the chunk of the mapping.
930 * @param _va The virtual address of the mapping.
931 */
932 METHOD void dumpsys_unmap {
933 mmu_t _mmu;
934 struct pmap_md *_md;
935 vm_size_t _ofs;
936 vm_offset_t _va;
937 };
938
939
940 /**
941 * @brief Scan/iterate memory chunks.
942 *
943 * @param _prev The previously returned chunk or NULL.
944 *
945 * @retval The next (or first when _prev is NULL) chunk.
946 */
947 METHOD struct pmap_md * scan_md {
948 mmu_t _mmu;
949 struct pmap_md *_prev;
950 } DEFAULT mmu_null_scan_md;
Cache object: 678124bff09f071e09d3ef0f05da9020
|