[apple/xnu.git] / osfmk / i386 / phys.c

/*
 * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
/*
 * @OSF_COPYRIGHT@
 */
/* 
 * Mach Operating System
 * Copyright (c) 1991,1990,1989 Carnegie Mellon University
 * All Rights Reserved.
 * 
 * Permission to use, copy, modify and distribute this software and its
 * documentation is hereby granted, provided that both the copyright
 * notice and this permission notice appear in all copies of the
 * software, derivative works or modified versions, and any portions
 * thereof, and that both notices appear in supporting documentation.
 * 
 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
 * 
 * Carnegie Mellon requests users of this software to return to
 * 
 *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
 *  School of Computer Science
 *  Carnegie Mellon University
 *  Pittsburgh PA 15213-3890
 * 
 * any improvements or extensions that they make and grant Carnegie Mellon
 * the rights to redistribute these changes.
 */

#include <mach_rt.h>
#include <mach_debug.h>
#include <mach_ldebug.h>

#include <sys/kdebug.h>

#include <mach/kern_return.h>
#include <mach/thread_status.h>
#include <mach/vm_param.h>

#include <kern/counters.h>
#include <kern/mach_param.h>
#include <kern/task.h>
#include <kern/thread.h>
#include <kern/sched_prim.h>
#include <kern/misc_protos.h>
#include <kern/assert.h>
#include <kern/spl.h>
#include <ipc/ipc_port.h>
#include <vm/vm_kern.h>
#include <vm/vm_map.h>
#include <vm/pmap.h>

#include <i386/cpu_data.h>
#include <i386/cpu_number.h>
#include <i386/thread.h>
#include <i386/eflags.h>
#include <i386/proc_reg.h>
#include <i386/seg.h>
#include <i386/tss.h>
#include <i386/user_ldt.h>
#include <i386/fpu.h>
#include <i386/iopb_entries.h>
#include <i386/misc_protos.h>

/*
 *	pmap_zero_page zeros the specified (machine independent) page.
 */
void
pmap_zero_page(
	       ppnum_t pn)
{
	assert(pn != vm_page_fictitious_addr);
	bzero_phys((addr64_t)i386_ptob(pn), PAGE_SIZE);
}

/*
 *	pmap_zero_part_page
 *	zeros the specified (machine independent) part of a page.
 */
void
pmap_zero_part_page(
        ppnum_t         pn,
	vm_offset_t     offset,
	vm_size_t       len)
{
	assert(pn != vm_page_fictitious_addr);
	assert(offset + len <= PAGE_SIZE);
	bzero_phys((addr64_t)(i386_ptob(pn) + offset), len);
}

/*
 *	pmap_copy_page copies the specified (machine independent) pages.
 */
void
pmap_copy_part_page(
	ppnum_t 	psrc,
	vm_offset_t	src_offset,
	ppnum_t	        pdst,
	vm_offset_t	dst_offset,
	vm_size_t	len)
{
        vm_offset_t  src, dst;
	assert(psrc != vm_page_fictitious_addr);
	assert(pdst != vm_page_fictitious_addr);
	src = (vm_offset_t)i386_ptob(psrc);
	dst = (vm_offset_t)i386_ptob(pdst);
	assert(((dst & PAGE_MASK) + dst_offset + len) <= PAGE_SIZE);
	assert(((src & PAGE_MASK) + src_offset + len) <= PAGE_SIZE);
	bcopy_phys((addr64_t)src + (src_offset & INTEL_OFFMASK),
		   (addr64_t)dst + (dst_offset & INTEL_OFFMASK),
		   len);
}

/*
 *      pmap_copy_part_lpage copies part of a virtually addressed page 
 *      to a physically addressed page.
 */
void
pmap_copy_part_lpage(
	vm_offset_t 	src,
	ppnum_t 	pdst,
	vm_offset_t	dst_offset,
	vm_size_t	len)
{
	pt_entry_t *ptep;
	thread_t	thr_act = current_thread();

	assert(pdst != vm_page_fictitious_addr);
	ptep = pmap_pte(thr_act->map->pmap, i386_ptob(pdst));
	if (0 == ptep)
		panic("pmap_copy_part_lpage ptep");
	assert(((pdst & PAGE_MASK) + dst_offset + len) <= PAGE_SIZE);
	if (*(pt_entry_t *) CM2)
	  panic("pmap_copy_part_lpage");
	*(int *) CM2 = INTEL_PTE_VALID | INTEL_PTE_RW | (*ptep & PG_FRAME) | 
	  INTEL_PTE_REF | INTEL_PTE_MOD;
	invlpg((unsigned int) CA2);
	memcpy((void *) (CA2 + (dst_offset & INTEL_OFFMASK)), (void *) src, len);
	*(pt_entry_t *) CM2 = 0;
}

/*
 *      pmap_copy_part_rpage copies part of a physically addressed page 
 *      to a virtually addressed page.
 */
void
pmap_copy_part_rpage(
	ppnum_t	        psrc,
	vm_offset_t	src_offset,
	vm_offset_t	dst,
	vm_size_t	len)
{
  pt_entry_t *ptep;
  thread_t thr_act = current_thread();

	assert(psrc != vm_page_fictitious_addr);
	ptep = pmap_pte(thr_act->map->pmap, i386_ptob(psrc));
	if (0 == ptep)
		panic("pmap_copy_part_rpage ptep");
	assert(((psrc & PAGE_MASK) + src_offset + len) <= PAGE_SIZE);
	if (*(pt_entry_t *) CM2)
	  panic("pmap_copy_part_rpage");
	*(pt_entry_t *) CM2 = INTEL_PTE_VALID | INTEL_PTE_RW | (*ptep & PG_FRAME) | 
	  INTEL_PTE_REF;
	invlpg((unsigned int) CA2);
	memcpy((void *) dst, (void *) (CA2 + (src_offset & INTEL_OFFMASK)), len);
	*(pt_entry_t *) CM2 = 0;
}

/*
 *	kvtophys(addr)
 *
 *	Convert a kernel virtual address to a physical address
 */
vm_offset_t
kvtophys(
	vm_offset_t addr)
{
        pt_entry_t *ptep;
	pmap_paddr_t pa;

	if ((ptep = pmap_pte(kernel_pmap, addr)) == PT_ENTRY_NULL) {
	  pa = 0;
	} else {
	  pa =  pte_to_pa(*ptep) | (addr & INTEL_OFFMASK);
	}
	if (0 == pa)
		kprintf("kvtophys ret 0!\n");
	return (pa);
}
Commit	Line	Data
1c79356b	1	/*
91447636	2	* Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
1c79356b	3	*
8f6c56a5	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
1c79356b	5	*
8f6c56a5 A	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
	14	*
	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
8ad349bb	24	* limitations under the License.
8f6c56a5 A	25	*
8f6c56a5 A	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
1c79356b A	27	*/
	28	/*
	29	* @OSF_COPYRIGHT@
	30	*/
	31	/*
	32	* Mach Operating System
	33	* Copyright (c) 1991,1990,1989 Carnegie Mellon University
	34	* All Rights Reserved.
	35	*
	36	* Permission to use, copy, modify and distribute this software and its
	37	* documentation is hereby granted, provided that both the copyright
	38	* notice and this permission notice appear in all copies of the
	39	* software, derivative works or modified versions, and any portions
	40	* thereof, and that both notices appear in supporting documentation.
	41	*
	42	* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
	43	* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
	44	* ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
	45	*
	46	* Carnegie Mellon requests users of this software to return to
	47	*
	48	* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
	49	* School of Computer Science
	50	* Carnegie Mellon University
	51	* Pittsburgh PA 15213-3890
	52	*
	53	* any improvements or extensions that they make and grant Carnegie Mellon
	54	* the rights to redistribute these changes.
	55	*/
1c79356b	56
91447636 A	57	#include <mach_rt.h>
	58	#include <mach_debug.h>
	59	#include <mach_ldebug.h>
	60
	61	#include <sys/kdebug.h>
	62
	63	#include <mach/kern_return.h>
	64	#include <mach/thread_status.h>
1c79356b	65	#include <mach/vm_param.h>
91447636 A	66
	67	#include <kern/counters.h>
	68	#include <kern/mach_param.h>
	69	#include <kern/task.h>
	70	#include <kern/thread.h>
	71	#include <kern/sched_prim.h>
1c79356b	72	#include <kern/misc_protos.h>
91447636 A	73	#include <kern/assert.h>
	74	#include <kern/spl.h>
	75	#include <ipc/ipc_port.h>
	76	#include <vm/vm_kern.h>
	77	#include <vm/vm_map.h>
	78	#include <vm/pmap.h>
	79
	80	#include <i386/cpu_data.h>
	81	#include <i386/cpu_number.h>
	82	#include <i386/thread.h>
	83	#include <i386/eflags.h>
	84	#include <i386/proc_reg.h>
	85	#include <i386/seg.h>
	86	#include <i386/tss.h>
	87	#include <i386/user_ldt.h>
	88	#include <i386/fpu.h>
	89	#include <i386/iopb_entries.h>
	90	#include <i386/misc_protos.h>
