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 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #ifndef _SYS_NSCTL_MODEL_H
27 #define _SYS_NSCTL_MODEL_H
28
29 #ifdef __cplusplus
30 extern "C" {
31 #endif
32
33 /*
34 * Stolen from Solaris 8
35 * Only used for Solaris 2.6
36 */
37 #define _ILP32
38 #undef _ASM
39
40
41 #ifdef _KERNEL
42 #include <sys/debug.h>
43 #endif
44
45 #ifndef DS_DDICT
46 #include <sys/isa_defs.h>
47 #endif
48
49 typedef uint32_t caddr32_t;
50
51 #if defined(_KERNEL) || defined(_KMEMUSER)
52
53 /*
54 * These bits are used in various places to specify the data model
55 * of the originator (and/or consumer) of data items. See <sys/conf.h>
56 * <sys/file.h>, <sys/stream.h> and <sys/sunddi.h>.
57 *
58 * This state should only be known to the kernel implementation.
59 */
60 #define DATAMODEL_MASK 0x0FF00000
61
62 #define DATAMODEL_ILP32 0x00100000
63 #define DATAMODEL_LP64 0x00200000
64
65 #define DATAMODEL_NONE 0
66
67 #if defined(_LP64)
68 #define DATAMODEL_NATIVE DATAMODEL_LP64
69 #elif defined(_ILP32)
70 #define DATAMODEL_NATIVE DATAMODEL_ILP32
71 #else
72 #error "No DATAMODEL_NATIVE specified"
73 #endif /* _LP64 || _ILP32 */
74
75 #endif /* _KERNEL || _KMEMUSER */
76
77 #ifndef _ASM
78 /*
79 * XXX Ick. This type needs to be visible outside the above guard because
80 * the proc structure is visible outside the _KERNEL | _KMEMUSER guard.
81 * If we can make proc internals less visible, (which we obviously should)
82 * then this can be invisible too.
83 */
84 typedef unsigned int model_t;
85
86 #endif /* _ASM */
87
88 #if defined(_KERNEL) && !defined(_ASM)
89 /*
90 * These macros allow two views of the same piece of memory depending
91 * on the originating user-mode program's data model. See the manual
92 * pages (or uts/README.XX64).
93 */
94 #if defined(_LP64)
95
96 #define STRUCT_HANDLE(struct_type, handle) \
97 struct __##handle##_type { \
98 union { \
99 struct struct_type##32 *m32; \
100 struct struct_type *m64; \
101 } ptr; \
102 model_t model; \
103 } handle = { NULL, DATAMODEL_ILP32 }
104
105 #define STRUCT_DECL(struct_type, handle) \
106 struct struct_type __##handle##_buf; \
107 STRUCT_HANDLE(struct_type, handle)
108
109 #define STRUCT_SET_HANDLE(handle, umodel, addr) \
110 (handle).model = (model_t)(umodel) & DATAMODEL_MASK; \
111 ASSERT(((umodel) & DATAMODEL_MASK) != DATAMODEL_NONE); \
112 ((handle).ptr.m64) = (addr)
113
114 #define STRUCT_INIT(handle, umodel) \
115 STRUCT_SET_HANDLE(handle, umodel, &__##handle##_buf)
116
117 #define STRUCT_SIZE(handle) \
118 ((handle).model == DATAMODEL_ILP32 ? \
119 sizeof (*(handle).ptr.m32) : \
120 sizeof (*(handle).ptr.m64))
121
122 /*
123 * In STRUCT_FADDR and STRUCT_FGETP a sleight of hand is employed to make
124 * the compiler cope with having two different pointer types within ?:.
125 * The (void *) case on the ILP32 case makes it a pointer which can be
126 * converted to the pointer on the LP64 case, thus quieting the compiler.
127 */
128 #define STRUCT_FADDR(handle, field) \
129 ((handle).model == DATAMODEL_ILP32 ? \
130 (void *)&(handle).ptr.m32->field : \
131 &(handle).ptr.m64->field)
132
133 #define STRUCT_FGET(handle, field) \
134 (((handle).model == DATAMODEL_ILP32) ? \
135 (handle).ptr.m32->field : \
136 (handle).ptr.m64->field)
137
138 #define STRUCT_FGETP(handle, field) \
139 ((handle).model == DATAMODEL_ILP32 ? \
140 (void *)(handle).ptr.m32->field : \
141 (handle).ptr.m64->field)
142
143 #define STRUCT_FSET(handle, field, val) \
144 ((handle).model == DATAMODEL_ILP32 ? \
145 ((handle).ptr.m32->field = (val)) : \
146 ((handle).ptr.m64->field = (val)))
147
148 #define STRUCT_FSETP(handle, field, val) \
149 ((handle).model == DATAMODEL_ILP32 ? \
150 (void) ((handle).ptr.m32->field = (caddr32_t)(val)) : \
151 (void) ((handle).ptr.m64->field = (val)))
152
153 #define STRUCT_BUF(handle) ((handle).ptr.m64)
154
155 #define SIZEOF_PTR(umodel) \
156 (((umodel) & DATAMODEL_MASK) == DATAMODEL_ILP32 ? \
157 sizeof (caddr32_t) : \
158 sizeof (caddr_t))
159
160 #define SIZEOF_STRUCT(struct_type, umodel) \
161 (((umodel) & DATAMODEL_MASK) == DATAMODEL_ILP32 ? \
162 sizeof (struct struct_type##32) : \
163 sizeof (struct struct_type))
164
165 #else /* _LP64 */
166
167 #define STRUCT_HANDLE(struct_type, handle) \
168 struct __##handle##_32 { \
169 struct struct_type *ptr; \
170 }; \
171 struct __##handle##_32 handle = { NULL }
172
173 #define STRUCT_DECL(struct_type, handle) \
174 struct struct_type __##handle##_buf; \
175 STRUCT_HANDLE(struct_type, handle)
176
177 #ifdef lint
178 #define STRUCT_SET_HANDLE(handle, umodel, addr) \
179 (void) (umodel); \
180 (handle).ptr = (addr)
181 #else
182 #define STRUCT_SET_HANDLE(handle, umodel, addr) \
183 (handle).ptr = (addr)
184 #endif /* lint */
185
186 #define STRUCT_INIT(handle, umodel) \
187 STRUCT_SET_HANDLE(handle, umodel, &__##handle##_buf)
188
189 #define STRUCT_SIZE(handle) (sizeof (*(handle).ptr))
190
191 #define STRUCT_FADDR(handle, field) (&(handle).ptr->field)
192
193 #define STRUCT_FGET(handle, field) ((handle).ptr->field)
194
195 #define STRUCT_FGETP STRUCT_FGET
196
197 #define STRUCT_FSET(handle, field, val) ((handle).ptr->field = (val))
198
199 #define STRUCT_FSETP STRUCT_FSET
200
201 #define STRUCT_BUF(handle) ((handle).ptr)
202
203 #define SIZEOF_PTR(umodel) sizeof (caddr_t)
204
205 #define SIZEOF_STRUCT(struct_type, umodel) sizeof (struct struct_type)
206
207 #endif /* _LP64 */
208
209 #if defined(_LP64) || defined(lint) || defined(__lint)
210
211 struct _klwp;
212
213 extern model_t lwp_getdatamodel(struct _klwp *);
214 extern model_t get_udatamodel(void);
215
216 #else
217
218 /*
219 * If we're the 32-bit kernel, the result of these function
220 * calls is completely predictable, so let's just cheat. A
221 * good compiler should be able to elide all the unreachable code
222 * that results. Optimism about optimization reigns supreme ;-)
223 */
224 #define lwp_getdatamodel(t) DATAMODEL_ILP32
225 #define get_udatamodel() DATAMODEL_ILP32
226
227 #endif /* _LP64 || lint || __lint */
228
229 #endif /* _KERNEL && !_ASM */
230
231 #ifdef __cplusplus
232 }
233 #endif
234
235 #endif /* _SYS_NSCTL_MODEL_H */