[apple/xnu.git] / bsd / vm / dp_backing_file.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This 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 OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */

#include <mach/boolean.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/lock.h>
#include <sys/proc.h>
#include <sys/buf.h>
#include <sys/uio.h>
#include <sys/vnode.h>
#include <sys/namei.h>
#include <sys/ubc.h>

#include <mach/mach_types.h>
#include <vm/vm_map.h>
#include <vm/vm_kern.h>
#include <kern/host.h>
#include <kern/parallel.h>
#include <kern/zalloc.h>
#include <kern/kalloc.h>
#include <libkern/libkern.h>
#include <sys/malloc.h>

#include <vm/vnode_pager.h>

/*
 * temporary support for delayed instantiation
 * of default_pager
 */
int default_pager_init_flag = 0;

struct bs_map		bs_port_table[MAX_BACKING_STORE] = { 
	{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
	{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
	{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
	{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
	{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
	{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
	{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
	{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
	{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
	{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}};

/* ###################################################### */


#include <kern/assert.h>

/*
 *	Routine:	macx_swapon
 *	Function:
 *		Syscall interface to add a file to backing store
 */
int
macx_swapon(
	char 	*filename,
	int	flags,
	long	size,
	long	priority)
{
	struct vnode		*vp = 0; 
	struct nameidata 	nd, *ndp;
	struct proc		*p =  current_proc();
	pager_file_t		pf;
	register int		error;
	kern_return_t		kr;
	mach_port_t		backing_store;
	mach_port_t		default_pager_port = MACH_PORT_NULL;
	int			i;
	boolean_t		funnel_state;

	struct vattr	vattr;

	funnel_state = thread_funnel_set(kernel_flock, TRUE);
	ndp = &nd;

	if ((error = suser(p->p_ucred, &p->p_acflag)))
		goto swapon_bailout;

	unix_master();

	if(default_pager_init_flag == 0) {
		start_def_pager(NULL);
		default_pager_init_flag = 1;
	}

	/*
	 * Get a vnode for the paging area.
	 */
	NDINIT(ndp, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
	    filename, p);

	if ((error = namei(ndp)))
		goto swapon_bailout;
	vp = ndp->ni_vp;

	if (vp->v_type != VREG) {
		error = EINVAL;
	        VOP_UNLOCK(vp, 0, p);
		goto swapon_bailout;
	}
	UBCINFOCHECK("macx_swapon", vp);

	if (error = VOP_GETATTR(vp, &vattr, p->p_ucred, p)) {
	        VOP_UNLOCK(vp, 0, p);
		goto swapon_bailout;
	}

	if (vattr.va_size < (u_quad_t)size) {
		vattr_null(&vattr);
		vattr.va_size = (u_quad_t)size;
		error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
		if (error) {
			VOP_UNLOCK(vp, 0, p);
			goto swapon_bailout;
		}
	}

	/* add new backing store to list */
	i = 0;
	while(bs_port_table[i].vp != 0) {
		if(i == MAX_BACKING_STORE)
			break;
		i++;
	}
	if(i == MAX_BACKING_STORE) {
	   	error = ENOMEM;
	        VOP_UNLOCK(vp, 0, p);
		goto swapon_bailout;
	}

	/* remember the vnode. This vnode has namei() reference */
	bs_port_table[i].vp = vp;
	
	/*
	 * Look to see if we are already paging to this file.
	 */
	/* make certain the copy send of kernel call will work */
	kr = host_default_memory_manager(host_priv_self(), &default_pager_port, 0);
	if(kr != KERN_SUCCESS) {
	   error = EAGAIN;
	   VOP_UNLOCK(vp, 0, p);
	   bs_port_table[i].vp = 0;
	   goto swapon_bailout;
	}

	kr = default_pager_backing_store_create(default_pager_port, 
					-1, /* default priority */
					0, /* default cluster size */
					&backing_store);
	if(kr != KERN_SUCCESS) {
	   error = ENOMEM;
	   VOP_UNLOCK(vp, 0, p);
	   bs_port_table[i].vp = 0;
	   goto swapon_bailout;
	}

	/*
	 * NOTE: we are able to supply PAGE_SIZE here instead of
	 *	an actual record size or block number because:
	 *	a: we do not support offsets from the beginning of the
	 *		file (allowing for non page size/record modulo offsets.
	 *	b: because allow paging will be done modulo page size
	 */

	VOP_UNLOCK(vp, 0, p);
	kr = default_pager_add_file(backing_store, vp, PAGE_SIZE, 
			((int)vattr.va_size)/PAGE_SIZE);
	if(kr != KERN_SUCCESS) {
	   bs_port_table[i].vp = 0;
	   if(kr == KERN_INVALID_ARGUMENT)
		error = EINVAL;
	   else 
		error = ENOMEM;
	   goto swapon_bailout;
	}
	bs_port_table[i].bs = (void *)backing_store;
	error = 0;
	if (!ubc_hold(vp))
		panic("macx_swapon: hold");

	/* Mark this vnode as being used for swapfile */
	SET(vp->v_flag, VSWAP);

	/*
	 * take an extra reference on the vnode to keep
	 * vnreclaim() away from this vnode.
	 */
	VREF(vp);

	/* Hold on to the namei  reference to the paging file vnode */
	vp = 0;

swapon_bailout:
	if (vp) {
		vrele(vp);
	}
	unix_release();
	(void) thread_funnel_set(kernel_flock, FALSE);
	return(error);
}

/*
 *	Routine:	macx_swapoff
 *	Function:
 *		Syscall interface to remove a file from backing store
 */
int
macx_swapoff(
	char 	*filename,
	int	flags)
{
	kern_return_t	kr;
	mach_port_t	backing_store;

	struct vnode		*vp = 0; 
	struct nameidata 	nd, *ndp;
	struct proc		*p =  current_proc();
	int			i;
	int			error;
	boolean_t		funnel_state;

	funnel_state = thread_funnel_set(kernel_flock, TRUE);
	backing_store = NULL;
	ndp = &nd;

	if ((error = suser(p->p_ucred, &p->p_acflag)))
		goto swapoff_bailout;

	unix_master();

	/*
	 * Get the vnode for the paging area.
	 */
	NDINIT(ndp, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
	    filename, p);

	if ((error = namei(ndp)))
		goto swapoff_bailout;
	vp = ndp->ni_vp;

	if (vp->v_type != VREG) {
		error = EINVAL;
		VOP_UNLOCK(vp, 0, p);
		goto swapoff_bailout;
	}

	for(i = 0; i < MAX_BACKING_STORE; i++) {
		if(bs_port_table[i].vp == vp) {
			backing_store; 
			break;
		}
	}
	if (i == MAX_BACKING_STORE) {
		error = EINVAL;
		VOP_UNLOCK(vp, 0, p);
		goto swapoff_bailout;
	}
	backing_store = (mach_port_t)bs_port_table[i].bs;

	VOP_UNLOCK(vp, 0, p);
	kr = default_pager_backing_store_delete(backing_store);
	switch (kr) {
		case KERN_SUCCESS:
			error = 0;
			bs_port_table[i].vp = 0;
			ubc_rele(vp);
			/* This vnode is no longer used for swapfile */
			CLR(vp->v_flag, VSWAP);

			/* get rid of macx_swapon() namei() reference */
			vrele(vp);

			/* get rid of macx_swapon() "extra" reference */
			vrele(vp);
			break;
		case KERN_FAILURE:
			error = EAGAIN;
			break;
		default:
			error = EAGAIN;
			break;
	}

swapoff_bailout:
	/* get rid of macx_swapoff() namei() reference */
	if (vp)
		vrele(vp);

	unix_release();
	(void) thread_funnel_set(kernel_flock, FALSE);
	return(error);
}
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22
	23	#include <mach/boolean.h>
	24	#include <sys/param.h>
	25	#include <sys/systm.h>
	26	#include <sys/lock.h>
	27	#include <sys/proc.h>
	28	#include <sys/buf.h>
	29	#include <sys/uio.h>
	30	#include <sys/vnode.h>
	31	#include <sys/namei.h>
	32	#include <sys/ubc.h>
	33
	34	#include <mach/mach_types.h>
	35	#include <vm/vm_map.h>
	36	#include <vm/vm_kern.h>
	37	#include <kern/host.h>
	38	#include <kern/parallel.h>
	39	#include <kern/zalloc.h>
	40	#include <kern/kalloc.h>
	41	#include <libkern/libkern.h>
	42	#include <sys/malloc.h>
	43
	44	#include <vm/vnode_pager.h>
	45
	46	/*
	47	* temporary support for delayed instantiation
	48	* of default_pager
	49	*/
	50	int default_pager_init_flag = 0;
	51
	52	struct bs_map bs_port_table[MAX_BACKING_STORE] = {
	53	{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
	54	{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
	55	{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
	56	{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
	57	{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
	58	{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
	59	{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
	60	{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
	61	{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},
	62	{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}};
	63
	64	/* ###################################################### */
65
66
67	#include <kern/assert.h>
68
69	/*
70	* Routine: macx_swapon
71	* Function:
72	* Syscall interface to add a file to backing store
73	*/
74	int
75	macx_swapon(
76	char *filename,
77	int flags,
78	long size,
79	long priority)
80	{
81	struct vnode *vp = 0;
82	struct nameidata nd, *ndp;
83	struct proc *p = current_proc();
84	pager_file_t pf;
85	register int error;
86	kern_return_t kr;
87	mach_port_t backing_store;
88	mach_port_t default_pager_port = MACH_PORT_NULL;
89	int i;
90	boolean_t funnel_state;
91
92	struct vattr vattr;
93
94	funnel_state = thread_funnel_set(kernel_flock, TRUE);
95	ndp = &nd;
96
97	if ((error = suser(p->p_ucred, &p->p_acflag)))
98	goto swapon_bailout;
99
100	unix_master();
101
102	if(default_pager_init_flag == 0) {
103	start_def_pager(NULL);
104	default_pager_init_flag = 1;
105	}
106
107	/*
108	* Get a vnode for the paging area.
109	*/
110	NDINIT(ndp, LOOKUP, FOLLOW \| LOCKLEAF, UIO_USERSPACE,
111	filename, p);
112
113	if ((error = namei(ndp)))
114	goto swapon_bailout;
115	vp = ndp->ni_vp;
116
117	if (vp->v_type != VREG) {
118	error = EINVAL;
119	VOP_UNLOCK(vp, 0, p);
120	goto swapon_bailout;
121	}
122	UBCINFOCHECK("macx_swapon", vp);
123
124	if (error = VOP_GETATTR(vp, &vattr, p->p_ucred, p)) {
125	VOP_UNLOCK(vp, 0, p);
126	goto swapon_bailout;
127	}
128
129	if (vattr.va_size < (u_quad_t)size) {
130	vattr_null(&vattr);
131	vattr.va_size = (u_quad_t)size;
132	error = VOP_SETATTR(vp, &vattr, p->p_ucred, p);
133	if (error) {
134	VOP_UNLOCK(vp, 0, p);
135	goto swapon_bailout;
136	}
137	}
138
139	/* add new backing store to list */
140	i = 0;
141	while(bs_port_table[i].vp != 0) {
142	if(i == MAX_BACKING_STORE)
143	break;
144	i++;
145	}
146	if(i == MAX_BACKING_STORE) {
147	error = ENOMEM;
148	VOP_UNLOCK(vp, 0, p);
149	goto swapon_bailout;
150	}
151
152	/* remember the vnode. This vnode has namei() reference */
153	bs_port_table[i].vp = vp;
154
155	/*
156	* Look to see if we are already paging to this file.
157	*/
158	/* make certain the copy send of kernel call will work */
159	kr = host_default_memory_manager(host_priv_self(), &default_pager_port, 0);
160	if(kr != KERN_SUCCESS) {
161	error = EAGAIN;
162	VOP_UNLOCK(vp, 0, p);
163	bs_port_table[i].vp = 0;
164	goto swapon_bailout;
165	}
166
167	kr = default_pager_backing_store_create(default_pager_port,
168	-1, /* default priority */
169	0, /* default cluster size */
170	&backing_store);
171	if(kr != KERN_SUCCESS) {
172	error = ENOMEM;
173	VOP_UNLOCK(vp, 0, p);
174	bs_port_table[i].vp = 0;
175	goto swapon_bailout;
176	}
177
178	/*
179	* NOTE: we are able to supply PAGE_SIZE here instead of
180	* an actual record size or block number because:
181	* a: we do not support offsets from the beginning of the
182	* file (allowing for non page size/record modulo offsets.
183	* b: because allow paging will be done modulo page size
184	*/
185
186	VOP_UNLOCK(vp, 0, p);
187	kr = default_pager_add_file(backing_store, vp, PAGE_SIZE,
188	((int)vattr.va_size)/PAGE_SIZE);
189	if(kr != KERN_SUCCESS) {
190	bs_port_table[i].vp = 0;
191	if(kr == KERN_INVALID_ARGUMENT)
192	error = EINVAL;
193	else
194	error = ENOMEM;
195	goto swapon_bailout;
196	}
197	bs_port_table[i].bs = (void *)backing_store;
198	error = 0;
199	if (!ubc_hold(vp))
200	panic("macx_swapon: hold");
201
202	/* Mark this vnode as being used for swapfile */
203	SET(vp->v_flag, VSWAP);
204
205	/*
206	* take an extra reference on the vnode to keep
207	* vnreclaim() away from this vnode.
208	*/
209	VREF(vp);
210
211	/* Hold on to the namei reference to the paging file vnode */
212	vp = 0;
213
214	swapon_bailout:
215	if (vp) {
216	vrele(vp);
217	}
218	unix_release();
219	(void) thread_funnel_set(kernel_flock, FALSE);
220	return(error);
221	}
222
223	/*
224	* Routine: macx_swapoff
225	* Function:
226	* Syscall interface to remove a file from backing store
227	*/
228	int
229	macx_swapoff(
230	char *filename,
231	int flags)
232	{
233	kern_return_t kr;
234	mach_port_t backing_store;
235
236	struct vnode *vp = 0;
237	struct nameidata nd, *ndp;
238	struct proc *p = current_proc();
239	int i;
240	int error;
241	boolean_t funnel_state;
242
243	funnel_state = thread_funnel_set(kernel_flock, TRUE);
244	backing_store = NULL;
245	ndp = &nd;
246
247	if ((error = suser(p->p_ucred, &p->p_acflag)))
248	goto swapoff_bailout;
249
250	unix_master();
251
252	/*
253	* Get the vnode for the paging area.
254	*/
255	NDINIT(ndp, LOOKUP, FOLLOW \| LOCKLEAF, UIO_USERSPACE,
256	filename, p);
257
258	if ((error = namei(ndp)))
259	goto swapoff_bailout;
260	vp = ndp->ni_vp;
261
262	if (vp->v_type != VREG) {
263	error = EINVAL;
264	VOP_UNLOCK(vp, 0, p);
265	goto swapoff_bailout;
266	}
267
268	for(i = 0; i < MAX_BACKING_STORE; i++) {
269	if(bs_port_table[i].vp == vp) {
270	backing_store;
271	break;
272	}
273	}
274	if (i == MAX_BACKING_STORE) {
275	error = EINVAL;
276	VOP_UNLOCK(vp, 0, p);
277	goto swapoff_bailout;
278	}
279	backing_store = (mach_port_t)bs_port_table[i].bs;
280
281	VOP_UNLOCK(vp, 0, p);
282	kr = default_pager_backing_store_delete(backing_store);
283	switch (kr) {
284	case KERN_SUCCESS:
285	error = 0;
286	bs_port_table[i].vp = 0;
287	ubc_rele(vp);
288	/* This vnode is no longer used for swapfile */
289	CLR(vp->v_flag, VSWAP);
290
291	/* get rid of macx_swapon() namei() reference */
292	vrele(vp);
293
294	/* get rid of macx_swapon() "extra" reference */
295	vrele(vp);
296	break;
297	case KERN_FAILURE:
298	error = EAGAIN;
299	break;
300	default:
301	error = EAGAIN;
302	break;
303	}
304
305	swapoff_bailout:
306	/* get rid of macx_swapoff() namei() reference */
307	if (vp)
308	vrele(vp);
309
310	unix_release();
311	(void) thread_funnel_set(kernel_flock, FALSE);
312	return(error);
313	}