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 (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22/*
23 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
24 * Use is subject to license terms.
25 */
26
27/*	Copyright (c) 1988 AT&T	*/
28/*	  All Rights Reserved  	*/
29
30#ifndef _MALLINT_H
31#define	_MALLINT_H
32
33#pragma ident	"%Z%%M%	%I%	%E% SMI"
34
35/*	From:	SVr4.0	libmalloc:mallint.h	1.3		*/
36
37/*
38 * number of bytes to align to  (must be at least 4, because lower 2 bits
39 * are used for flags
40 *
41 * header and code assume ALIGNSZ is exact multiple of sizeof (struct header *)
42 * several places assume sizeof (long) == sizeof (struct holdblk *)
43 */
44
45#include <sys/types.h>
46
47#ifdef	__cplusplus
48extern "C" {
49#endif
50
51#ifdef _LP64
52#define	ALIGNSZ	16
53#else
54#define	ALIGNSZ	8
55#endif
56
57/*
58 *	template for the header
59 */
60
61struct header {
62	struct header *nextblk;
63	struct header *nextfree;
64	struct header *prevfree;
65	struct header *__Pad;	/* pad to a multiple of ALIGNSZ */
66};
67
68/*
69 *	template for a small block
70 */
71
72struct lblk  {
73	union {
74		/*
75		 * the next free little block in this holding block.
76		 * This field is used when the block is free
77		 */
78		struct lblk *nextfree;
79		/*
80		 * the holding block containing this little block.
81		 * This field is used when the block is allocated
82		 */
83		struct holdblk *holder;
84		/*
85		 * Insure over head is multiple of ALIGNSZ
86		 * assumes  ALIGNSZ >= sizeof pointer
87		 */
88		char __Overhead[ALIGNSZ];
89	}  header;
90	/* There is no telling how big this field really is.  */
91	/* This must be on a ALIGNSZ  boundary */
92	char byte;
93};
94
95/*
96 *	template for holding block
97 */
98struct holdblk {
99	struct holdblk *nexthblk;   /* next holding block */
100	struct holdblk *prevhblk;   /* previous holding block */
101	struct lblk *lfreeq;	/* head of free queue within block */
102	struct lblk *unused;	/* pointer to 1st little block never used */
103	long blksz;		/* size of little blocks contained */
104	struct lblk *__Pad;	/* pad to a multiple of ALIGNSZ */
105	char space[1];		/* start of space to allocate. */
106				/* This must be on a ALIGNSZ boundary */
107};
108
109/*
110 *	 The following manipulate the free queue
111 *
112 *		DELFREEQ will remove x from the free queue
113 *		ADDFREEQ will add an element to the head
114 *			 of the free queue.
115 *		MOVEHEAD will move the free pointers so that
116 *			 x is at the front of the queue
117 */
118#define	ADDFREEQ(x)	(x)->prevfree = &(freeptr[0]);\
119				(x)->nextfree = freeptr[0].nextfree;\
120				freeptr[0].nextfree->prevfree = (x);\
121				freeptr[0].nextfree = (x);\
122				assert((x)->nextfree != (x));\
123				assert((x)->prevfree != (x));
124#define	DELFREEQ(x)	(x)->prevfree->nextfree = (x)->nextfree;\
125				(x)->nextfree->prevfree = (x)->prevfree;\
126				assert((x)->nextfree != (x));\
127				assert((x)->prevfree != (x));
128#define	MOVEHEAD(x)	freeptr[1].prevfree->nextfree = freeptr[0].nextfree;\
129				freeptr[0].nextfree->prevfree = \
130				    freeptr[1].prevfree;\
131				(x)->prevfree->nextfree = &(freeptr[1]);\
132				freeptr[1].prevfree = (x)->prevfree;\
133				(x)->prevfree = &(freeptr[0]);\
134				freeptr[0].nextfree = (x);\
135				assert((x)->nextfree != (x));\
136				assert((x)->prevfree != (x));
137/*
138 *	The following manipulate the busy flag
139 */
140#define	BUSY	1L
141#define	SETBUSY(x)	((struct header *)((long)(x) | BUSY))
142#define	CLRBUSY(x)	((struct header *)((long)(x) & ~BUSY))
143#define	TESTBUSY(x)	((long)(x) & BUSY)
144/*
145 *	The following manipulate the small block flag
146 */
147#define	SMAL	2L
148#define	SETSMAL(x)	((struct lblk *)((long)(x) | SMAL))
149#define	CLRSMAL(x)	((struct lblk *)((long)(x) & ~SMAL))
150#define	TESTSMAL(x)	((long)(x) & SMAL)
151/*
152 *	The following manipulate both flags.  They must be
153 *	type coerced
154 */
155#define	SETALL(x)	((long)(x) | (SMAL | BUSY))
156#define	CLRALL(x)	((long)(x) & ~(SMAL | BUSY))
157/*
158 *	Other useful constants
159 */
160#define	TRUE	1
161#define	FALSE	0
162#define	HEADSZ	sizeof (struct header)	/* size of unallocated block header */
163
164/* MINHEAD is the minimum size of an allocated block header */
165#define	MINHEAD	ALIGNSZ
166
167/* min. block size must as big as HEADSZ */
168#define	MINBLKSZ	HEADSZ
169
170/* memory is gotten from sbrk in multiples of BLOCKSZ */
171#define	BLOCKSZ		2048	/* ??? Too Small, ?? pagesize? */
172
173#define	GROUND	(struct header *)0
174#define	LGROUND	(struct lblk *)0
175#define	HGROUND	(struct holdblk *)0	/* ground for the holding block queue */
176#ifndef	NULL
177#define	NULL	(char *)0
178#endif
179/*
180 *	Structures and constants describing the holding blocks
181 */
182/* default number of small blocks per holding block */
183#define	NUMLBLKS	100
184
185/* size of a holding block with small blocks of size blksz */
186#define	HOLDSZ(blksz)	\
187	    (sizeof (struct holdblk) - sizeof (struct lblk *) + blksz*numlblks)
188#define	FASTCT	6	/* number of blocks that can be allocated quickly */
189
190/* default maximum size block for fast allocation */
191/* assumes initial value of grain == ALIGNSZ */
192#define	MAXFAST	ALIGNSZ*FASTCT
193
194#ifdef	debug
195#define	CHECKQ	checkq();
196#else
197#define	CHECKQ
198#endif
199
200#ifdef	__cplusplus
201}
202#endif
203
204#endif	/* _MALLINT_H */
205