![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ledger.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / kern|
Return to ledger.c CVS log | Up to [Apple XNU] / XNU / osfmk / kern |
1.1 root 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: * @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: * Get the remote ledger service port
248: */
249: kern_return_t ledger_get_remote(
250: ledger_t ledger,
251: host_t host,
252: ledger_t *service)
253: {
254: if (ledger == LEDGER_NULL)
255: return(KERN_INVALID_ARGUMENT);
256:
257: if (host == HOST_NULL)
258: return(KERN_INVALID_ARGUMENT);
259:
260: /* XXX if host != this host, call remote host */
261: ledger_lock(ledger);
262: *service = convert_port_to_ledger(ledger->ledger_service_port);
263: ledger_unlock(ledger);
264:
265: return(KERN_SUCCESS);
266: }
267:
268: /*
269: * Return the ledger limit and balance
270: */
271: kern_return_t ledger_read(
272: ledger_t ledger,
273: ledger_item_t *balance,
274: ledger_item_t *limit)
275: {
276: if (ledger == LEDGER_NULL)
277: return(KERN_INVALID_ARGUMENT);
278:
279: ledger_lock(ledger);
280: *balance = ledger->ledger_balance;
281: *limit = ledger->ledger_limit;
282: ledger_unlock(ledger);
283:
284: return(KERN_SUCCESS);
285: }
286:
287: /*
288: * Sets the remote ledger service port
289: */
290: kern_return_t ledger_set_remote(
291: ledger_t ledger,
292: ledger_t service)
293: {
294: if (ledger == LEDGER_NULL)
295: return(KERN_INVALID_ARGUMENT);
296:
297: /* XXX Check that service port is a port */
298:
299: ledger_lock(ledger);
300: ledger->ledger_service_port = service->ledger_self;
301: ledger_unlock(ledger);
302:
303: return(KERN_SUCCESS);
304: }
305:
306: /*
307: * Destroy a ledger
308: */
309: kern_return_t ledger_terminate(
310: ledger_t ledger)
311: {
312: if (ledger == LEDGER_NULL)
313: return(KERN_INVALID_ARGUMENT);
314:
315: /* You can't deallocate kernel ledgers */
316: if (ledger == root_wired_ledger ||
317: ledger == root_paged_ledger)
318: return(KERN_INVALID_LEDGER);
319:
320: /* Lock the ledger */
321: ledger_lock(ledger);
322:
323: /* the parent ledger gets back the limit */
324: ledger_lock(ledger->ledger_parent);
325: if (ledger->ledger_parent->ledger_limit != LEDGER_ITEM_INFINITY) {
326: assert((natural_t)(ledger->ledger_parent->ledger_limit +
327: ledger->ledger_limit) <
328: LEDGER_ITEM_INFINITY);
329: ledger->ledger_parent->ledger_limit += ledger->ledger_limit;
330: }
331: ledger_unlock(ledger->ledger_parent);
332:
333: /*
334: * XXX The spec says that you have to destroy all objects that
335: * have been created with this ledger. Nice work eh? For now
336: * Transfer the balance to the parent and let it worry about
337: * it.
338: */
339: /* XXX the parent ledger inherits the debt ?? */
340: (void) ledger_enter(ledger->ledger_parent, ledger->ledger_balance);
341:
342: /* adjust the balance of the creation ledger */
343: (void) ledger_enter(ledger->ledger_ledger, -sizeof(*ledger));
344:
345: /* delete the ledger */
346: ledger_deallocate(ledger);
347:
348: return(KERN_SUCCESS);
349: }
350:
351: /*
352: * Transfer resources from a parent ledger to a child
353: */
354: kern_return_t ledger_transfer(
355: ledger_t parent_ledger,
356: ledger_t child_ledger,
357: ledger_item_t transfer)
358: {
359: #define abs(v) ((v) > 0)?(v):-(v)
360:
361: ledger_t src, dest;
362: ledger_item_t amount = abs(transfer);
363:
364: if (parent_ledger == LEDGER_NULL)
365: return(KERN_INVALID_ARGUMENT);
366:
367: if (child_ledger == LEDGER_NULL)
368: return(KERN_INVALID_ARGUMENT);
369:
370: /* Must be different ledgers */
371: if (parent_ledger == child_ledger)
372: return(KERN_INVALID_ARGUMENT);
373:
374: if (transfer == 0)
375: return(KERN_SUCCESS);
376:
377: ledger_lock(child_ledger);
378: ledger_lock(parent_ledger);
379:
380: /* XXX Should be the parent you created it from ?? */
381: if (parent_ledger != child_ledger->ledger_parent) {
382: ledger_unlock(parent_ledger);
383: ledger_unlock(child_ledger);
384: return(KERN_INVALID_LEDGER);
385: }
386:
387: if (transfer > 0) {
388: dest = child_ledger;
389: src = parent_ledger;
390: }
391: else {
392: src = child_ledger;
393: dest = parent_ledger;
394: }
395:
396: if (src->ledger_limit != LEDGER_ITEM_INFINITY) {
397: /* Would the existing balance exceed the new limit ? */
398: if (src->ledger_limit - amount < src->ledger_balance) {
399: ledger_unlock(parent_ledger);
400: ledger_unlock(child_ledger);
401: return(KERN_RESOURCE_SHORTAGE);
402: }
403: if (src->ledger_limit - amount > 0)
404: src->ledger_limit -= amount;
405: else
406: src->ledger_limit = 0;
407: }
408:
409: if (dest->ledger_limit != LEDGER_ITEM_INFINITY) {
410: if ((natural_t)(dest->ledger_limit + amount)
411: < LEDGER_ITEM_INFINITY)
412: dest->ledger_limit += amount;
413: else
414: dest->ledger_limit = (LEDGER_ITEM_INFINITY - 1);
415: }
416:
417: ledger_unlock(parent_ledger);
418: ledger_unlock(child_ledger);
419:
420: return(KERN_SUCCESS);
421: #undef abs
422: }
423:
424: /*
425: * Routine: convert_port_to_ledger
426: * Purpose:
427: * Convert from a port to a ledger.
428: * Doesn't consume the port ref; the ledger produced may be null.
429: * Conditions:
430: * Nothing locked.
431: */
432:
433: ledger_t
434: convert_port_to_ledger(
435: ipc_port_t port)
436: {
437: ledger_t ledger = LEDGER_NULL;
438:
439: if (IP_VALID(port)) {
440: ip_lock(port);
441: if (ip_active(port) &&
442: (ip_kotype(port) == IKOT_LEDGER))
443: ledger = (ledger_t) port->ip_kobject;
444: ip_unlock(port);
445: }
446:
447: return ledger;
448: }
449:
450: /*
451: * Routine: convert_ledger_to_port
452: * Purpose:
453: * Convert from a ledger to a port.
454: * Produces a naked send right which may be invalid.
455: * Conditions:
456: * Nothing locked.
457: */
458:
459: ipc_port_t
460: convert_ledger_to_port(
461: ledger_t ledger)
462: {
463: ipc_port_t port;
464:
465: port = ipc_port_make_send(ledger->ledger_self);
466:
467: return port;
468: }
469:
470: /*
471: * Copy a ledger
472: */
473: ipc_port_t
474: ledger_copy(
475: ledger_t ledger)
476: {
477: /* XXX reference counting */
478: assert(ledger);
479: return(ipc_port_copy_send(ledger->ledger_self));
480: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.