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 */
27
28 #include <sys/cdefs.h>
29 __FBSDID("$FreeBSD: releng/10.4/sys/powerpc/powerpc/pmap_dispatch.c 270920 2014-09-01 07:58:15Z kib $");
30
31 /*
32 * Dispatch MI pmap calls to the appropriate MMU implementation
33 * through a previously registered kernel object.
34 *
35 * Before pmap_bootstrap() can be called, a CPU module must have
36 * called pmap_mmu_install(). This may be called multiple times:
37 * the highest priority call will be installed as the default
38 * MMU handler when pmap_bootstrap() is called.
39 *
40 * It is required that mutex_init() be called before pmap_bootstrap(),
41 * as the PMAP layer makes extensive use of mutexes.
42 */
43
44 #include <sys/param.h>
45 #include <sys/kernel.h>
46 #include <sys/lock.h>
47 #include <sys/ktr.h>
48 #include <sys/mutex.h>
49 #include <sys/systm.h>
50
51 #include <vm/vm.h>
52 #include <vm/vm_page.h>
53
54 #include <machine/mmuvar.h>
55 #include <machine/smp.h>
56
57 #include "mmu_if.h"
58
59 static mmu_def_t *mmu_def_impl;
60 static mmu_t mmu_obj;
61 static struct mmu_kobj mmu_kernel_obj;
62 static struct kobj_ops mmu_kernel_kops;
63
64 /*
65 * pmap globals
66 */
67 struct pmap kernel_pmap_store;
68
69 struct msgbuf *msgbufp;
70 vm_offset_t msgbuf_phys;
71
72 vm_offset_t kernel_vm_end;
73 vm_offset_t phys_avail[PHYS_AVAIL_SZ];
74 vm_offset_t virtual_avail;
75 vm_offset_t virtual_end;
76
77 int pmap_bootstrapped;
78
79 #ifdef AIM
80 int
81 pvo_vaddr_compare(struct pvo_entry *a, struct pvo_entry *b)
82 {
83 if (PVO_VADDR(a) < PVO_VADDR(b))
84 return (-1);
85 else if (PVO_VADDR(a) > PVO_VADDR(b))
86 return (1);
87 return (0);
88 }
89 RB_GENERATE(pvo_tree, pvo_entry, pvo_plink, pvo_vaddr_compare);
90 #endif
91
92
93 void
94 pmap_advise(pmap_t pmap, vm_offset_t start, vm_offset_t end, int advice)
95 {
96
97 CTR5(KTR_PMAP, "%s(%p, %#x, %#x, %d)", __func__, pmap, start, end,
98 advice);
99 MMU_ADVISE(mmu_obj, pmap, start, end, advice);
100 }
101
102 void
103 pmap_clear_modify(vm_page_t m)
104 {
105
106 CTR2(KTR_PMAP, "%s(%p)", __func__, m);
107 MMU_CLEAR_MODIFY(mmu_obj, m);
108 }
109
110 void
111 pmap_copy(pmap_t dst_pmap, pmap_t src_pmap, vm_offset_t dst_addr,
112 vm_size_t len, vm_offset_t src_addr)
113 {
114
115 CTR6(KTR_PMAP, "%s(%p, %p, %#x, %#x, %#x)", __func__, dst_pmap,
116 src_pmap, dst_addr, len, src_addr);
117 MMU_COPY(mmu_obj, dst_pmap, src_pmap, dst_addr, len, src_addr);
118 }
119
120 void
121 pmap_copy_page(vm_page_t src, vm_page_t dst)
122 {
123
124 CTR3(KTR_PMAP, "%s(%p, %p)", __func__, src, dst);
125 MMU_COPY_PAGE(mmu_obj, src, dst);
126 }
127
128 void
129 pmap_copy_pages(vm_page_t ma[], vm_offset_t a_offset, vm_page_t mb[],
130 vm_offset_t b_offset, int xfersize)
131 {
132
133 CTR6(KTR_PMAP, "%s(%p, %#x, %p, %#x, %#x)", __func__, ma,
134 a_offset, mb, b_offset, xfersize);
135 MMU_COPY_PAGES(mmu_obj, ma, a_offset, mb, b_offset, xfersize);
136 }
137
138 int
139 pmap_enter(pmap_t pmap, vm_offset_t va, vm_page_t p, vm_prot_t prot,
140 u_int flags, int8_t psind)
141 {
142
143 CTR6(KTR_PMAP, "pmap_enter(%p, %#x, %p, %#x, %x, %d)", pmap, va,
144 p, prot, flags, psind);
145 return (MMU_ENTER(mmu_obj, pmap, va, p, prot, flags, psind));
146 }
147
148 void
149 pmap_enter_object(pmap_t pmap, vm_offset_t start, vm_offset_t end,
150 vm_page_t m_start, vm_prot_t prot)
151 {
152
153 CTR6(KTR_PMAP, "%s(%p, %#x, %#x, %p, %#x)", __func__, pmap, start,
154 end, m_start, prot);
155 MMU_ENTER_OBJECT(mmu_obj, pmap, start, end, m_start, prot);
156 }
157
158 void
159 pmap_enter_quick(pmap_t pmap, vm_offset_t va, vm_page_t m, vm_prot_t prot)
160 {
161
162 CTR5(KTR_PMAP, "%s(%p, %#x, %p, %#x)", __func__, pmap, va, m, prot);
163 MMU_ENTER_QUICK(mmu_obj, pmap, va, m, prot);
164 }
165
166 vm_paddr_t
167 pmap_extract(pmap_t pmap, vm_offset_t va)
168 {
169
170 CTR3(KTR_PMAP, "%s(%p, %#x)", __func__, pmap, va);
171 return (MMU_EXTRACT(mmu_obj, pmap, va));
172 }
173
174 vm_page_t
175 pmap_extract_and_hold(pmap_t pmap, vm_offset_t va, vm_prot_t prot)
176 {
177
178 CTR4(KTR_PMAP, "%s(%p, %#x, %#x)", __func__, pmap, va, prot);
179 return (MMU_EXTRACT_AND_HOLD(mmu_obj, pmap, va, prot));
180 }
181
182 void
183 pmap_growkernel(vm_offset_t va)
184 {
185
186 CTR2(KTR_PMAP, "%s(%#x)", __func__, va);
187 MMU_GROWKERNEL(mmu_obj, va);
188 }
189
190 void
191 pmap_init(void)
192 {
193
194 CTR1(KTR_PMAP, "%s()", __func__);
195 MMU_INIT(mmu_obj);
196 }
197
198 boolean_t
199 pmap_is_modified(vm_page_t m)
200 {
201
202 CTR2(KTR_PMAP, "%s(%p)", __func__, m);
203 return (MMU_IS_MODIFIED(mmu_obj, m));
204 }
205
206 boolean_t
207 pmap_is_prefaultable(pmap_t pmap, vm_offset_t va)
208 {
209
210 CTR3(KTR_PMAP, "%s(%p, %#x)", __func__, pmap, va);
211 return (MMU_IS_PREFAULTABLE(mmu_obj, pmap, va));
212 }
213
214 boolean_t
215 pmap_is_referenced(vm_page_t m)
216 {
217
218 CTR2(KTR_PMAP, "%s(%p)", __func__, m);
219 return (MMU_IS_REFERENCED(mmu_obj, m));
220 }
221
222 boolean_t
223 pmap_ts_referenced(vm_page_t m)
224 {
225
226 CTR2(KTR_PMAP, "%s(%p)", __func__, m);
227 return (MMU_TS_REFERENCED(mmu_obj, m));
228 }
229
230 vm_offset_t
231 pmap_map(vm_offset_t *virt, vm_paddr_t start, vm_paddr_t end, int prot)
232 {
233
234 CTR5(KTR_PMAP, "%s(%p, %#x, %#x, %#x)", __func__, virt, start, end,
235 prot);
236 return (MMU_MAP(mmu_obj, virt, start, end, prot));
237 }
238
239 void
240 pmap_object_init_pt(pmap_t pmap, vm_offset_t addr, vm_object_t object,
241 vm_pindex_t pindex, vm_size_t size)
242 {
243
244 CTR6(KTR_PMAP, "%s(%p, %#x, %p, %u, %#x)", __func__, pmap, addr,
245 object, pindex, size);
246 MMU_OBJECT_INIT_PT(mmu_obj, pmap, addr, object, pindex, size);
247 }
248
249 boolean_t
250 pmap_page_exists_quick(pmap_t pmap, vm_page_t m)
251 {
252
253 CTR3(KTR_PMAP, "%s(%p, %p)", __func__, pmap, m);
254 return (MMU_PAGE_EXISTS_QUICK(mmu_obj, pmap, m));
255 }
256
257 void
258 pmap_page_init(vm_page_t m)
259 {
260
261 CTR2(KTR_PMAP, "%s(%p)", __func__, m);
262 MMU_PAGE_INIT(mmu_obj, m);
263 }
264
265 int
266 pmap_page_wired_mappings(vm_page_t m)
267 {
268
269 CTR2(KTR_PMAP, "%s(%p)", __func__, m);
270 return (MMU_PAGE_WIRED_MAPPINGS(mmu_obj, m));
271 }
272
273 int
274 pmap_pinit(pmap_t pmap)
275 {
276
277 CTR2(KTR_PMAP, "%s(%p)", __func__, pmap);
278 MMU_PINIT(mmu_obj, pmap);
279 return (1);
280 }
281
282 void
283 pmap_pinit0(pmap_t pmap)
284 {
285
286 CTR2(KTR_PMAP, "%s(%p)", __func__, pmap);
287 MMU_PINIT0(mmu_obj, pmap);
288 }
289
290 void
291 pmap_protect(pmap_t pmap, vm_offset_t start, vm_offset_t end, vm_prot_t prot)
292 {
293
294 CTR5(KTR_PMAP, "%s(%p, %#x, %#x, %#x)", __func__, pmap, start, end,
295 prot);
296 MMU_PROTECT(mmu_obj, pmap, start, end, prot);
297 }
298
299 void
300 pmap_qenter(vm_offset_t start, vm_page_t *m, int count)
301 {
302
303 CTR4(KTR_PMAP, "%s(%#x, %p, %d)", __func__, start, m, count);
304 MMU_QENTER(mmu_obj, start, m, count);
305 }
306
307 void
308 pmap_qremove(vm_offset_t start, int count)
309 {
310
311 CTR3(KTR_PMAP, "%s(%#x, %d)", __func__, start, count);
312 MMU_QREMOVE(mmu_obj, start, count);
313 }
314
315 void
316 pmap_release(pmap_t pmap)
317 {
318
319 CTR2(KTR_PMAP, "%s(%p)", __func__, pmap);
320 MMU_RELEASE(mmu_obj, pmap);
321 }
322
323 void
324 pmap_remove(pmap_t pmap, vm_offset_t start, vm_offset_t end)
325 {
326
327 CTR4(KTR_PMAP, "%s(%p, %#x, %#x)", __func__, pmap, start, end);
328 MMU_REMOVE(mmu_obj, pmap, start, end);
329 }
330
331 void
332 pmap_remove_all(vm_page_t m)
333 {
334
335 CTR2(KTR_PMAP, "%s(%p)", __func__, m);
336 MMU_REMOVE_ALL(mmu_obj, m);
337 }
338
339 void
340 pmap_remove_pages(pmap_t pmap)
341 {
342
343 CTR2(KTR_PMAP, "%s(%p)", __func__, pmap);
344 MMU_REMOVE_PAGES(mmu_obj, pmap);
345 }
346
347 void
348 pmap_remove_write(vm_page_t m)
349 {
350
351 CTR2(KTR_PMAP, "%s(%p)", __func__, m);
352 MMU_REMOVE_WRITE(mmu_obj, m);
353 }
354
355 void
356 pmap_unwire(pmap_t pmap, vm_offset_t start, vm_offset_t end)
357 {
358
359 CTR4(KTR_PMAP, "%s(%p, %#x, %#x)", __func__, pmap, start, end);
360 MMU_UNWIRE(mmu_obj, pmap, start, end);
361 }
362
363 void
364 pmap_zero_page(vm_page_t m)
365 {
366
367 CTR2(KTR_PMAP, "%s(%p)", __func__, m);
368 MMU_ZERO_PAGE(mmu_obj, m);
369 }
370
371 void
372 pmap_zero_page_area(vm_page_t m, int off, int size)
373 {
374
375 CTR4(KTR_PMAP, "%s(%p, %d, %d)", __func__, m, off, size);
376 MMU_ZERO_PAGE_AREA(mmu_obj, m, off, size);
377 }
378
379 void
380 pmap_zero_page_idle(vm_page_t m)
381 {
382
383 CTR2(KTR_PMAP, "%s(%p)", __func__, m);
384 MMU_ZERO_PAGE_IDLE(mmu_obj, m);
385 }
386
387 int
388 pmap_mincore(pmap_t pmap, vm_offset_t addr, vm_paddr_t *locked_pa)
389 {
390
391 CTR3(KTR_PMAP, "%s(%p, %#x)", __func__, pmap, addr);
392 return (MMU_MINCORE(mmu_obj, pmap, addr, locked_pa));
393 }
394
395 void
396 pmap_activate(struct thread *td)
397 {
398
399 CTR2(KTR_PMAP, "%s(%p)", __func__, td);
400 MMU_ACTIVATE(mmu_obj, td);
401 }
402
403 void
404 pmap_deactivate(struct thread *td)
405 {
406
407 CTR2(KTR_PMAP, "%s(%p)", __func__, td);
408 MMU_DEACTIVATE(mmu_obj, td);
409 }
410
411 /*
412 * Increase the starting virtual address of the given mapping if a
413 * different alignment might result in more superpage mappings.
414 */
415 void
416 pmap_align_superpage(vm_object_t object, vm_ooffset_t offset,
417 vm_offset_t *addr, vm_size_t size)
418 {
419
420 CTR5(KTR_PMAP, "%s(%p, %#x, %p, %#x)", __func__, object, offset, addr,
421 size);
422 MMU_ALIGN_SUPERPAGE(mmu_obj, object, offset, addr, size);
423 }
424
425 /*
426 * Routines used in machine-dependent code
427 */
428 void
429 pmap_bootstrap(vm_offset_t start, vm_offset_t end)
430 {
431 mmu_obj = &mmu_kernel_obj;
432
433 /*
434 * Take care of compiling the selected class, and
435 * then statically initialise the MMU object
436 */
437 kobj_class_compile_static(mmu_def_impl, &mmu_kernel_kops);
438 kobj_init_static((kobj_t)mmu_obj, mmu_def_impl);
439
440 MMU_BOOTSTRAP(mmu_obj, start, end);
441 }
442
443 void
444 pmap_cpu_bootstrap(int ap)
445 {
446 /*
447 * No KTR here because our console probably doesn't work yet
448 */
449
450 return (MMU_CPU_BOOTSTRAP(mmu_obj, ap));
451 }
452
453 void *
454 pmap_mapdev(vm_paddr_t pa, vm_size_t size)
455 {
456
457 CTR3(KTR_PMAP, "%s(%#x, %#x)", __func__, pa, size);
458 return (MMU_MAPDEV(mmu_obj, pa, size));
459 }
460
461 void *
462 pmap_mapdev_attr(vm_offset_t pa, vm_size_t size, vm_memattr_t attr)
463 {
464
465 CTR4(KTR_PMAP, "%s(%#x, %#x, %#x)", __func__, pa, size, attr);
466 return (MMU_MAPDEV_ATTR(mmu_obj, pa, size, attr));
467 }
468
469 void
470 pmap_page_set_memattr(vm_page_t m, vm_memattr_t ma)
471 {
472
473 CTR3(KTR_PMAP, "%s(%p, %#x)", __func__, m, ma);
474 return (MMU_PAGE_SET_MEMATTR(mmu_obj, m, ma));
475 }
476
477 void
478 pmap_unmapdev(vm_offset_t va, vm_size_t size)
479 {
480
481 CTR3(KTR_PMAP, "%s(%#x, %#x)", __func__, va, size);
482 MMU_UNMAPDEV(mmu_obj, va, size);
483 }
484
485 vm_paddr_t
486 pmap_kextract(vm_offset_t va)
487 {
488
489 CTR2(KTR_PMAP, "%s(%#x)", __func__, va);
490 return (MMU_KEXTRACT(mmu_obj, va));
491 }
492
493 void
494 pmap_kenter(vm_offset_t va, vm_paddr_t pa)
495 {
496
497 CTR3(KTR_PMAP, "%s(%#x, %#x)", __func__, va, pa);
498 MMU_KENTER(mmu_obj, va, pa);
499 }
500
501 void
502 pmap_kenter_attr(vm_offset_t va, vm_offset_t pa, vm_memattr_t ma)
503 {
504
505 CTR4(KTR_PMAP, "%s(%#x, %#x, %#x)", __func__, va, pa, ma);
506 MMU_KENTER_ATTR(mmu_obj, va, pa, ma);
507 }
508
509 boolean_t
510 pmap_dev_direct_mapped(vm_paddr_t pa, vm_size_t size)
511 {
512
513 CTR3(KTR_PMAP, "%s(%#x, %#x)", __func__, pa, size);
514 return (MMU_DEV_DIRECT_MAPPED(mmu_obj, pa, size));
515 }
516
517 void
518 pmap_sync_icache(pmap_t pm, vm_offset_t va, vm_size_t sz)
519 {
520
521 CTR4(KTR_PMAP, "%s(%p, %#x, %#x)", __func__, pm, va, sz);
522 return (MMU_SYNC_ICACHE(mmu_obj, pm, va, sz));
523 }
524
525 vm_offset_t
526 pmap_dumpsys_map(struct pmap_md *md, vm_size_t ofs, vm_size_t *sz)
527 {
528
529 CTR4(KTR_PMAP, "%s(%p, %#x, %#x)", __func__, md, ofs, *sz);
530 return (MMU_DUMPSYS_MAP(mmu_obj, md, ofs, sz));
531 }
532
533 void
534 pmap_dumpsys_unmap(struct pmap_md *md, vm_size_t ofs, vm_offset_t va)
535 {
536
537 CTR4(KTR_PMAP, "%s(%p, %#x, %#x)", __func__, md, ofs, va);
538 return (MMU_DUMPSYS_UNMAP(mmu_obj, md, ofs, va));
539 }
540
541 struct pmap_md *
542 pmap_scan_md(struct pmap_md *prev)
543 {
544
545 CTR2(KTR_PMAP, "%s(%p)", __func__, prev);
546 return (MMU_SCAN_MD(mmu_obj, prev));
547 }
548
549 /*
550 * MMU install routines. Highest priority wins, equal priority also
551 * overrides allowing last-set to win.
552 */
553 SET_DECLARE(mmu_set, mmu_def_t);
554
555 boolean_t
556 pmap_mmu_install(char *name, int prio)
557 {
558 mmu_def_t **mmupp, *mmup;
559 static int curr_prio = 0;
560
561 /*
562 * Try and locate the MMU kobj corresponding to the name
563 */
564 SET_FOREACH(mmupp, mmu_set) {
565 mmup = *mmupp;
566
567 if (mmup->name &&
568 !strcmp(mmup->name, name) &&
569 (prio >= curr_prio || mmu_def_impl == NULL)) {
570 curr_prio = prio;
571 mmu_def_impl = mmup;
572 return (TRUE);
573 }
574 }
575
576 return (FALSE);
577 }
578
579 int unmapped_buf_allowed;
Cache object: 3ca7b4d3cbf4a66c085253af2a86ac9f
|