[apple/xnu.git] / osfmk / kern / ledger.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@
 */
/*
 * @OSF_COPYRIGHT@
 */
/*
 * HISTORY
 * 
 * Revision 1.1.1.1  1998/09/22 21:05:34  wsanchez
 * Import of Mac OS X kernel (~semeria)
 *
 * Revision 1.1.1.1  1998/03/07 02:25:55  wsanchez
 * Import of OSF Mach kernel (~mburg)
 *
 * Revision 1.1.6.1  1995/01/06  19:47:19  devrcs
 * 	mk6 CR668 - 1.3b26 merge
 * 	new file for mk6
 * 	[1994/10/12  22:19:28  dwm]
 *
 * Revision 1.1.3.4  1994/05/13  20:10:01  tmt
 * 	Changed three unsigned casts to natural_t.
 * 	[1994/05/12  22:12:28  tmt]
 * 
 * Revision 1.1.3.2  1993/11/30  18:26:24  jph
 * 	CR10228 -- Typo in unlock(), ledger_ledger should be child_ledger.
 * 	[1993/11/30  16:10:43  jph]
 * 
 * Revision 1.1.3.1  1993/11/24  21:22:14  jph
 * 	CR9801 brezak merge, ledgers, security and NMK15_COMPAT
 * 	[1993/11/23  22:41:07  jph]
 * 
 * Revision 1.1.1.4  1993/09/08  14:17:36  brezak
 * 	Include <mach/ledger_server.h> for protos.
 * 
 * Revision 1.1.1.3  1993/08/20  14:16:55  brezak
 * 	Created.
 * 
 * $EndLog$
 */

/*
 * 8/13/93
 * 
 * This is a half-hearted attempt at providing the parts of the
 * ledger facility to satisfy the ledger interfaces.
 *
 * This implementation basically leaves the (dysfunctional) ledgers
 * unfunctional and are mearly here to satisfy the Mach spec interface
 * reqirements.
 */

#include <mach/mach_types.h>
#include <mach/message.h>
#include <kern/mach_param.h>
#include <kern/misc_protos.h>
#include <mach/port.h>
#include <kern/lock.h>
#include <kern/ipc_kobject.h>
#include <ipc/ipc_space.h>
#include <ipc/ipc_port.h>
#include <kern/host.h>
#include <kern/ledger.h>
#include <mach/ledger_server.h>

ledger_t	root_wired_ledger;
ledger_t	root_paged_ledger;


/* Utility routine to handle entries to a ledger */
kern_return_t
ledger_enter(
	     ledger_t		ledger,
	     ledger_item_t	amount)
{
	/* Need to lock the ledger */
	ledger_lock(ledger);
	
	if (amount > 0) {
		if (ledger->ledger_limit != LEDGER_ITEM_INFINITY &&
		    ledger->ledger_balance + amount > ledger->ledger_limit) {
			/* XXX this is where you do BAD things */
			printf("Ledger limit exceeded ! ledger=%x lim=%d balance=%d\n",
			       ledger, ledger->ledger_limit,
			       ledger->ledger_balance);
			ledger_unlock(ledger);
			return(KERN_RESOURCE_SHORTAGE);
		}
		if ((natural_t)(ledger->ledger_balance + amount) 
			< LEDGER_ITEM_INFINITY)
			ledger->ledger_balance += amount;
		else
			ledger->ledger_balance = LEDGER_ITEM_INFINITY;
	}
	else if (amount) {
		if (ledger->ledger_balance + amount > 0)
			ledger->ledger_balance += amount;
		else
			ledger->ledger_balance = 0;
	}
	ledger_unlock(ledger);
	return(KERN_SUCCESS);
}

