Protect malloc, realloc and free calls with INT{ON,OFF} directly in chkalloc,
[dragonfly.git] / bin / sh / memalloc.c
1 /*-
2  * Copyright (c) 1991, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * Kenneth Almquist.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *      This product includes software developed by the University of
19  *      California, Berkeley and its contributors.
20  * 4. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  *
36  * @(#)memalloc.c       8.3 (Berkeley) 5/4/95
37  * $FreeBSD: src/bin/sh/memalloc.c,v 1.27 2005/10/28 10:45:19 stefanf Exp $
38  * $DragonFly: src/bin/sh/memalloc.c,v 1.5 2007/01/14 03:59:57 pavalos Exp $
39  */
40
41 #include <sys/param.h>
42 #include "shell.h"
43 #include "output.h"
44 #include "memalloc.h"
45 #include "error.h"
46 #include "mystring.h"
47 #include "expand.h"
48 #include <stdlib.h>
49 #include <unistd.h>
50
51 /*
52  * Like malloc, but returns an error when out of space.
53  */
54
55 pointer
56 ckmalloc(int nbytes)
57 {
58         pointer p;
59
60         INTOFF;
61         p = malloc(nbytes);
62         INTON;
63         if (p == NULL)
64                 error("Out of space");
65         return p;
66 }
67
68
69 /*
70  * Same for realloc.
71  */
72
73 pointer
74 ckrealloc(pointer p, int nbytes)
75 {
76         INTOFF;
77         p = realloc(p, nbytes);
78         INTON;
79         if (p == NULL)
80                 error("Out of space");
81         return p;
82 }
83
84 void
85 ckfree(pointer p)
86 {
87         INTOFF;
88         free(p);
89         INTON;
90 }
91
92
93 /*
94  * Make a copy of a string in safe storage.
95  */
96
97 char *
98 savestr(const char *s)
99 {
100         char *p;
101
102         p = ckmalloc(strlen(s) + 1);
103         scopy(s, p);
104         return p;
105 }
106
107
108 /*
109  * Parse trees for commands are allocated in lifo order, so we use a stack
110  * to make this more efficient, and also to avoid all sorts of exception
111  * handling code to handle interrupts in the middle of a parse.
112  *
113  * The size 496 was chosen because with 16-byte alignment the total size
114  * for the allocated block is 512.
115  */
116
117 #define MINSIZE 496             /* minimum size of a block. */
118
119
120 struct stack_block {
121         struct stack_block *prev;
122         /* Data follows */
123 };
124 #define SPACE(sp)       ((char*)(sp) + ALIGN(sizeof(struct stack_block)))
125
126 STATIC struct stack_block *stackp;
127 STATIC struct stackmark *markp;
128 char *stacknxt;
129 int stacknleft;
130 int sstrnleft;
131 int herefd = -1;
132
133
134 static void
135 stnewblock(int nbytes)
136 {
137         struct stack_block *sp;
138         int allocsize;
139
140         if (nbytes < MINSIZE)
141                 nbytes = MINSIZE;
142
143         allocsize = ALIGN(sizeof(struct stack_block)) + ALIGN(nbytes);
144
145         INTOFF;
146         sp = ckmalloc(allocsize);
147         sp->prev = stackp;
148         stacknxt = SPACE(sp);
149         stacknleft = allocsize - (stacknxt - (char*)sp);
150         stackp = sp;
151         INTON;
152 }
153
154
155 pointer
156 stalloc(int nbytes)
157 {
158         char *p;
159
160         nbytes = ALIGN(nbytes);
161         if (nbytes > stacknleft)
162                 stnewblock(nbytes);
163         p = stacknxt;
164         stacknxt += nbytes;
165         stacknleft -= nbytes;
166         return p;
167 }
168
169
170 void
171 stunalloc(pointer p)
172 {
173         if (p == NULL) {                /*DEBUG */
174                 write(STDERR_FILENO, "stunalloc\n", 10);
175                 abort();
176         }
177         stacknleft += stacknxt - (char *)p;
178         stacknxt = p;
179 }
180
181
182
183 void
184 setstackmark(struct stackmark *mark)
185 {
186         mark->stackp = stackp;
187         mark->stacknxt = stacknxt;
188         mark->stacknleft = stacknleft;
189         mark->marknext = markp;
190         markp = mark;
191 }
192
193
194 void
195 popstackmark(struct stackmark *mark)
196 {
197         struct stack_block *sp;
198
199         INTOFF;
200         markp = mark->marknext;
201         while (stackp != mark->stackp) {
202                 sp = stackp;
203                 stackp = sp->prev;
204                 ckfree(sp);
205         }
206         stacknxt = mark->stacknxt;
207         stacknleft = mark->stacknleft;
208         INTON;
209 }
210
211
212 /*
213  * When the parser reads in a string, it wants to stick the string on the
214  * stack and only adjust the stack pointer when it knows how big the
215  * string is.  Stackblock (defined in stack.h) returns a pointer to a block
216  * of space on top of the stack and stackblocklen returns the length of
217  * this block.  Growstackblock will grow this space by at least one byte,
218  * possibly moving it (like realloc).  Grabstackblock actually allocates the
219  * part of the block that has been used.
220  */
221
222 void
223 growstackblock(void)
224 {
225         char *p;
226         int newlen;
227         char *oldspace;
228         int oldlen;
229         struct stack_block *sp;
230         struct stack_block *oldstackp;
231         struct stackmark *xmark;
232
233         newlen = (stacknleft == 0) ? MINSIZE : stacknleft * 2 + 100;
234         newlen = ALIGN(newlen);
235         oldspace = stacknxt;
236         oldlen = stacknleft;
237
238         if (stackp != NULL && stacknxt == SPACE(stackp)) {
239                 INTOFF;
240                 oldstackp = stackp;
241                 stackp = oldstackp->prev;
242                 sp = ckrealloc((pointer)oldstackp, newlen);
243                 sp->prev = stackp;
244                 stackp = sp;
245                 stacknxt = SPACE(sp);
246                 stacknleft = newlen - (stacknxt - (char*)sp);
247
248                 /*
249                  * Stack marks pointing to the start of the old block
250                  * must be relocated to point to the new block
251                  */
252                 xmark = markp;
253                 while (xmark != NULL && xmark->stackp == oldstackp) {
254                         xmark->stackp = stackp;
255                         xmark->stacknxt = stacknxt;
256                         xmark->stacknleft = stacknleft;
257                         xmark = xmark->marknext;
258                 }
259                 INTON;
260         } else {
261                 p = stalloc(newlen);
262                 if (oldlen != 0)
263                         memcpy(p, oldspace, oldlen);
264                 stunalloc(p);
265         }
266 }
267
268
269
270 void
271 grabstackblock(int len)
272 {
273         len = ALIGN(len);
274         stacknxt += len;
275         stacknleft -= len;
276 }
277
278
279
280 /*
281  * The following routines are somewhat easier to use that the above.
282  * The user declares a variable of type STACKSTR, which may be declared
283  * to be a register.  The macro STARTSTACKSTR initializes things.  Then
284  * the user uses the macro STPUTC to add characters to the string.  In
285  * effect, STPUTC(c, p) is the same as *p++ = c except that the stack is
286  * grown as necessary.  When the user is done, she can just leave the
287  * string there and refer to it using stackblock().  Or she can allocate
288  * the space for it using grabstackstr().  If it is necessary to allow
289  * someone else to use the stack temporarily and then continue to grow
290  * the string, the user should use grabstack to allocate the space, and
291  * then call ungrabstr(p) to return to the previous mode of operation.
292  *
293  * USTPUTC is like STPUTC except that it doesn't check for overflow.
294  * CHECKSTACKSPACE can be called before USTPUTC to ensure that there
295  * is space for at least one character.
296  */
297
298
299 char *
300 growstackstr(void)
301 {
302         int len;
303
304         len = stackblocksize();
305         if (herefd >= 0 && len >= 1024) {
306                 xwrite(herefd, stackblock(), len);
307                 sstrnleft = len - 1;
308                 return stackblock();
309         }
310         growstackblock();
311         sstrnleft = stackblocksize() - len - 1;
312         return stackblock() + len;
313 }
314
315
316 /*
317  * Called from CHECKSTRSPACE.
318  */
319
320 char *
321 makestrspace(void)
322 {
323         int len;
324
325         len = stackblocksize() - sstrnleft;
326         growstackblock();
327         sstrnleft = stackblocksize() - len;
328         return stackblock() + len;
329 }
330
331
332
333 void
334 ungrabstackstr(char *s, char *p)
335 {
336         stacknleft += stacknxt - s;
337         stacknxt = s;
338         sstrnleft = stacknleft - (p - s);
339 }