1c79356b A	91
	92	/*
	93	* pmap_zero_page zeros the specified (machine independent) page.
	94	*/
	95	void
	96	pmap_zero_page(
55e303ae	97	ppnum_t pn)
1c79356b	98	{
55e303ae	99	assert(pn != vm_page_fictitious_addr);
91447636	100	bzero_phys((addr64_t)i386_ptob(pn), PAGE_SIZE);
1c79356b A	101	}
	102
	103	/*
	104	* pmap_zero_part_page
	105	* zeros the specified (machine independent) part of a page.
	106	*/
	107	void
	108	pmap_zero_part_page(
55e303ae	109	ppnum_t pn,
1c79356b A	110	vm_offset_t offset,
	111	vm_size_t len)
	112	{
55e303ae	113	assert(pn != vm_page_fictitious_addr);
1c79356b	114	assert(offset + len <= PAGE_SIZE);
91447636	115	bzero_phys((addr64_t)(i386_ptob(pn) + offset), len);
1c79356b A	116	}
	117
	118	/*
	119	* pmap_copy_page copies the specified (machine independent) pages.
	120	*/
	121	void
	122	pmap_copy_part_page(
55e303ae	123	ppnum_t psrc,
1c79356b	124	vm_offset_t src_offset,
55e303ae	125	ppnum_t pdst,
1c79356b A	126	vm_offset_t dst_offset,
	127	vm_size_t len)
	128	{
8f6c56a5	129	vm_offset_t src, dst;
55e303ae A	130	assert(psrc != vm_page_fictitious_addr);
55e303ae A	131	assert(pdst != vm_page_fictitious_addr);
8f6c56a5 A	132	src = (vm_offset_t)i386_ptob(psrc);
	133	dst = (vm_offset_t)i386_ptob(pdst);
	134	assert(((dst & PAGE_MASK) + dst_offset + len) <= PAGE_SIZE);
	135	assert(((src & PAGE_MASK) + src_offset + len) <= PAGE_SIZE);
91447636 A	136	bcopy_phys((addr64_t)src + (src_offset & INTEL_OFFMASK),
	137	(addr64_t)dst + (dst_offset & INTEL_OFFMASK),
	138	len);
1c79356b A	139	}
	140
	141	/*
	142	* pmap_copy_part_lpage copies part of a virtually addressed page
	143	* to a physically addressed page.
	144	*/
	145	void
	146	pmap_copy_part_lpage(
55e303ae A	147	vm_offset_t src,
55e303ae A	148	ppnum_t pdst,
1c79356b A	149	vm_offset_t dst_offset,
	150	vm_size_t len)
	151	{
8f6c56a5 A	152	pt_entry_t *ptep;
8f6c56a5 A	153	thread_t thr_act = current_thread();
55e303ae	154
55e303ae	155	assert(pdst != vm_page_fictitious_addr);
8f6c56a5 A	156	ptep = pmap_pte(thr_act->map->pmap, i386_ptob(pdst));
	157	if (0 == ptep)
	158	panic("pmap_copy_part_lpage ptep");
	159	assert(((pdst & PAGE_MASK) + dst_offset + len) <= PAGE_SIZE);
	160	if ((pt_entry_t ) CM2)
	161	panic("pmap_copy_part_lpage");
	162	(int ) CM2 = INTEL_PTE_VALID \| INTEL_PTE_RW \| (*ptep & PG_FRAME) \|
	163	INTEL_PTE_REF \| INTEL_PTE_MOD;
	164	invlpg((unsigned int) CA2);
	165	memcpy((void ) (CA2 + (dst_offset & INTEL_OFFMASK)), (void ) src, len);
	166	(pt_entry_t ) CM2 = 0;
1c79356b A	167	}
	168
	169	/*
	170	* pmap_copy_part_rpage copies part of a physically addressed page
	171	* to a virtually addressed page.
	172	*/
	173	void
	174	pmap_copy_part_rpage(
55e303ae	175	ppnum_t psrc,
1c79356b A	176	vm_offset_t src_offset,
	177	vm_offset_t dst,
	178	vm_size_t len)
	179	{
8f6c56a5 A	180	pt_entry_t *ptep;
8f6c56a5 A	181	thread_t thr_act = current_thread();
55e303ae A	182
55e303ae A	183	assert(psrc != vm_page_fictitious_addr);
8f6c56a5 A	184	ptep = pmap_pte(thr_act->map->pmap, i386_ptob(psrc));
	185	if (0 == ptep)
	186	panic("pmap_copy_part_rpage ptep");
	187	assert(((psrc & PAGE_MASK) + src_offset + len) <= PAGE_SIZE);
	188	if ((pt_entry_t ) CM2)
	189	panic("pmap_copy_part_rpage");
	190	(pt_entry_t ) CM2 = INTEL_PTE_VALID \| INTEL_PTE_RW \| (*ptep & PG_FRAME) \|
	191	INTEL_PTE_REF;
	192	invlpg((unsigned int) CA2);
	193	memcpy((void ) dst, (void ) (CA2 + (src_offset & INTEL_OFFMASK)), len);
	194	(pt_entry_t ) CM2 = 0;
1c79356b A	195	}
	196
	197	/*
	198	* kvtophys(addr)
	199	*
	200	* Convert a kernel virtual address to a physical address
	201	*/
8f6c56a5	202	vm_offset_t
1c79356b A	203	kvtophys(
	204	vm_offset_t addr)
	205	{
91447636 A	206	pt_entry_t *ptep;
	207	pmap_paddr_t pa;
	208
8f6c56a5 A	209	if ((ptep = pmap_pte(kernel_pmap, addr)) == PT_ENTRY_NULL) {
8f6c56a5 A	210	pa = 0;
91447636	211	} else {
8f6c56a5	212	pa = pte_to_pa(*ptep) \| (addr & INTEL_OFFMASK);
91447636	213	}
8f6c56a5 A	214	if (0 == pa)
	215	kprintf("kvtophys ret 0!\n");
	216	return (pa);
1c79356b	217	}