/* Utility routine to create a new ledger */
static ledger_t
ledger_allocate(
		ledger_item_t	limit,
		ledger_t	ledger_ledger,
		ledger_t	ledger_parent)
{
	ledger_t	ledger;

	ledger = (ledger_t)kalloc(sizeof(ledger_data_t));
	if (ledger == LEDGER_NULL)
		return(LEDGER_NULL);

	ledger->ledger_self = ipc_port_alloc_kernel();
	if (ledger->ledger_self == IP_NULL)
		return(LEDGER_NULL);

	ledger_lock_init(ledger);
	ledger->ledger_limit = limit;
	ledger->ledger_balance = 0;
	ledger->ledger_service_port = MACH_PORT_NULL;
	ledger->ledger_ledger = ledger_ledger;
	ledger->ledger_parent = ledger_parent;
	ipc_kobject_set(ledger->ledger_self, (ipc_kobject_t)ledger,
			IKOT_LEDGER);

	return(ledger);
}

/* Utility routine to destroy a ledger */
static void
ledger_deallocate(
		  ledger_t	ledger)
{
	/* XXX can be many send rights (copies) of this */
	ipc_port_dealloc_kernel(ledger->ledger_self);

	/* XXX release send right on service port */
	kfree((vm_offset_t)ledger, sizeof(*ledger));
}


/*
 * Inititalize the ledger facility
 */
void ledger_init(void)
{
	/*
	 * Allocate the root ledgers; wired and paged.
	 */
	root_wired_ledger = ledger_allocate(LEDGER_ITEM_INFINITY,
					    LEDGER_NULL, LEDGER_NULL);
	if (root_wired_ledger == LEDGER_NULL)
		panic("can't allocate root (wired) ledger");
	ipc_port_make_send(root_wired_ledger->ledger_self);

	root_paged_ledger = ledger_allocate(LEDGER_ITEM_INFINITY,
					    LEDGER_NULL, LEDGER_NULL);
	if (root_paged_ledger == LEDGER_NULL)
		panic("can't allocate root (paged) ledger");
	ipc_port_make_send(root_paged_ledger->ledger_self);
}

/*
 *	Create a subordinate ledger
 */
kern_return_t ledger_create(
			    ledger_t parent_ledger,
			    ledger_t ledger_ledger,
			    ledger_t *new_ledger,
			    ledger_item_t transfer)
{
	if (parent_ledger == LEDGER_NULL)
		return(KERN_INVALID_ARGUMENT);

	if (ledger_ledger == LEDGER_NULL)
		return(KERN_INVALID_LEDGER);

	/*
	 * Allocate a new ledger and change the ledger_ledger for
	 * its space.
	 */
	ledger_lock(ledger_ledger);
	if ((ledger_ledger->ledger_limit != LEDGER_ITEM_INFINITY) &&
	    (ledger_ledger->ledger_balance + sizeof(ledger_data_t) >
	     ledger_ledger->ledger_limit)) {
		ledger_unlock(ledger_ledger);
		return(KERN_RESOURCE_SHORTAGE);
	}

	*new_ledger = ledger_allocate(LEDGER_ITEM_INFINITY, ledger_ledger, parent_ledger);
	if (*new_ledger == LEDGER_NULL) {
		ledger_unlock(ledger_ledger);
		return(KERN_RESOURCE_SHORTAGE);
	}
	
	/*
	 * Now transfer the limit for the new ledger from the parent
	 */
	ledger_lock(parent_ledger);
	if (parent_ledger->ledger_limit != LEDGER_ITEM_INFINITY) {
		/* Would the existing balance exceed the new limit ? */
		if (parent_ledger->ledger_limit - transfer < parent_ledger->ledger_balance) {
			ledger_unlock(parent_ledger);
			ledger_unlock(ledger_ledger);
			return(KERN_RESOURCE_SHORTAGE);
		}
		if (parent_ledger->ledger_limit - transfer > 0)
			parent_ledger->ledger_limit -= transfer;
		else
			parent_ledger->ledger_limit = 0;
	}
	(*new_ledger)->ledger_limit = transfer;

	/* Charge the ledger against the ledger_ledger */
	ledger_ledger->ledger_balance += sizeof(ledger_data_t);
	ledger_unlock(parent_ledger);

	ledger_unlock(ledger_ledger);
	
	return(KERN_SUCCESS);
}

/*
 *	Destroy a ledger
 */
