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