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