mksh/R56c/lalloc.c

/*-
 * Copyright (c) 2009, 2010, 2011, 2013, 2014, 2016
 *      mirabilos <m@mirbsd.org>
 *
 * Provided that these terms and disclaimer and all copyright notices
 * are retained or reproduced in an accompanying document, permission
 * is granted to deal in this work without restriction, including un-
 * limited rights to use, publicly perform, distribute, sell, modify,
 * merge, give away, or sublicence.
 *
 * This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to
 * the utmost extent permitted by applicable law, neither express nor
 * implied; without malicious intent or gross negligence. In no event
 * may a licensor, author or contributor be held liable for indirect,
 * direct, other damage, loss, or other issues arising in any way out
 * of dealing in the work, even if advised of the possibility of such
 * damage or existence of a defect, except proven that it results out
 * of said person's immediate fault when using the work as intended.
 */

#include "sh.h"
#ifdef MKSH_ALLOC_CATCH_UNDERRUNS
#include <err.h>
#endif

__RCSID("$MirOS: src/bin/mksh/lalloc.c,v 1.26 2016/02/26 21:53:36 tg Exp $");

/* build with CPPFLAGS+= -DUSE_REALLOC_MALLOC=0 on ancient systems */
#if defined(USE_REALLOC_MALLOC) && (USE_REALLOC_MALLOC == 0)
#define remalloc(p,n)   ((p) == NULL ? malloc_osi(n) : realloc_osi((p), (n)))
#else
#define remalloc(p,n)   realloc_osi((p), (n))
#endif


static struct lalloc_common *findptr(struct lalloc_common **, char *, Area *);

#ifndef MKSH_ALLOC_CATCH_UNDERRUNS
#define ALLOC_ISUNALIGNED(p) (((size_t)(p)) % sizeof(struct lalloc_common))
#else
#define ALLOC_ISUNALIGNED(p) (((size_t)(p)) & 4095)
#undef remalloc
#undef free_osimalloc

static void
free_osimalloc(void *ptr)
{
        struct lalloc_item *lp = ptr;

        if (munmap(lp, lp->len))
                err(1, "free_osimalloc");
}

static void *
remalloc(void *ptr, size_t size)
{
        struct lalloc_item *lp, *lold = ptr;

        size = (size + 4095) & ~(size_t)4095;

        if (lold && lold->len >= size)
                return (ptr);

        if ((lp = mmap(NULL, size, PROT_READ | PROT_WRITE,
            MAP_ANON | MAP_PRIVATE, -1, (off_t)0)) == MAP_FAILED)
                err(1, "remalloc: mmap(%zu)", size);
        if (ALLOC_ISUNALIGNED(lp))
                errx(1, "remalloc: unaligned(%p)", lp);
        if (mprotect(((char *)lp) + 4096, 4096, PROT_NONE))
                err(1, "remalloc: mprotect");
        lp->len = size;

        if (lold) {
                memcpy(((char *)lp) + 8192, ((char *)lold) + 8192,
                    lold->len - 8192);
                if (munmap(lold, lold->len))
                        err(1, "remalloc: munmap");
        }

        return (lp);
}
#endif

void
ainit(Area *ap)
{
#ifdef MKSH_ALLOC_CATCH_UNDERRUNS
        if (sysconf(_SC_PAGESIZE) != 4096) {
                fprintf(stderr, "mksh: fatal: pagesize %lu not 4096!\n",
                    sysconf(_SC_PAGESIZE));
                fflush(stderr);
                abort();
        }
#endif
        /* area pointer and items share struct lalloc_common */
        ap->next = NULL;
}

static struct lalloc_common *
findptr(struct lalloc_common **lpp, char *ptr, Area *ap)
{
        void *lp;

#ifndef MKSH_SMALL
        if (ALLOC_ISUNALIGNED(ptr))
                goto fail;
#endif
        /* get address of ALLOC_ITEM from user item */
        /*
         * note: the alignment of "ptr" to ALLOC_ITEM is checked
         * above; the "void *" gets us rid of a gcc 2.95 warning
         */
        *lpp = (lp = ptr - sizeof(ALLOC_ITEM));
        /* search for allocation item in group list */
        while (ap->next != lp)
                if ((ap = ap->next) == NULL) {
#ifndef MKSH_SMALL
 fail:
#endif
#ifdef DEBUG
                        internal_warningf("rogue pointer %zX in ap %zX",
                            (size_t)ptr, (size_t)ap);
                        /* try to get a coredump */
                        abort();
#else
                        internal_errorf("rogue pointer %zX", (size_t)ptr);
#endif
                }
        return (ap);
}

void *
aresize2(void *ptr, size_t fac1, size_t fac2, Area *ap)
{
        if (notoktomul(fac1, fac2))
                internal_errorf(Tintovfl, fac1, '*', fac2);
        return (aresize(ptr, fac1 * fac2, ap));
}

void *
aresize(void *ptr, size_t numb, Area *ap)
{
        struct lalloc_common *lp = NULL;

        /* resizing (true) or newly allocating? */
        if (ptr != NULL) {
                struct lalloc_common *pp;

                pp = findptr(&lp, ptr, ap);
                pp->next = lp->next;
        }

        if (notoktoadd(numb, sizeof(ALLOC_ITEM)) ||
            (lp = remalloc(lp, numb + sizeof(ALLOC_ITEM))) == NULL
#ifndef MKSH_SMALL
            || ALLOC_ISUNALIGNED(lp)
#endif
            )
                internal_errorf(Toomem, numb);
        /* area pointer and items share struct lalloc_common */
        lp->next = ap->next;
        ap->next = lp;
        /* return user item address */
        return ((char *)lp + sizeof(ALLOC_ITEM));
}

void
afree(void *ptr, Area *ap)
{
        if (ptr != NULL) {
                struct lalloc_common *lp, *pp;

                pp = findptr(&lp, ptr, ap);
                /* unhook */
                pp->next = lp->next;
                /* now free ALLOC_ITEM */
                free_osimalloc(lp);
        }
}