kern_return_t ledger_terminate(
			       ledger_t ledger)
{
	if (ledger == LEDGER_NULL)
		return(KERN_INVALID_ARGUMENT);
	
	/* You can't deallocate kernel ledgers */
	if (ledger == root_wired_ledger ||
	    ledger == root_paged_ledger)
		return(KERN_INVALID_LEDGER);

	/* Lock the ledger */
	ledger_lock(ledger);
	
	/* the parent ledger gets back the limit */
	ledger_lock(ledger->ledger_parent);
	if (ledger->ledger_parent->ledger_limit != LEDGER_ITEM_INFINITY) {
		assert((natural_t)(ledger->ledger_parent->ledger_limit +
				  ledger->ledger_limit) <
		       LEDGER_ITEM_INFINITY);
		ledger->ledger_parent->ledger_limit += ledger->ledger_limit;
	}
	ledger_unlock(ledger->ledger_parent);

	/*
	 * XXX The spec says that you have to destroy all objects that
	 * have been created with this ledger. Nice work eh? For now
	 * Transfer the balance to the parent and let it worry about
	 * it.
	 */
	/* XXX the parent ledger inherits the debt ?? */
	(void) ledger_enter(ledger->ledger_parent, ledger->ledger_balance);
	
	/* adjust the balance of the creation ledger */
	(void) ledger_enter(ledger->ledger_ledger, -sizeof(*ledger));

	/* delete the ledger */
	ledger_deallocate(ledger);

	return(KERN_SUCCESS);
}

/*
 *	Return the ledger limit and balance
 */
kern_return_t ledger_read(
			  ledger_t ledger,
			  ledger_item_t *balance,
			  ledger_item_t *limit)
{
	if (ledger == LEDGER_NULL)
		return(KERN_INVALID_ARGUMENT);
	
	ledger_lock(ledger);
	*balance = ledger->ledger_balance;
	*limit = ledger->ledger_limit;
	ledger_unlock(ledger);

	return(KERN_SUCCESS);
}

/*
 *	Transfer resources from a parent ledger to a child
 */
kern_return_t ledger_transfer(
			      ledger_t parent_ledger,
			      ledger_t child_ledger,
			      ledger_item_t transfer)
{
#define abs(v)	((v) > 0)?(v):-(v)
	
	ledger_t src, dest;
	ledger_item_t amount = abs(transfer);
	
	if (parent_ledger == LEDGER_NULL)
		return(KERN_INVALID_ARGUMENT);

	if (child_ledger == LEDGER_NULL)
		return(KERN_INVALID_ARGUMENT);

	/* Must be different ledgers */
	if (parent_ledger == child_ledger)
		return(KERN_INVALID_ARGUMENT);

	if (transfer == 0)
		return(KERN_SUCCESS);
	
	ledger_lock(child_ledger);
	ledger_lock(parent_ledger);

	/* XXX Should be the parent you created it from ?? */
	if (parent_ledger != child_ledger->ledger_parent) {
		ledger_unlock(parent_ledger);
		ledger_unlock(child_ledger);
		return(KERN_INVALID_LEDGER);
	}

	if (transfer > 0) {
		dest = child_ledger;
		src = parent_ledger;
	}
	else {
		src = child_ledger;
		dest = parent_ledger;
	}

	if (src->ledger_limit != LEDGER_ITEM_INFINITY) {
		/* Would the existing balance exceed the new limit ? */
		if (src->ledger_limit - amount < src->ledger_balance) {
			ledger_unlock(parent_ledger);
			ledger_unlock(child_ledger);
			return(KERN_RESOURCE_SHORTAGE);
		}
		if (src->ledger_limit - amount > 0)
			src->ledger_limit -= amount;
		else
			src->ledger_limit = 0;
	}

	if (dest->ledger_limit != LEDGER_ITEM_INFINITY) {
		if ((natural_t)(dest->ledger_limit + amount) 
			< LEDGER_ITEM_INFINITY)
			dest->ledger_limit += amount;
		else
			dest->ledger_limit = (LEDGER_ITEM_INFINITY - 1);
	}

	ledger_unlock(parent_ledger);
	ledger_unlock(child_ledger);
	
	return(KERN_SUCCESS);
#undef abs
}

