[apple/xnu.git] / osfmk / kern / ledger.c

/*
 * Copyright (c) 2000-2004 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@
 */
/*
 * 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 <mach/port.h>
#include <mach/ledger_server.h>

#include <kern/mach_param.h>
#include <kern/misc_protos.h>
#include <kern/lock.h>
#include <kern/ipc_kobject.h>
#include <kern/host.h>
#include <kern/ledger.h>
#include <kern/kalloc.h>

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