void
afreeall(Area *ap)
{
        struct lalloc_common *lp;

        /* traverse group (linked list) */
        while ((lp = ap->next) != NULL) {
                /* make next ALLOC_ITEM head of list */
                ap->next = lp->next;
                /* free old head */
                free_osimalloc(lp);
        }
}
Revision:	12140
Committed:	Fri Jan 18 20:59:41 2019 UTC (5 years, 3 months ago) by laffer1
Content type:	text/plain
File size:	4784 byte(s)
Log Message:	tag R56c
#	Content
1	/*-
2	* Copyright (c) 2009, 2010, 2011, 2013, 2014, 2016
3	* mirabilos <m@mirbsd.org>
4	*
5	* Provided that these terms and disclaimer and all copyright notices
6	* are retained or reproduced in an accompanying document, permission
7	* is granted to deal in this work without restriction, including un-
8	* limited rights to use, publicly perform, distribute, sell, modify,
9	* merge, give away, or sublicence.
10	*
11	* This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to
12	* the utmost extent permitted by applicable law, neither express nor
13	* implied; without malicious intent or gross negligence. In no event
14	* may a licensor, author or contributor be held liable for indirect,
15	* direct, other damage, loss, or other issues arising in any way out
16	* of dealing in the work, even if advised of the possibility of such
17	* damage or existence of a defect, except proven that it results out
18	* of said person's immediate fault when using the work as intended.
19	*/
20
21	#include "sh.h"
22	#ifdef MKSH_ALLOC_CATCH_UNDERRUNS
23	#include <err.h>
24	#endif
25
26	__RCSID("$MirOS: src/bin/mksh/lalloc.c,v 1.26 2016/02/26 21:53:36 tg Exp $");
27
28	/* build with CPPFLAGS+= -DUSE_REALLOC_MALLOC=0 on ancient systems */
29	#if defined(USE_REALLOC_MALLOC) && (USE_REALLOC_MALLOC == 0)
30	#define remalloc(p,n) ((p) == NULL ? malloc_osi(n) : realloc_osi((p), (n)))
31	#else
32	#define remalloc(p,n) realloc_osi((p), (n))
33	#endif
34
35
36	static struct lalloc_common findptr(struct lalloc_common , char , Area *);
37
38	#ifndef MKSH_ALLOC_CATCH_UNDERRUNS
39	#define ALLOC_ISUNALIGNED(p) (((size_t)(p)) % sizeof(struct lalloc_common))
40	#else
41	#define ALLOC_ISUNALIGNED(p) (((size_t)(p)) & 4095)
42	#undef remalloc
43	#undef free_osimalloc
44
45	static void
46	free_osimalloc(void *ptr)
47	{
48	struct lalloc_item *lp = ptr;
49
50	if (munmap(lp, lp->len))
51	err(1, "free_osimalloc");
52	}
53
54	static void *
55	remalloc(void *ptr, size_t size)
56	{
57	struct lalloc_item lp, lold = ptr;
58
59	size = (size + 4095) & ~(size_t)4095;
60
61	if (lold && lold->len >= size)
62	return (ptr);
63
64	if ((lp = mmap(NULL, size, PROT_READ \| PROT_WRITE,
65	MAP_ANON \| MAP_PRIVATE, -1, (off_t)0)) == MAP_FAILED)
66	err(1, "remalloc: mmap(%zu)", size);
67	if (ALLOC_ISUNALIGNED(lp))
68	errx(1, "remalloc: unaligned(%p)", lp);
69	if (mprotect(((char *)lp) + 4096, 4096, PROT_NONE))
70	err(1, "remalloc: mprotect");
71	lp->len = size;
72
73	if (lold) {
74	memcpy(((char )lp) + 8192, ((char )lold) + 8192,
75	lold->len - 8192);
76	if (munmap(lold, lold->len))
77	err(1, "remalloc: munmap");
78	}
79
80	return (lp);
81	}
82	#endif
83
84	void
85	ainit(Area *ap)
86	{
87	#ifdef MKSH_ALLOC_CATCH_UNDERRUNS
88	if (sysconf(_SC_PAGESIZE) != 4096) {
89	fprintf(stderr, "mksh: fatal: pagesize %lu not 4096!\n",
90	sysconf(_SC_PAGESIZE));
91	fflush(stderr);
92	abort();
93	}
94	#endif
95	/* area pointer and items share struct lalloc_common */
96	ap->next = NULL;
97	}
98
99	static struct lalloc_common *
100	findptr(struct lalloc_common *lpp, char ptr, Area *ap)
101	{
102	void *lp;
103
104	#ifndef MKSH_SMALL
105	if (ALLOC_ISUNALIGNED(ptr))
106	goto fail;
107	#endif
108	/* get address of ALLOC_ITEM from user item */
109	/*
110	* note: the alignment of "ptr" to ALLOC_ITEM is checked
111	* above; the "void *" gets us rid of a gcc 2.95 warning
112	*/
113	*lpp = (lp = ptr - sizeof(ALLOC_ITEM));
114	/* search for allocation item in group list */
115	while (ap->next != lp)
116	if ((ap = ap->next) == NULL) {
117	#ifndef MKSH_SMALL
118	fail:
119	#endif
120	#ifdef DEBUG
121	internal_warningf("rogue pointer %zX in ap %zX",
122	(size_t)ptr, (size_t)ap);
123	/* try to get a coredump */
124	abort();
125	#else
126	internal_errorf("rogue pointer %zX", (size_t)ptr);
127	#endif
128	}
129	return (ap);
130	}
131
132	void *
133	aresize2(void ptr, size_t fac1, size_t fac2, Area ap)
134	{
135	if (notoktomul(fac1, fac2))
136	internal_errorf(Tintovfl, fac1, '*', fac2);
137	return (aresize(ptr, fac1 * fac2, ap));
138	}
139
140	void *
141	aresize(void ptr, size_t numb, Area ap)
142	{
143	struct lalloc_common *lp = NULL;
144
145	/* resizing (true) or newly allocating? */
146	if (ptr != NULL) {
147	struct lalloc_common *pp;
148
149	pp = findptr(&lp, ptr, ap);
150	pp->next = lp->next;
151	}
152
153	if (notoktoadd(numb, sizeof(ALLOC_ITEM)) \|\|
154	(lp = remalloc(lp, numb + sizeof(ALLOC_ITEM))) == NULL
155	#ifndef MKSH_SMALL
156	\|\| ALLOC_ISUNALIGNED(lp)
157	#endif
158	)
159	internal_errorf(Toomem, numb);
160	/* area pointer and items share struct lalloc_common */
161	lp->next = ap->next;
162	ap->next = lp;
163	/* return user item address */
164	return ((char *)lp + sizeof(ALLOC_ITEM));
165	}
166
167	void
168	afree(void ptr, Area ap)
169	{
170	if (ptr != NULL) {
171	struct lalloc_common lp, pp;
172
173	pp = findptr(&lp, ptr, ap);
174	/* unhook */
175	pp->next = lp->next;
176	/* now free ALLOC_ITEM */
177	free_osimalloc(lp);
178	}
179	}
180
181	void
182	afreeall(Area *ap)
183	{
184	struct lalloc_common *lp;
185
186	/* traverse group (linked list) */
187	while ((lp = ap->next) != NULL) {
188	/* make next ALLOC_ITEM head of list */
189	ap->next = lp->next;
190	/* free old head */
191	free_osimalloc(lp);
192	}
193	}