/*
 *	Routine:	convert_port_to_ledger
 *	Purpose:
 *		Convert from a port to a ledger.
 *		Doesn't consume the port ref; the ledger produced may be null.
 *	Conditions:
 *		Nothing locked.
 */

ledger_t
convert_port_to_ledger(
		       ipc_port_t port)
{
	ledger_t ledger = LEDGER_NULL;

	if (IP_VALID(port)) {
		ip_lock(port);
		if (ip_active(port) &&
		    (ip_kotype(port) == IKOT_LEDGER))
			ledger = (ledger_t) port->ip_kobject;
		ip_unlock(port);
	}

	return ledger;
}

/*
 *	Routine:	convert_ledger_to_port
 *	Purpose:
 *		Convert from a ledger to a port.
 *		Produces a naked send right which may be invalid.
 *	Conditions:
 *		Nothing locked.
 */

ipc_port_t
convert_ledger_to_port(
		       ledger_t ledger)
{
	ipc_port_t port;

	port = ipc_port_make_send(ledger->ledger_self);

	return port;
}

/*
 * Copy a ledger
 */
ipc_port_t
ledger_copy(
	    ledger_t ledger)
{
	/* XXX reference counting */
	assert(ledger);
	return(ipc_port_copy_send(ledger->ledger_self));
}
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
e5568f75 A	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
1c79356b A	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
1c79356b A	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
e5568f75 A	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.
1c79356b A	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/*
	23	* @OSF_COPYRIGHT@
	24	*/
	25	/*
	26	* HISTORY
	27	*
	28	* Revision 1.1.1.1 1998/09/22 21:05:34 wsanchez
	29	* Import of Mac OS X kernel (~semeria)
	30	*
	31	* Revision 1.1.1.1 1998/03/07 02:25:55 wsanchez
	32	* Import of OSF Mach kernel (~mburg)
	33	*
	34	* Revision 1.1.6.1 1995/01/06 19:47:19 devrcs
	35	* mk6 CR668 - 1.3b26 merge
	36	* new file for mk6
	37	* [1994/10/12 22:19:28 dwm]
	38	*
	39	* Revision 1.1.3.4 1994/05/13 20:10:01 tmt
	40	* Changed three unsigned casts to natural_t.
	41	* [1994/05/12 22:12:28 tmt]
	42	*
	43	* Revision 1.1.3.2 1993/11/30 18:26:24 jph
	44	* CR10228 -- Typo in unlock(), ledger_ledger should be child_ledger.
	45	* [1993/11/30 16:10:43 jph]
	46	*
	47	* Revision 1.1.3.1 1993/11/24 21:22:14 jph
	48	* CR9801 brezak merge, ledgers, security and NMK15_COMPAT
	49	* [1993/11/23 22:41:07 jph]
	50	*
	51	* Revision 1.1.1.4 1993/09/08 14:17:36 brezak
	52	* Include <mach/ledger_server.h> for protos.
	53	*
	54	* Revision 1.1.1.3 1993/08/20 14:16:55 brezak
	55	* Created.
	56	*
	57	* $EndLog$
	58	*/
	59
	60	/*
	61	* 8/13/93
	62	*
	63	* This is a half-hearted attempt at providing the parts of the
	64	* ledger facility to satisfy the ledger interfaces.
	65	*
	66	* This implementation basically leaves the (dysfunctional) ledgers
	67	* unfunctional and are mearly here to satisfy the Mach spec interface
	68	* reqirements.
	69	*/
	70
	71	#include <mach/mach_types.h>
	72	#include <mach/message.h>
	73	#include <kern/mach_param.h>
	74	#include <kern/misc_protos.h>
	75	#include <mach/port.h>
	76	#include <kern/lock.h>
	77	#include <kern/ipc_kobject.h>
	78	#include <ipc/ipc_space.h>
	79	#include <ipc/ipc_port.h>
	80	#include <kern/host.h>
	81	#include <kern/ledger.h>
	82	#include <mach/ledger_server.h>
83
84	ledger_t root_wired_ledger;
85	ledger_t root_paged_ledger;
86
87
88	/* Utility routine to handle entries to a ledger */
89	kern_return_t
90	ledger_enter(
91	ledger_t ledger,
92	ledger_item_t amount)
93	{
94	/* Need to lock the ledger */
95	ledger_lock(ledger);
96
97	if (amount > 0) {
98	if (ledger->ledger_limit != LEDGER_ITEM_INFINITY &&
99	ledger->ledger_balance + amount > ledger->ledger_limit) {
100	/* XXX this is where you do BAD things */
101	printf("Ledger limit exceeded ! ledger=%x lim=%d balance=%d\n",
102	ledger, ledger->ledger_limit,
103	ledger->ledger_balance);
104	ledger_unlock(ledger);
105	return(KERN_RESOURCE_SHORTAGE);
106	}
107	if ((natural_t)(ledger->ledger_balance + amount)
108	< LEDGER_ITEM_INFINITY)
109	ledger->ledger_balance += amount;
110	else
111	ledger->ledger_balance = LEDGER_ITEM_INFINITY;
112	}
113	else if (amount) {
114	if (ledger->ledger_balance + amount > 0)
115	ledger->ledger_balance += amount;
116	else
117	ledger->ledger_balance = 0;
118	}
119	ledger_unlock(ledger);
120	return(KERN_SUCCESS);
121	}
122
123	/* Utility routine to create a new ledger */
124	static ledger_t
125	ledger_allocate(
126	ledger_item_t limit,
127	ledger_t ledger_ledger,
128	ledger_t ledger_parent)
129	{
130	ledger_t ledger;
131
132	ledger = (ledger_t)kalloc(sizeof(ledger_data_t));
133	if (ledger == LEDGER_NULL)
134	return(LEDGER_NULL);
135
136	ledger->ledger_self = ipc_port_alloc_kernel();
137	if (ledger->ledger_self == IP_NULL)
138	return(LEDGER_NULL);
139
140	ledger_lock_init(ledger);
141	ledger->ledger_limit = limit;
142	ledger->ledger_balance = 0;
143	ledger->ledger_service_port = MACH_PORT_NULL;
144	ledger->ledger_ledger = ledger_ledger;
145	ledger->ledger_parent = ledger_parent;
146	ipc_kobject_set(ledger->ledger_self, (ipc_kobject_t)ledger,
147	IKOT_LEDGER);
148
149	return(ledger);
150	}
151
152	/* Utility routine to destroy a ledger */
153	static void
154	ledger_deallocate(
155	ledger_t ledger)
156	{
157	/* XXX can be many send rights (copies) of this */
158	ipc_port_dealloc_kernel(ledger->ledger_self);
159
160	/* XXX release send right on service port */
161	kfree((vm_offset_t)ledger, sizeof(*ledger));
162	}
163
164
165	/*
166	* Inititalize the ledger facility
167	*/
168	void ledger_init(void)
169	{
170	/*
171	* Allocate the root ledgers; wired and paged.
172	*/
173	root_wired_ledger = ledger_allocate(LEDGER_ITEM_INFINITY,
174	LEDGER_NULL, LEDGER_NULL);
175	if (root_wired_ledger == LEDGER_NULL)
176	panic("can't allocate root (wired) ledger");
177	ipc_port_make_send(root_wired_ledger->ledger_self);
178
179	root_paged_ledger = ledger_allocate(LEDGER_ITEM_INFINITY,
180	LEDGER_NULL, LEDGER_NULL);
181	if (root_paged_ledger == LEDGER_NULL)
182	panic("can't allocate root (paged) ledger");
183	ipc_port_make_send(root_paged_ledger->ledger_self);
184	}
185
186	/*
187	* Create a subordinate ledger
188	*/
189	kern_return_t ledger_create(
190	ledger_t parent_ledger,
191	ledger_t ledger_ledger,
192	ledger_t *new_ledger,
193	ledger_item_t transfer)
194	{
195	if (parent_ledger == LEDGER_NULL)
196	return(KERN_INVALID_ARGUMENT);
197
198	if (ledger_ledger == LEDGER_NULL)
199	return(KERN_INVALID_LEDGER);
200
201	/*
202	* Allocate a new ledger and change the ledger_ledger for
203	* its space.
204	*/
205	ledger_lock(ledger_ledger);
206	if ((ledger_ledger->ledger_limit != LEDGER_ITEM_INFINITY) &&
207	(ledger_ledger->ledger_balance + sizeof(ledger_data_t) >
208	ledger_ledger->ledger_limit)) {
209	ledger_unlock(ledger_ledger);
210	return(KERN_RESOURCE_SHORTAGE);
211	}
212
213	*new_ledger = ledger_allocate(LEDGER_ITEM_INFINITY, ledger_ledger, parent_ledger);
214	if (*new_ledger == LEDGER_NULL) {
215	ledger_unlock(ledger_ledger);
216	return(KERN_RESOURCE_SHORTAGE);
217	}
218
219	/*
220	* Now transfer the limit for the new ledger from the parent
221	*/
222	ledger_lock(parent_ledger);
223	if (parent_ledger->ledger_limit != LEDGER_ITEM_INFINITY) {
224	/* Would the existing balance exceed the new limit ? */
225	if (parent_ledger->ledger_limit - transfer < parent_ledger->ledger_balance) {
226	ledger_unlock(parent_ledger);
227	ledger_unlock(ledger_ledger);
228	return(KERN_RESOURCE_SHORTAGE);
229	}
230	if (parent_ledger->ledger_limit - transfer > 0)
231	parent_ledger->ledger_limit -= transfer;
232	else
233	parent_ledger->ledger_limit = 0;
234	}
235	(*new_ledger)->ledger_limit = transfer;
236
237	/* Charge the ledger against the ledger_ledger */
238	ledger_ledger->ledger_balance += sizeof(ledger_data_t);
239	ledger_unlock(parent_ledger);
240
241	ledger_unlock(ledger_ledger);
242
243	return(KERN_SUCCESS);
244	}
245
246	/*
247	* Destroy a ledger
248	*/
249	kern_return_t ledger_terminate(
250	ledger_t ledger)
251	{
252	if (ledger == LEDGER_NULL)
253	return(KERN_INVALID_ARGUMENT);
254
255	/* You can't deallocate kernel ledgers */
256	if (ledger == root_wired_ledger \|\|
257	ledger == root_paged_ledger)
258	return(KERN_INVALID_LEDGER);
259
260	/* Lock the ledger */
261	ledger_lock(ledger);
262
263	/* the parent ledger gets back the limit */
264	ledger_lock(ledger->ledger_parent);
265	if (ledger->ledger_parent->ledger_limit != LEDGER_ITEM_INFINITY) {
266	assert((natural_t)(ledger->ledger_parent->ledger_limit +
267	ledger->ledger_limit) <
268	LEDGER_ITEM_INFINITY);
269	ledger->ledger_parent->ledger_limit += ledger->ledger_limit;
270	}
271	ledger_unlock(ledger->ledger_parent);
272
273	/*
274	* XXX The spec says that you have to destroy all objects that
275	* have been created with this ledger. Nice work eh? For now
276	* Transfer the balance to the parent and let it worry about
277	* it.
278	*/
279	/* XXX the parent ledger inherits the debt ?? */
280	(void) ledger_enter(ledger->ledger_parent, ledger->ledger_balance);
281
282	/* adjust the balance of the creation ledger */
283	(void) ledger_enter(ledger->ledger_ledger, -sizeof(*ledger));
284
285	/* delete the ledger */
286	ledger_deallocate(ledger);
287
288	return(KERN_SUCCESS);
289	}
290
291	/*
292	* Return the ledger limit and balance
293	*/
294	kern_return_t ledger_read(
295	ledger_t ledger,
296	ledger_item_t *balance,
297	ledger_item_t *limit)
298	{
299	if (ledger == LEDGER_NULL)
300	return(KERN_INVALID_ARGUMENT);
301
302	ledger_lock(ledger);
303	*balance = ledger->ledger_balance;
304	*limit = ledger->ledger_limit;
305	ledger_unlock(ledger);
306
307	return(KERN_SUCCESS);
308	}
309
310	/*
311	* Transfer resources from a parent ledger to a child
312	*/
313	kern_return_t ledger_transfer(
314	ledger_t parent_ledger,
315	ledger_t child_ledger,
316	ledger_item_t transfer)
317	{
318	#define abs(v) ((v) > 0)?(v):-(v)
319
320	ledger_t src, dest;
321	ledger_item_t amount = abs(transfer);
322
323	if (parent_ledger == LEDGER_NULL)
324	return(KERN_INVALID_ARGUMENT);
325
326	if (child_ledger == LEDGER_NULL)
327	return(KERN_INVALID_ARGUMENT);
328
329	/* Must be different ledgers */
330	if (parent_ledger == child_ledger)
331	return(KERN_INVALID_ARGUMENT);
332
333	if (transfer == 0)
334	return(KERN_SUCCESS);
335
336	ledger_lock(child_ledger);
337	ledger_lock(parent_ledger);
338
339	/* XXX Should be the parent you created it from ?? */
340	if (parent_ledger != child_ledger->ledger_parent) {
341	ledger_unlock(parent_ledger);
342	ledger_unlock(child_ledger);
343	return(KERN_INVALID_LEDGER);
344	}
345
346	if (transfer > 0) {
347	dest = child_ledger;
348	src = parent_ledger;
349	}
350	else {
351	src = child_ledger;
352	dest = parent_ledger;
353	}
354
355	if (src->ledger_limit != LEDGER_ITEM_INFINITY) {
356	/* Would the existing balance exceed the new limit ? */
357	if (src->ledger_limit - amount < src->ledger_balance) {
358	ledger_unlock(parent_ledger);
359	ledger_unlock(child_ledger);
360	return(KERN_RESOURCE_SHORTAGE);
361	}
362	if (src->ledger_limit - amount > 0)
363	src->ledger_limit -= amount;
364	else
365	src->ledger_limit = 0;
366	}
367
368	if (dest->ledger_limit != LEDGER_ITEM_INFINITY) {
369	if ((natural_t)(dest->ledger_limit + amount)
370	< LEDGER_ITEM_INFINITY)
371	dest->ledger_limit += amount;
372	else
373	dest->ledger_limit = (LEDGER_ITEM_INFINITY - 1);
374	}
375
376	ledger_unlock(parent_ledger);
377	ledger_unlock(child_ledger);
378
379	return(KERN_SUCCESS);
380	#undef abs
381	}
382
383	/*
384	* Routine: convert_port_to_ledger
385	* Purpose:
386	* Convert from a port to a ledger.
387	* Doesn't consume the port ref; the ledger produced may be null.
388	* Conditions:
389	* Nothing locked.
390	*/
391
392	ledger_t
393	convert_port_to_ledger(
394	ipc_port_t port)
395	{
396	ledger_t ledger = LEDGER_NULL;
397
398	if (IP_VALID(port)) {
399	ip_lock(port);
400	if (ip_active(port) &&
401	(ip_kotype(port) == IKOT_LEDGER))
402	ledger = (ledger_t) port->ip_kobject;
403	ip_unlock(port);
404	}
405
406	return ledger;
407	}
408
409	/*
410	* Routine: convert_ledger_to_port
411	* Purpose:
412	* Convert from a ledger to a port.
413	* Produces a naked send right which may be invalid.
414	* Conditions:
415	* Nothing locked.
416	*/
417
418	ipc_port_t
419	convert_ledger_to_port(
420	ledger_t ledger)
421	{
422	ipc_port_t port;
423
424	port = ipc_port_make_send(ledger->ledger_self);
425
426	return port;
427	}
428
429	/*
430	* Copy a ledger
431	*/
432	ipc_port_t
433	ledger_copy(
434	ledger_t ledger)
435	{
436	/* XXX reference counting */
437	assert(ledger);
438	return(ipc_port_copy_send(ledger->ledger_self));
439	}