![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to osenv_mem.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / OSKit-Mach / oskit|
Return to osenv_mem.c CVS log | Up to [GnuMach] / OSKit-Mach / oskit |
1.1 root 1: /*
2: * Copyright (c) 1999, 2000 University of Utah and the Flux Group.
3: * All rights reserved.
4: *
5: * This file is part of the Flux OSKit. The OSKit is free software, also known
6: * as "open source;" you can redistribute it and/or modify it under the terms
7: * of the GNU General Public License (GPL), version 2, as published by the Free
8: * Software Foundation (FSF). To explore alternate licensing terms, contact
9: * the University of Utah at [email protected] or +1-801-585-3271.
10: *
11: * The OSKit is distributed in the hope that it will be useful, but WITHOUT ANY
12: * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
13: * FOR A PARTICULAR PURPOSE. See the GPL for more details. You should have
14: * received a copy of the GPL along with the OSKit; see the file COPYING. If
15: * not, write to the FSF, 59 Temple Place #330, Boston, MA 02111-1307, USA.
16: */
17:
18: #include <oskit/com.h>
19: #include <oskit/com/mem.h>
20: #include <oskit/com/services.h>
21: #include <oskit/dev/dev.h>
22: #include <oskit/dev/osenv_mem.h>
23:
24: #include <oskit/lmm.h>
25: #include <oskit/machine/base_vm.h>
26: #include <oskit/machine/physmem.h>
27: #include <oskit/machine/phys_lmm.h>
28:
29: #include <string.h>
30:
31: #include <cpus.h>
32: #include "lock.h"
33: #include "kalloc.h"
34: #include "zalloc.h"
35: #include "assert.h"
36: #include <machine/spl.h>
37:
38: #include <vm/vm_kern.h>
39:
40: #include "ds_oskit.h"
41:
42: #define in_oskit_interrupt (nested_pic_mask != 0)
43: extern unsigned int nested_pic_mask; /* osenv_irq.c */
44:
45: decl_simple_lock_data(, phys_lmm_lock)
46: decl_simple_lock_data(extern, vm_page_queue_free_lock)
47:
48: extern int vm_page_unqueued_count; /* vm_resident.c */
49: extern zone_t vm_page_zone;
50: extern vm_offset_t virtual_space_start;
51: extern vm_offset_t virtual_space_end;
52:
53: int lmm_wants_pages;
54:
55: #define debug_protect_page(p) ((void)(p))
56: #define debug_unprotect_page(p) ((void)(p))
57:
58:
59: /* Update the VM system's counts of free pages in the LMM.
60: Called at sploskit with phys_lmm_lock held. */
61: static void
62: update_counts (void)
63: {
64: vm_page_unqueued_count = atop (lmm_avail (&malloc_lmm, 0));
65: }
66:
67:
68: void *
69: alloc_for_oskit (oskit_size_t size, osenv_memflags_t flags, unsigned align)
70: {
71: kern_return_t kr;
72: lmm_flags_t lmm_flags;
73:
74: assert (align <= size);
75:
76: if (flags & OSENV_AUTO_SIZE)
77: {
78: oskit_size_t *p;
79: size += sizeof (oskit_size_t);
80: if (align > sizeof (oskit_size_t))
81: panic ("autosize + align %u", align);
82: /* XXX how would I recover the beginning of the block in free?
83: size += align - sizeof (oskit_size_t);
84: */
85: else
86: align = sizeof (oskit_size_t);
87: p = alloc_for_oskit (size, flags &~ OSENV_AUTO_SIZE, align);
88: if (p == 0)
89: return 0;
90: p = (void *) (((oskit_addr_t) (p + 1) + align - 1) &~ (align - 1));
91: p[-1] = size;
92: return p;
93: }
94:
95: lmm_flags = (((flags & OSENV_ISADMA_MEM) ? LMMF_16MB : 0)
96: | ((flags & OSENV_X861MB_MEM) ? LMMF_1MB : 0));
97:
98: if (lmm_flags != 0)
99: assert (flags & OSENV_VIRT_EQ_PHYS);
100:
101: if (mach_osenv == 0)
102: /* This is early oskit startup code before the kernel is set up.
103: Always go directly to physical memory. */
104: flags |= OSENV_VIRT_EQ_PHYS|OSENV_PHYS_WIRED|OSENV_PHYS_CONTIG;
105:
106: if (in_oskit_interrupt)
107: /* The oskit documentation says an interrupt caller must set the flag. */
108: assert (flags & OSENV_NONBLOCKING);
109:
110: if (!(flags & (OSENV_NONBLOCKING|OSENV_PHYS_WIRED)))
111: {
112: /* Unwired virtual memory will do. */
113:
114: if (size < PAGE_SIZE)
115: /* For less than a page we don't want to waste partial pages,
116: and we don't want to bother with a second-tier allocator
117: for virtual memory, so just give him wired memory. */
118: return (void *) kalloc (size);
119: else
120: {
121: vm_offset_t addr;
122: kr = kmem_alloc_pageable (kernel_map, &addr, size);
123: return kr ? 0 : (void *) addr;
124: }
125: }
126:
127: if (!(flags & (OSENV_VIRT_EQ_PHYS|OSENV_NONBLOCKING))
128: && (!(flags & OSENV_PHYS_CONTIG) || size <= PAGE_SIZE))
129: {
130: /* Wired virtual memory will do. */
131: return (void *) kalloc (size);
132: }
133:
134: /* We need physically contiguous memory. This we get directly from the
135: lmm, which might also be used by vm_page_grab. All users of the lmm
136: must go to sploskit or above and take the phys_lmm_lock. This blocks
137: out any interrupts that might go to the oskit (and get us here). */
138: while (1)
139: {
140: spl_t s;
141: void *block;
142:
143: s = sploskit ();
144: simple_lock (&phys_lmm_lock);
145:
146: if (align)
147: block = lmm_alloc_aligned (&malloc_lmm, size, lmm_flags,
148: ffs (align) - 1, 0);
149: else
150: block = lmm_alloc (&malloc_lmm, size, lmm_flags);
151:
152: update_counts ();
153:
154: simple_unlock (&phys_lmm_lock);
155: splx (s);
156:
157: if (block)
158: return block;
159:
160: if (flags & OSENV_NONBLOCKING)
161: return 0;
162:
163: /* There is no space in the lmm. There may well be pages available on
164: the VM system's free list. If we're sure we are not being called
165: from an interrupt handler here, which we should be guaranteed by
166: checking for OSENV_NONBLOCKING, then we can just access the free
167: list directly here (vm_page_grab). Another approach is to just wake
168: up the pageout daemon to have it find some pages for the lmm and
169: then block until it wakes us up. lmm_wants_pages accumulates the
170: number of pages wanted by blocked threads like ourselves.
171: consider_lmm_collect will produce some memory, set lmm_want_pages to
172: zero, and wake up all blocked threads to retry their allocations. */
173: lmm_wants_pages += atop (round_page (size));
174: thread_wakeup_one ((event_t)&vm_page_queue_free_count);
175: assert_wait ((event_t)&lmm_wants_pages, FALSE);
176: thread_block (0);
177: /* The pageout daemon woke us up (see consider_lmm_collect)
178: after putting some memory back into the LMM for us.
179: XXX make sure we don't loop in livelock? */
180: }
181: }
182:
183:
184: void
185: free_for_oskit (void *block, osenv_memflags_t flags, oskit_size_t size)
186: {
187: if (flags & OSENV_AUTO_SIZE)
188: {
189: oskit_size_t *p = block;
190: size = *--p;
191: block = p;
192: }
193:
194: if (mach_osenv == 0)
195: /* This is early oskit startup code before the kernel is set up.
196: Always go directly to physical memory. */
197: flags |= OSENV_VIRT_EQ_PHYS|OSENV_PHYS_WIRED|OSENV_PHYS_CONTIG;
198:
199: #if 0
200: if (in_oskit_interrupt)
201: /* The oskit documentation says an interrupt caller must set the flag. */
202: assert (flags & OSENV_NONBLOCKING);
203: #endif /* ... but oskit/linux/shared/s_kmem.c doesn't. */
204:
205: if ((oskit_addr_t) block < phys_mem_max)
206: {
207: /* We got physical memory directly from the lmm. */
208: spl_t s;
209:
210: s = sploskit ();
211: simple_lock (&phys_lmm_lock);
212:
213: lmm_free (&malloc_lmm, block, size);
214: update_counts ();
215:
216: simple_unlock (&phys_lmm_lock);
217: splx (s);
218: }
219: else
220: {
221: if (in_oskit_interrupt)
222: {
223: /* This should be impossible if the caller (oskit) is consistent
224: in its use of OSENV_NONBLOCKING for allocations and
225: deallocations. alloc_for_oskit will always get physical
226: memory when called with the flag set. */
227: panic ("free_for_oskit of virtual memory from interrupt level");
228: /* If this ever happens, make a little free list and have the
229: pageout daemon run over it doing kfree. */
230: }
231: else
232: kfree ((vm_offset_t) block, size);
233: }
234: }
235:
236:
237: /*** Entry points from the VM system. ***/
238:
239:
240: /* Called only from vm_page_bootstrap, only for estimate. */
241: unsigned int pmap_free_pages()
242: {
243: return atop (lmm_avail (&malloc_lmm, 0));
244: }
245:
246:
247: /* This is called from pmap_bootstrap for kernel page table pages, and from
248: pmap_steal_memory for physical pages to back kernel virtual memory
249: allocated in early Mach startup. */
250: vm_offset_t
251: pmap_grab_page (void)
252: {
253: void *page = lmm_alloc_page (&malloc_lmm, 0);
254: if (page == 0)
255: panic ("Not enough memory to initialize Mach");
256: return (vm_offset_t) page;
257: }
258:
259: int
260: init_alloc (vm_size_t size, vm_offset_t *p)
261: {
262: void *block = lmm_alloc (&malloc_lmm, size, 0);
263: if (block == 0)
264: return 0;
265: *p = (vm_offset_t) block;
266: return 1;
267: }
268:
269:
270: /* in zalloc.c XXX */
271: extern vm_offset_t zdata;
272: extern vm_size_t zdata_size;
273:
274:
275: void pmap_startup(
276: vm_offset_t *startp,
277: vm_offset_t *endp)
278: {
279: unsigned int i, npages, initial_pages;
280: vm_page_t pages;
281:
282: /* Calculate how many pages can possibly go into the VM pool,
283: taking into account the space required for each page's own
284: vm_page_t structure. */
285: npages = ((lmm_avail (&malloc_lmm, 0) - round_page(zdata_size)) /
286: (PAGE_SIZE + sizeof *pages));
287:
288: /* We will allocate a quarter of the pages to start with.
289: That ought to be plenty enough to get the kernel up and running.
290: Once the pageout daemon has started, it will equalize the
291: free page queue and LMM free pool sizes. */
292: initial_pages = npages / 4;
293:
294: /* Steal some memory for the zone system, including enough
295: to cover the initial vm_page structures we will steal. */
296: zdata_size = (round_page (virtual_space_start + zdata_size +
297: initial_pages * sizeof *pages)
298: - virtual_space_start);
299: zdata = pmap_steal_memory (zdata_size);
300:
301: /* Steal vm_page structures from the zone system,
302: and physical pages from the LMM. */
303: pages = (void *) zdata;
304: for (i = 0; i < initial_pages; ++i)
305: {
306: vm_page_t mem = pages++;
307: void *page = lmm_alloc_page (&malloc_lmm, 0);
308: vm_page_init (mem, (vm_offset_t) page);
309: debug_protect_page (page);
310: vm_page_release (mem, FALSE);
311: }
312:
313: /* Account for the memory swiped for vm_page structures,
314: and return the rest of the stolen memory to the zone system. */
315: zdata_size = zdata + zdata_size - (vm_offset_t) pages;
316: zdata = (vm_offset_t) pages;
317:
318: /* Set the initial record of the number of pages available in the
319: LMM to a deliberate lie. This value will be used to set paging
320: algorithm parameters that should be based on what things look
321: like with all available physical pages in the VM pool. So here
322: we use the calculation that takes into account the overhead of
323: vm_page_t structures that we will have to consume to put pages
324: into the pool. Counting the free pages in the LMM will show
325: more pages available than we admit, since we haven't allocated
326: all of those structures up front. As soon as the pageout daemon
327: gets started up, it will recalculate from the LMM. */
328: vm_page_unqueued_count = npages - initial_pages;
329:
330:
331: /*
332: * We have to re-align virtual_space_start,
333: * because pmap_steal_memory has been using it.
334: */
335:
336: virtual_space_start = round_page(virtual_space_start);
337:
338: *startp = virtual_space_start;
339: *endp = virtual_space_end;
340: }
341:
342:
343: void
344: vm_page_grab_oskit_page (void)
345: {
346: void *page;
347: vm_page_t m;
348:
349: do
350: {
351: spl_t s = sploskit ();
352: simple_lock (&phys_lmm_lock);
353:
354: page = lmm_alloc_page (&malloc_lmm, 0);
355:
356: update_counts ();
357:
358: debug_protect_page (page);
359: simple_unlock (&phys_lmm_lock);
360: splx (s);
361:
362: if (page == 0)
363: panic (__FUNCTION__);
364:
365: m = (vm_page_t) zget(vm_page_zone);
366: if (m == VM_PAGE_NULL)
367: {
368: /* The zone is out of space. A normal zalloc would call
369: kmem_alloc_wired and wind up recursing down to here trying to
370: get a page. So instead we just stuff a physical page directly
371: into the zone, and loop for a new one to satisfy our caller. */
372: debug_unprotect_page (page);
373: zcram(vm_page_zone, (vm_offset_t) page, PAGE_SIZE);
374: }
375: } while (m == VM_PAGE_NULL);
376:
377: vm_page_init(m, (vm_offset_t) page);
378: vm_page_release(m, FALSE);
379: }
380:
381:
382: #define PAGE_BATCH 32
383:
384: /* Called by the pageout daemon to see if the vm_page_free_queue
385: and the LMM want to tango. */
386:
387: void
388: consider_lmm_collect (void)
389: {
390: spl_t s;
391: unsigned int need;
392:
393: /* First check if the LMM needs pages back for alloc_for_oskit calls. */
394: if (vm_page_unqueued_count < lmm_wants_pages
395: || vm_page_queue_free_count > 8 * vm_page_unqueued_count) /* random */
396: {
397: /* The LMM needs some physical pages back from the VM pool. */
398: need = lmm_wants_pages > PAGE_BATCH ? lmm_wants_pages : PAGE_BATCH;
399:
400: while (need > 0)
401: {
402: unsigned int batch = need > PAGE_BATCH ? PAGE_BATCH : need;
403: void *pages[PAGE_BATCH];
404: unsigned int i;
405:
406: for (i = 0; i < batch; ++i)
407: {
408: vm_page_t mem = vm_page_grab (FALSE);
409: if (mem == VM_PAGE_NULL)
410: break;
411: pages[i] = (void *) mem->phys_addr;
412: zfree (vm_page_zone, (vm_offset_t) mem);
413: debug_unprotect_page (pages[i]);
414: }
415:
416: s = sploskit ();
417: simple_lock (&phys_lmm_lock);
418:
419: while (i-- > 0)
420: lmm_free_page (&malloc_lmm, (void *) pages[i]);
421:
422: update_counts ();
423:
424: simple_unlock (&phys_lmm_lock);
425: splx (s);
426:
427: if (i < batch)
428: break;
429: need -= batch;
430: }
431: }
432:
433: /* If lmm_wants_pages is set, then some threads are blocked in
434: alloc_for_oskit. This might still be the case even if the memory was
435: released to the LMM before we ran so that we didn't do anything above.
436: We need to wake the blocked threads so they will all retry their
437: allocations. */
438: if (lmm_wants_pages != 0)
439: {
440: lmm_wants_pages = 0;
441: thread_wakeup ((event_t)&lmm_wants_pages);
442: }
443:
444: /* Any time the VM pool has fewer free pages than the LMM does,
445: we give it half the LMM's free pages. */
446:
447: if (vm_page_queue_free_count < vm_page_unqueued_count)
448: {
449: s = sploskit ();
450: simple_lock (&phys_lmm_lock);
451:
452: need = vm_page_unqueued_count / 2;
453:
454: /* We allocate only a single page at a time from the LMM, since we
455: don't need contiguous pages, and would rather use up fragmented
456: pages so as to leave the contiguous regions for those who need them.
457:
458: We must go to sploskit to call into the LMM, but back up to spl0 to
459: deliver the new pages to the VM system. We don't want to do this
460: for every single page allocation from the LMM, so we allocate
461: individual pages from the LMM in batches of PAGE_BATCH pages and
462: then reenable interrupts to deliver those pages before going back
463: for more. */
464:
465: while (need > 0)
466: {
467: unsigned int batch = need > PAGE_BATCH ? PAGE_BATCH : need;
468: void *pages[PAGE_BATCH];
469: unsigned int i;
470:
471: for (i = 0; i < batch; ++i)
472: {
473: /* This allocation should never fail, since we keep track
474: of the number of pages available in the lmm. */
475: pages[i] = lmm_alloc_page (&malloc_lmm, 0);
476: if (pages[i] == 0)
477: panic ("LMM unexpectedly out of physical pages");
478: debug_protect_page (pages[i]);
479: }
480:
481: update_counts ();
482:
483: simple_unlock (&phys_lmm_lock);
484: splx (s);
485:
486: while (i-- > 0)
487: vm_page_create ((vm_offset_t) pages[i],
488: (vm_offset_t) pages[i] + PAGE_SIZE);
489:
490: need -= batch;
491: if (need == 0)
492: break;
493:
494: s = sploskit ();
495: simple_lock (&phys_lmm_lock);
496: }
497: }
498: }
499:
500:
501: /*** oskit_osenv_mem_t COM object implementation ***/
502:
503:
504: /*
505: * There is one and only one memory interface in this implementation.
506: */
507: static struct oskit_osenv_mem_ops osenv_mem_ops;
508: static struct oskit_osenv_mem osenv_mem_object = {&osenv_mem_ops};
509:
510: static OSKIT_COMDECL
511: mem_query(oskit_osenv_mem_t *s, const oskit_iid_t *iid, void **out_ihandle)
512: {
513: if (memcmp(iid, &oskit_iunknown_iid, sizeof(*iid)) == 0 ||
514: memcmp(iid, &oskit_osenv_mem_iid, sizeof(*iid)) == 0) {
515: *out_ihandle = s;
516: return 0;
517: }
518:
519: *out_ihandle = 0;
520: return OSKIT_E_NOINTERFACE;
521: };
522:
523: static OSKIT_COMDECL_U
524: mem_addref(oskit_osenv_mem_t *s)
525: {
526: /* Only one object */
527: return 1;
528: }
529:
530: static OSKIT_COMDECL_U
531: mem_release(oskit_osenv_mem_t *s)
532: {
533: /* Only one object */
534: return 1;
535: }
536:
537: static void * OSKIT_COMCALL
538: mem_alloc(oskit_osenv_mem_t *o, oskit_size_t size,
539: osenv_memflags_t flags, unsigned align)
540: {
541: return alloc_for_oskit (size, flags, align);
542: }
543:
544: static OSKIT_COMDECL_V
545: mem_free(oskit_osenv_mem_t *o, void *block,
546: osenv_memflags_t flags, oskit_size_t size)
547: {
548: free_for_oskit (block, flags, size);
549: }
550:
551: static oskit_addr_t OSKIT_COMCALL
552: mem_getphys(oskit_osenv_mem_t *o, oskit_addr_t va)
553: {
554: /* We can only use kvtophys for memory allocated with OSENV_PHYS_CONTIG.
555: But at least some code (e.g. eepro100 driver) will call us with an
556: address on a kernel stack and expect to get a physical address from that.
557: Checking the kernel pmap is a little heavy but should be correct in
558: all cases. */
559: return pmap_extract (kernel_pmap, va);
560: }
561:
562: static oskit_addr_t OSKIT_COMCALL
563: mem_getvirt(oskit_osenv_mem_t *o, oskit_addr_t pa)
564: {
565: return ((oskit_addr_t)phystokv(pa));
566: }
567:
568: static oskit_addr_t OSKIT_COMCALL
569: mem_physmax(oskit_osenv_mem_t *o)
570: {
571: return phys_mem_max;
572: }
573:
574: static OSKIT_COMDECL_U
575: mem_mapphys(oskit_osenv_mem_t *o, oskit_addr_t pa,
576: oskit_size_t size, void **addr, int flags)
577: {
578: kern_return_t kr;
579: vm_offset_t kva;
580:
581: if (trunc_page (pa) != 0 &&
582: trunc_page (pa) >= trunc_page (phys_mem_min) &&
583: round_page (pa + size) < round_page (phys_mem_max))
584: {
585: /* Direct mapping already covers it. */
586: *addr = (void *) phystokv (pa);
587: return 0;
588: }
589:
590: kr = kmem_alloc_pageable (kernel_map, &kva, round_page (size));
591: if (kr)
592: return OSKIT_E_OUTOFMEMORY;
593:
594: pmap_map (kva, trunc_page (pa), round_page (pa + size),
595: VM_PROT_READ | VM_PROT_WRITE);
596:
597: *addr = (char *) kva + (pa & PAGE_MASK);
598: return 0;
599: }
600:
601: #if NCPUS > 1
602: /* This function is used as a callback from smp_init_paging. */
603: oskit_addr_t
604: smp_map_range (oskit_addr_t start, oskit_size_t size)
605: {
606: oskit_error_t err = mem_mapphys (0, start, size, (void **)&start, 0);
607: return err ? 0 : start;
608: }
609: #endif
610:
611:
612: static struct oskit_osenv_mem_ops osenv_mem_ops = {
613: mem_query,
614: mem_addref,
615: mem_release,
616: mem_alloc,
617: mem_free,
618: mem_getphys,
619: mem_getvirt,
620: mem_physmax,
621: mem_mapphys,
622: };
623:
624: /*
625: * Return a reference to the one and only memory interface object.
626: */
627: oskit_osenv_mem_t *
628: oskit_create_osenv_mem(void)
629: {
630: return &osenv_mem_object;
631: }
632:
633:
634: /*** oskit_mem_t COM object implementation ***/
635:
636:
637: /* the COM object */
638: static struct oskit_mem_ops mem_ops;
639: static oskit_mem_t oskit_mem = { &mem_ops };
640:
641:
642: static OSKIT_COMDECL
643: mem2_query(oskit_mem_t *m, const oskit_iid_t *iid, void **out_ihandle)
644: {
645: if (memcmp(iid, &oskit_iunknown_iid, sizeof(*iid)) == 0 ||
646: memcmp(iid, &oskit_mem_iid, sizeof(*iid)) == 0) {
647: *out_ihandle = m;
648: return 0;
649: }
650:
651: *out_ihandle = 0;
652: return OSKIT_E_NOINTERFACE;
653: };
654:
655: static OSKIT_COMDECL_U
656: mem2_addref(oskit_mem_t *m)
657: {
658: /* No reference counting; only one of them */
659: return 1;
660: }
661:
662: static OSKIT_COMDECL_U
663: mem2_release(oskit_mem_t *m)
664: {
665: /* No reference counting; only one of them */
666: return 1;
667: }
668:
669: static void * OSKIT_COMCALL
670: mem2_alloc(oskit_mem_t *m, oskit_u32_t size, oskit_u32_t flags)
671: {
672: return alloc_for_oskit (size, flags, 0);
673: }
674:
675: static void * OSKIT_COMCALL
676: mem2_realloc(oskit_mem_t *m, void *ptr,
677: oskit_u32_t oldsize, oskit_u32_t newsize, oskit_u32_t flags)
678: {
679: if (flags & OSKIT_MEM_AUTO_SIZE)
680: {
681: oskit_size_t *op = ptr, *new;
682: oldsize = *--op;
683: newsize += sizeof (oskit_size_t);
684: new = alloc_for_oskit (newsize, flags, 0);
685: if (new)
686: {
687: *new++ = newsize;
688: memcpy (new, ptr, oldsize - sizeof (oskit_size_t));
689: free_for_oskit (op, flags, oldsize);
690: }
691: return new;
692: }
693: else
694: {
695: void *new = alloc_for_oskit (newsize, flags, 0);
696: if (new)
697: {
698: memcpy (new, ptr, oldsize);
699: free_for_oskit (ptr, flags, oldsize);
700: }
701: return new;
702: }
703: }
704:
705: static void *OSKIT_COMCALL
706: mem2_alloc_aligned(oskit_mem_t *m,
707: oskit_u32_t size, oskit_u32_t flags, oskit_u32_t align)
708: {
709: return alloc_for_oskit (size, flags, align);
710: }
711:
712: static void OSKIT_COMCALL
713: mem2_free(oskit_mem_t *m, void *ptr, oskit_u32_t size, oskit_u32_t flags)
714: {
715: if (ptr)
716: free_for_oskit (ptr, flags, size);
717: }
718:
719: static oskit_u32_t OSKIT_COMCALL
720: mem2_getsize(oskit_mem_t *m, void *ptr)
721: {
722: if (ptr) {
723: oskit_u32_t *chunk = (oskit_u32_t *)ptr - 1;
724:
725: return *chunk;
726: }
727: return 0;
728: }
729:
730: static void *OSKIT_COMCALL
731: mem2_alloc_gen(oskit_mem_t *m,
732: oskit_u32_t size, oskit_u32_t flags,
733: oskit_u32_t align_bits, oskit_u32_t align_ofs)
734: {
735: if (align_ofs != 0)
736: panic ("alloc with align_bits=%u align_ofs=%u",
737: align_bits, align_ofs);
738: return alloc_for_oskit (size, flags, 1 << align_bits);
739: }
740:
741: static oskit_size_t OSKIT_COMCALL
742: mem2_avail(oskit_mem_t *m, oskit_u32_t flags)
743: {
744: panic ("mem_avail");
745: }
746:
747: static OSKIT_COMDECL_V
748: mem2_dump(oskit_mem_t *m)
749: {
750: panic ("mem_dump");
751: }
752:
753: static struct oskit_mem_ops mem_ops = {
754: mem2_query,
755: mem2_addref,
756: mem2_release,
757: mem2_alloc,
758: mem2_realloc,
759: mem2_alloc_aligned,
760: mem2_free,
761: mem2_getsize,
762: mem2_alloc_gen,
763: mem2_avail,
764: mem2_dump,
765: };
766:
767: /*
768: * Not a lot to do in this impl.
769: */
770: oskit_mem_t *
771: oskit_mem_init(void)
772: {
773: return &oskit_mem;
774: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.