root/trunk/vmem_stand.c

Revision 2, 3.8 kB (checked in by wez, 9 years ago)

Initial revision

  • Property svn:eol-style set to native
Line 
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26
27 #pragma ident   "@(#)vmem_stand.c       1.4     05/06/08 SMI"
28
29 /*
30  * Standalone-specific vmem routines
31  *
32  * The standalone allocator operates on a pre-existing blob of memory, the
33  * location and dimensions of which are set using vmem_stand_setsize().  We
34  * then hand out CHUNKSIZE-sized pieces of this blob, until we run out.
35  */
36
37 #define DEF_CHUNKSIZE   (64 * 1024)     /* 64K */
38
39 #define DEF_NREGIONS    2
40
41 #include <errno.h>
42 #include <limits.h>
43 #include <sys/sysmacros.h>
44 #include <sys/mman.h>
45 #include <unistd.h>
46 #include <strings.h>
47
48 #include "vmem_base.h"
49 #include "misc.h"
50
51 static vmem_t *stand_heap;
52
53 static size_t stand_chunksize;
54
55 typedef struct stand_region {
56         caddr_t sr_base;
57         caddr_t sr_curtop;
58         size_t sr_left;
59 } stand_region_t;
60
61 static stand_region_t stand_regions[DEF_NREGIONS];
62 static int stand_nregions;
63
64 extern void membar_producer(void);
65
66 void
67 vmem_stand_init(void)
68 {
69         stand_chunksize = MAX(DEF_CHUNKSIZE, pagesize);
70
71         stand_nregions = 0;
72 }
73
74 int
75 vmem_stand_add(caddr_t base, size_t len)
76 {
77         stand_region_t *sr = &stand_regions[stand_nregions];
78
79         ASSERT(pagesize != 0);
80
81         if (stand_nregions == DEF_NREGIONS) {
82                 errno = ENOSPC;
83                 return (-1); /* we don't have room -- throw it back */
84         }
85
86         /*
87          * We guarantee that only one call to `vmem_stand_add' will be
88          * active at a time, but we can't ensure that the allocator won't be
89          * in use while this function is being called.  As such, we have to
90          * ensure that sr is populated and visible to other processors before
91          * allowing the allocator to access the new region.
92          */
93         sr->sr_base = base;
94         sr->sr_curtop = (caddr_t)P2ROUNDUP((ulong_t)base, stand_chunksize);
95         sr->sr_left = P2ALIGN(len - (size_t)(sr->sr_curtop - sr->sr_base),
96             stand_chunksize);
97         membar_producer();
98
99         stand_nregions++;
100
101         return (0);
102 }
103
104 static void *
105 stand_parent_alloc(vmem_t *src, size_t size, int vmflags)
106 {
107         int old_errno = errno;
108         stand_region_t *sr;
109         size_t chksize;
110         void *ret;
111         int i;
112
113         if ((ret = vmem_alloc(src, size, VM_NOSLEEP)) != NULL) {
114                 errno = old_errno;
115                 return (ret);
116         }
117
118         /* We need to allocate another chunk */
119         chksize = roundup(size, stand_chunksize);
120
121         for (sr = stand_regions, i = 0; i < stand_nregions; i++, sr++) {
122                 if (sr->sr_left >= chksize)
123                         break;
124         }
125
126         if (i == stand_nregions) {
127                 /*
128                  * We don't have enough in any of our regions to satisfy the
129                  * request.
130                  */
131                 errno = old_errno;
132                 return (NULL);
133         }
134
135         if ((ret = _vmem_extend_alloc(src, sr->sr_curtop, chksize, size,
136             vmflags)) == NULL) {
137                 errno = old_errno;
138                 return (NULL);
139         }
140
141         bzero(sr->sr_curtop, chksize);
142
143         sr->sr_curtop += chksize;
144         sr->sr_left -= chksize;
145
146         return (ret);
147 }
148
149 vmem_t *
150 vmem_stand_arena(vmem_alloc_t **a_out, vmem_free_t **f_out)
151 {
152         ASSERT(stand_nregions == 1);
153
154         stand_heap = vmem_init("stand_parent", stand_chunksize,
155             stand_parent_alloc, vmem_free,
156             "stand_heap", NULL, 0, pagesize, vmem_alloc, vmem_free);
157
158         if (a_out != NULL)
159                 *a_out = vmem_alloc;
160         if (f_out != NULL)
161                 *f_out = vmem_free;
162
163         return (stand_heap);
164 }
Note: See TracBrowser for help on using the browser.