Print this page
7127 remove -Wno-missing-braces from Makefile.uts
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/brand/sn1/sn1_brand.c
+++ new/usr/src/uts/common/brand/sn1/sn1_brand.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 22 /*
23 23 * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
24 24 */
25 25
26 26 #include <sys/errno.h>
27 27 #include <sys/exec.h>
28 28 #include <sys/kmem.h>
29 29 #include <sys/modctl.h>
30 30 #include <sys/model.h>
31 31 #include <sys/proc.h>
32 32 #include <sys/syscall.h>
33 33 #include <sys/systm.h>
34 34 #include <sys/thread.h>
35 35 #include <sys/cmn_err.h>
36 36 #include <sys/archsystm.h>
37 37 #include <sys/pathname.h>
38 38
39 39 #include <sys/machbrand.h>
40 40 #include <sys/brand.h>
41 41 #include "sn1_brand.h"
42 42
43 43 char *sn1_emulation_table = NULL;
44 44
45 45 void sn1_init_brand_data(zone_t *);
46 46 void sn1_free_brand_data(zone_t *);
47 47 void sn1_setbrand(proc_t *);
48 48 int sn1_getattr(zone_t *, int, void *, size_t *);
49 49 int sn1_setattr(zone_t *, int, void *, size_t);
50 50 int sn1_brandsys(int, int64_t *, uintptr_t, uintptr_t, uintptr_t,
51 51 uintptr_t, uintptr_t, uintptr_t);
52 52 void sn1_copy_procdata(proc_t *, proc_t *);
53 53 void sn1_proc_exit(struct proc *, klwp_t *);
54 54 void sn1_exec();
55 55 int sn1_initlwp(klwp_t *);
56 56 void sn1_forklwp(klwp_t *, klwp_t *);
57 57 void sn1_freelwp(klwp_t *);
58 58 void sn1_lwpexit(klwp_t *);
59 59 int sn1_elfexec(vnode_t *, execa_t *, uarg_t *, intpdata_t *, int,
60 60 long *, int, caddr_t, cred_t *, int);
61 61
62 62 /* sn1 brand */
63 63 struct brand_ops sn1_brops = {
64 64 sn1_init_brand_data,
65 65 sn1_free_brand_data,
66 66 sn1_brandsys,
67 67 sn1_setbrand,
68 68 sn1_getattr,
69 69 sn1_setattr,
70 70 sn1_copy_procdata,
71 71 sn1_proc_exit,
72 72 sn1_exec,
73 73 lwp_setrval,
74 74 sn1_initlwp,
75 75 sn1_forklwp,
76 76 sn1_freelwp,
77 77 sn1_lwpexit,
78 78 sn1_elfexec,
79 79 NULL,
80 80 NULL,
81 81 NSIG,
82 82 };
83 83
84 84 #ifdef sparc
85 85
86 86 struct brand_mach_ops sn1_mops = {
87 87 sn1_brand_syscall_callback,
88 88 sn1_brand_syscall32_callback
89 89 };
90 90
91 91 #else /* sparc */
92 92
93 93 #ifdef __amd64
94 94
95 95 struct brand_mach_ops sn1_mops = {
96 96 sn1_brand_sysenter_callback,
97 97 sn1_brand_int91_callback,
98 98 sn1_brand_syscall_callback,
99 99 sn1_brand_syscall32_callback
100 100 };
101 101
102 102 #else /* ! __amd64 */
103 103
104 104 struct brand_mach_ops sn1_mops = {
105 105 sn1_brand_sysenter_callback,
106 106 NULL,
107 107 sn1_brand_syscall_callback,
108 108 NULL
109 109 };
110 110 #endif /* __amd64 */
111 111
112 112 #endif /* _sparc */
113 113
114 114 struct brand sn1_brand = {
115 115 BRAND_VER_1,
116 116 "sn1",
117 117 &sn1_brops,
|
↓ open down ↓ |
117 lines elided |
↑ open up ↑ |
118 118 &sn1_mops
119 119 };
120 120
121 121 static struct modlbrand modlbrand = {
122 122 &mod_brandops, /* type of module */
123 123 "Solaris N-1 Brand", /* description of module */
124 124 &sn1_brand /* driver ops */
125 125 };
126 126
127 127 static struct modlinkage modlinkage = {
128 - MODREV_1, (void *)&modlbrand, NULL
128 + MODREV_1, { (void *)&modlbrand, NULL }
129 129 };
130 130
131 131 void
132 132 sn1_setbrand(proc_t *p)
133 133 {
134 134 brand_solaris_setbrand(p, &sn1_brand);
135 135 }
136 136
137 137 /* ARGSUSED */
138 138 int
139 139 sn1_getattr(zone_t *zone, int attr, void *buf, size_t *bufsize)
140 140 {
141 141 return (EINVAL);
142 142 }
143 143
144 144 /* ARGSUSED */
145 145 int
146 146 sn1_setattr(zone_t *zone, int attr, void *buf, size_t bufsize)
147 147 {
148 148 return (EINVAL);
149 149 }
150 150
151 151 /*ARGSUSED*/
152 152 int
153 153 sn1_brandsys(int cmd, int64_t *rval, uintptr_t arg1, uintptr_t arg2,
154 154 uintptr_t arg3, uintptr_t arg4, uintptr_t arg5, uintptr_t arg6)
155 155 {
156 156 int res;
157 157
158 158 *rval = 0;
159 159
160 160 res = brand_solaris_cmd(cmd, arg1, arg2, arg3, &sn1_brand, SN1_VERSION);
161 161 if (res >= 0)
162 162 return (res);
163 163
164 164 return (EINVAL);
165 165 }
166 166
167 167 void
168 168 sn1_copy_procdata(proc_t *child, proc_t *parent)
169 169 {
170 170 brand_solaris_copy_procdata(child, parent, &sn1_brand);
171 171 }
172 172
173 173 void
174 174 sn1_proc_exit(struct proc *p, klwp_t *l)
175 175 {
176 176 brand_solaris_proc_exit(p, l, &sn1_brand);
177 177 }
178 178
179 179 void
180 180 sn1_exec()
181 181 {
182 182 brand_solaris_exec(&sn1_brand);
183 183 }
184 184
185 185 int
186 186 sn1_initlwp(klwp_t *l)
187 187 {
188 188 return (brand_solaris_initlwp(l, &sn1_brand));
189 189 }
190 190
191 191 void
192 192 sn1_forklwp(klwp_t *p, klwp_t *c)
193 193 {
194 194 brand_solaris_forklwp(p, c, &sn1_brand);
195 195 }
196 196
197 197 void
198 198 sn1_freelwp(klwp_t *l)
199 199 {
200 200 brand_solaris_freelwp(l, &sn1_brand);
201 201 }
202 202
203 203 void
204 204 sn1_lwpexit(klwp_t *l)
205 205 {
206 206 brand_solaris_lwpexit(l, &sn1_brand);
207 207 }
208 208
209 209 /*ARGSUSED*/
210 210 void
211 211 sn1_free_brand_data(zone_t *zone)
212 212 {
213 213 }
214 214
215 215 /*ARGSUSED*/
216 216 void
217 217 sn1_init_brand_data(zone_t *zone)
218 218 {
219 219 }
220 220
221 221 int
222 222 sn1_elfexec(vnode_t *vp, execa_t *uap, uarg_t *args, intpdata_t *idatap,
223 223 int level, long *execsz, int setid, caddr_t exec_file, cred_t *cred,
224 224 int brand_action)
225 225 {
226 226 return (brand_solaris_elfexec(vp, uap, args, idatap, level, execsz,
227 227 setid, exec_file, cred, brand_action, &sn1_brand, SN1_BRANDNAME,
228 228 SN1_LIB, SN1_LIB32, SN1_LINKER, SN1_LINKER32));
229 229 }
230 230
231 231 int
232 232 _init(void)
233 233 {
234 234 int err;
235 235
236 236 /*
237 237 * Set up the table indicating which system calls we want to
238 238 * interpose on. We should probably build this automatically from
239 239 * a list of system calls that is shared with the user-space
240 240 * library.
241 241 */
242 242 sn1_emulation_table = kmem_zalloc(NSYSCALL, KM_SLEEP);
243 243 sn1_emulation_table[SYS_read] = 1; /* 3 */
244 244 sn1_emulation_table[SYS_write] = 1; /* 4 */
245 245 sn1_emulation_table[SYS_time] = 1; /* 13 */
246 246 sn1_emulation_table[SYS_getpid] = 1; /* 20 */
247 247 sn1_emulation_table[SYS_mount] = 1; /* 21 */
248 248 sn1_emulation_table[SYS_getuid] = 1; /* 24 */
249 249 sn1_emulation_table[SYS_times] = 1; /* 43 */
250 250 sn1_emulation_table[SYS_getgid] = 1; /* 47 */
251 251 sn1_emulation_table[SYS_utssys] = 1; /* 57 */
252 252 sn1_emulation_table[SYS_waitid] = 1; /* 107 */
253 253 sn1_emulation_table[SYS_uname] = 1; /* 135 */
254 254
255 255 err = mod_install(&modlinkage);
256 256 if (err) {
257 257 cmn_err(CE_WARN, "Couldn't install brand module");
258 258 kmem_free(sn1_emulation_table, NSYSCALL);
259 259 }
260 260
261 261 return (err);
262 262 }
263 263
264 264 int
265 265 _info(struct modinfo *modinfop)
266 266 {
267 267 return (mod_info(&modlinkage, modinfop));
268 268 }
269 269
270 270 int
271 271 _fini(void)
272 272 {
273 273 return (brand_solaris_fini(&sn1_emulation_table, &modlinkage,
274 274 &sn1_brand));
275 275 }
|
↓ open down ↓ |
137 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX