This source file includes following definitions.
- cvt_msqid2imsqid
- cvt_imsqid2msqid
- ibcs2_sys_msgsys
- cvt_sem2isem
- cvt_isem2sem
- cvt_semid2isemid
- cvt_isemid2semid
- ibcs2_sys_semsys
- cvt_shmid2ishmid
- cvt_ishmid2shmid
- ibcs2_sys_shmsys
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27 #include <sys/param.h>
28 #include <sys/systm.h>
29 #include <sys/namei.h>
30 #include <sys/proc.h>
31 #include <sys/file.h>
32 #include <sys/stat.h>
33 #include <sys/filedesc.h>
34 #include <sys/ioctl.h>
35 #include <sys/ipc.h>
36 #include <sys/kernel.h>
37 #include <sys/malloc.h>
38 #include <sys/mbuf.h>
39 #include <sys/mman.h>
40 #include <sys/mount.h>
41 #include <sys/reboot.h>
42 #include <sys/resource.h>
43 #include <sys/resourcevar.h>
44 #include <sys/signal.h>
45 #include <sys/signalvar.h>
46 #include <sys/socket.h>
47 #include <sys/time.h>
48 #include <sys/times.h>
49 #include <sys/vnode.h>
50 #include <sys/uio.h>
51 #include <sys/wait.h>
52 #include <sys/utsname.h>
53 #include <sys/unistd.h>
54 #include <sys/msg.h>
55 #include <sys/sem.h>
56 #include <sys/shm.h>
57 #include <sys/syscallargs.h>
58
59 #include <uvm/uvm_extern.h>
60
61 #include <compat/ibcs2/ibcs2_types.h>
62 #include <compat/ibcs2/ibcs2_signal.h>
63 #include <compat/ibcs2/ibcs2_syscallargs.h>
64 #include <compat/ibcs2/ibcs2_util.h>
65
66 #define IBCS2_IPC_RMID 0
67 #define IBCS2_IPC_SET 1
68 #define IBCS2_IPC_STAT 2
69
70 #ifdef SYSVMSG
71
72
73
74
75 struct ibcs2_msqid_ds {
76 struct ipc_perm msg_perm;
77 struct msg *msg_first;
78 struct msg *msg_last;
79 u_short msg_cbytes;
80 u_short msg_qnum;
81 u_short msg_qbytes;
82 u_short msg_lspid;
83 u_short msg_lrpid;
84 ibcs2_time_t msg_stime;
85 ibcs2_time_t msg_rtime;
86 ibcs2_time_t msg_ctime;
87 };
88
89 void cvt_msqid2imsqid(struct msqid_ds *, struct ibcs2_msqid_ds *);
90 void cvt_imsqid2msqid(struct ibcs2_msqid_ds *, struct msqid_ds *);
91
92 void
93 cvt_msqid2imsqid(bp, ibp)
94 struct msqid_ds *bp;
95 struct ibcs2_msqid_ds *ibp;
96 {
97 ibp->msg_perm = bp->msg_perm;
98 ibp->msg_first = bp->msg_first;
99 ibp->msg_last = bp->msg_last;
100 ibp->msg_cbytes = (u_short)bp->msg_cbytes;
101 ibp->msg_qnum = (u_short)bp->msg_qnum;
102 ibp->msg_qbytes = (u_short)bp->msg_qbytes;
103 ibp->msg_lspid = (u_short)bp->msg_lspid;
104 ibp->msg_lrpid = (u_short)bp->msg_lrpid;
105 ibp->msg_stime = bp->msg_stime;
106 ibp->msg_rtime = bp->msg_rtime;
107 ibp->msg_ctime = bp->msg_ctime;
108 return;
109 }
110
111 void
112 cvt_imsqid2msqid(ibp, bp)
113 struct ibcs2_msqid_ds *ibp;
114 struct msqid_ds *bp;
115 {
116 bp->msg_perm = ibp->msg_perm;
117 bp->msg_first = ibp->msg_first;
118 bp->msg_last = ibp->msg_last;
119 bp->msg_cbytes = ibp->msg_cbytes;
120 bp->msg_qnum = ibp->msg_qnum;
121 bp->msg_qbytes = ibp->msg_qbytes;
122 bp->msg_lspid = ibp->msg_lspid;
123 bp->msg_lrpid = ibp->msg_lrpid;
124 bp->msg_stime = ibp->msg_stime;
125 bp->msg_rtime = ibp->msg_rtime;
126 bp->msg_ctime = ibp->msg_ctime;
127 return;
128 }
129
130 int
131 ibcs2_sys_msgsys(p, v, retval)
132 struct proc *p;
133 void *v;
134 register_t *retval;
135 {
136 struct ibcs2_sys_msgsys_args
137
138
139
140
141
142
143 *uap = v;
144
145 switch (SCARG(uap, which)) {
146 case 0:
147 SCARG(uap, which) = 1;
148 return compat_10_sys_msgsys(p, uap, retval);
149 case 1: {
150 int error;
151 struct compat_10_sys_msgsys_args margs;
152 caddr_t sg = stackgap_init(p->p_emul);
153
154 SCARG(&margs, which) = 0;
155 SCARG(&margs, a2) = SCARG(uap, a2);
156 SCARG(&margs, a4) =
157 (int)stackgap_alloc(&sg, sizeof(struct msqid_ds));
158 SCARG(&margs, a3) = SCARG(uap, a3);
159 switch (SCARG(&margs, a3)) {
160 case IBCS2_IPC_STAT:
161 error = compat_10_sys_msgsys(p, &margs, retval);
162 if (!error)
163 cvt_msqid2imsqid((struct msqid_ds *)
164 SCARG(&margs, a4),
165 (struct ibcs2_msqid_ds *)SCARG(uap, a4));
166 return error;
167 case IBCS2_IPC_SET:
168 cvt_imsqid2msqid((struct ibcs2_msqid_ds *)SCARG(uap,
169 a4),
170 (struct msqid_ds *) SCARG(&margs, a4));
171 return compat_10_sys_msgsys(p, &margs, retval);
172 case IBCS2_IPC_RMID:
173 return compat_10_sys_msgsys(p, &margs, retval);
174 }
175 return EINVAL;
176 }
177 case 2:
178 SCARG(uap, which) = 3;
179 return compat_10_sys_msgsys(p, uap, retval);
180 case 3:
181 SCARG(uap, which) = 2;
182 return compat_10_sys_msgsys(p, uap, retval);
183 default:
184 return EINVAL;
185 }
186 }
187 #endif
188
189
190 #ifdef SYSVSEM
191
192
193
194
195 struct ibcs2_semid_ds {
196 struct ipc_perm sem_perm;
197 struct ibcs2_sem *sem_base;
198 u_short sem_nsems;
199 int pad1;
200 ibcs2_time_t sem_otime;
201 ibcs2_time_t sem_ctime;
202 };
203
204 struct ibcs2_sem {
205 u_short semval;
206 ibcs2_pid_t sempid;
207 u_short semncnt;
208 u_short semzcnt;
209 };
210
211 void cvt_semid2isemid(struct semid_ds *, struct ibcs2_semid_ds *);
212 void cvt_isemid2semid(struct ibcs2_semid_ds *, struct semid_ds *);
213 #ifdef notdef
214 void cvt_sem2isem(struct sem *, struct ibcs2_sem *);
215 void cvt_isem2sem(struct ibcs2_sem *, struct sem *);
216
217 void
218 cvt_sem2isem(bp, ibp)
219 struct sem *bp;
220 struct ibcs2_sem *ibp;
221 {
222 ibp->semval = bp->semval;
223 ibp->sempid = bp->sempid;
224 ibp->semncnt = bp->semncnt;
225 ibp->semzcnt = bp->semzcnt;
226 return;
227 }
228
229 void
230 cvt_isem2sem(ibp, bp)
231 struct ibcs2_sem *ibp;
232 struct sem *bp;
233 {
234 bp->semval = ibp->semval;
235 bp->sempid = ibp->sempid;
236 bp->semncnt = ibp->semncnt;
237 bp->semzcnt = ibp->semzcnt;
238 return;
239 }
240 #endif
241
242 void
243 cvt_semid2isemid(bp, ibp)
244 struct semid_ds *bp;
245 struct ibcs2_semid_ds *ibp;
246 {
247 ibp->sem_perm = bp->sem_perm;
248 ibp->sem_base = (struct ibcs2_sem *)bp->sem_base;
249 ibp->sem_nsems = bp->sem_nsems;
250 ibp->sem_otime = bp->sem_otime;
251 ibp->sem_ctime = bp->sem_ctime;
252 return;
253 }
254
255 void
256 cvt_isemid2semid(ibp, bp)
257 struct ibcs2_semid_ds *ibp;
258 struct semid_ds *bp;
259 {
260 bp->sem_perm = ibp->sem_perm;
261 bp->sem_base = (struct sem *)ibp->sem_base;
262 bp->sem_nsems = ibp->sem_nsems;
263 bp->sem_otime = ibp->sem_otime;
264 bp->sem_ctime = ibp->sem_ctime;
265 return;
266 }
267
268 int
269 ibcs2_sys_semsys(p, v, retval)
270 struct proc *p;
271 void *v;
272 register_t *retval;
273 {
274 struct ibcs2_sys_semsys_args
275
276
277
278
279
280 *uap = v;
281 int error;
282
283 switch (SCARG(uap, which)) {
284 case 0:
285 switch(SCARG(uap, a4)) {
286 case IBCS2_IPC_STAT:
287 {
288 struct ibcs2_semid_ds *isp;
289 struct semid_ds *sp;
290 caddr_t sg = stackgap_init(p->p_emul);
291
292 isp = (struct ibcs2_semid_ds *)SCARG(uap, a5);
293 sp = stackgap_alloc(&sg, sizeof(struct semid_ds));
294 SCARG(uap, a5) = (int)sp;
295 error = compat_10_sys_semsys(p, uap, retval);
296 if (!error) {
297 SCARG(uap, a5) = (int)isp;
298 isp = stackgap_alloc(&sg, sizeof(*isp));
299 cvt_semid2isemid(sp, isp);
300 error = copyout((caddr_t)isp,
301 (caddr_t)SCARG(uap, a5),
302 sizeof(*isp));
303 }
304 return error;
305 }
306 case IBCS2_IPC_SET:
307 {
308 struct ibcs2_semid_ds *isp;
309 struct semid_ds *sp;
310 caddr_t sg = stackgap_init(p->p_emul);
311
312 isp = stackgap_alloc(&sg, sizeof(*isp));
313 sp = stackgap_alloc(&sg, sizeof(*sp));
314 error = copyin((caddr_t)SCARG(uap, a5), (caddr_t)isp,
315 sizeof(*isp));
316 if (error)
317 return error;
318 cvt_isemid2semid(isp, sp);
319 SCARG(uap, a5) = (int)sp;
320 return compat_10_sys_semsys(p, uap, retval);
321 }
322 }
323 return compat_10_sys_semsys(p, uap, retval);
324
325 case 1:
326 return compat_10_sys_semsys(p, uap, retval);
327
328 case 2:
329 return compat_10_sys_semsys(p, uap, retval);
330 }
331 return EINVAL;
332 }
333 #endif
334
335
336 #ifdef SYSVSHM
337
338
339
340
341 struct ibcs2_shmid_ds {
342 struct ipc_perm shm_perm;
343 int shm_segsz;
344 int pad1;
345 char pad2[4];
346 u_short shm_lpid;
347 u_short shm_cpid;
348 u_short shm_nattch;
349 u_short shm_cnattch;
350 ibcs2_time_t shm_atime;
351 ibcs2_time_t shm_dtime;
352 ibcs2_time_t shm_ctime;
353 };
354
355 void cvt_shmid2ishmid(struct shmid_ds *, struct ibcs2_shmid_ds *);
356 void cvt_ishmid2shmid(struct ibcs2_shmid_ds *, struct shmid_ds *);
357
358 void
359 cvt_shmid2ishmid(bp, ibp)
360 struct shmid_ds *bp;
361 struct ibcs2_shmid_ds *ibp;
362 {
363 ibp->shm_perm = bp->shm_perm;
364 ibp->shm_segsz = bp->shm_segsz;
365 ibp->shm_lpid = bp->shm_lpid;
366 ibp->shm_cpid = bp->shm_cpid;
367 ibp->shm_nattch = bp->shm_nattch;
368 ibp->shm_cnattch = 0;
369 ibp->shm_atime = bp->shm_atime;
370 ibp->shm_dtime = bp->shm_dtime;
371 ibp->shm_ctime = bp->shm_ctime;
372 return;
373 }
374
375 void
376 cvt_ishmid2shmid(ibp, bp)
377 struct ibcs2_shmid_ds *ibp;
378 struct shmid_ds *bp;
379 {
380 bp->shm_perm = ibp->shm_perm;
381 bp->shm_segsz = ibp->shm_segsz;
382 bp->shm_lpid = ibp->shm_lpid;
383 bp->shm_cpid = ibp->shm_cpid;
384 bp->shm_nattch = ibp->shm_nattch;
385 bp->shm_atime = ibp->shm_atime;
386 bp->shm_dtime = ibp->shm_dtime;
387 bp->shm_ctime = ibp->shm_ctime;
388 bp->shm_internal = (void *)0;
389 return;
390 }
391
392 int
393 ibcs2_sys_shmsys(p, v, retval)
394 struct proc *p;
395 void *v;
396 register_t *retval;
397 {
398 struct ibcs2_sys_shmsys_args
399
400
401
402
403 *uap = v;
404 int error;
405
406 switch (SCARG(uap, which)) {
407 case 0:
408 return compat_10_sys_shmsys(p, uap, retval);
409
410 case 1:
411 switch(SCARG(uap, a3)) {
412 case IBCS2_IPC_STAT:
413 {
414 struct ibcs2_shmid_ds *isp;
415 struct shmid_ds *sp;
416 caddr_t sg = stackgap_init(p->p_emul);
417
418 isp = (struct ibcs2_shmid_ds *)SCARG(uap, a4);
419 sp = stackgap_alloc(&sg, sizeof(*sp));
420 SCARG(uap, a4) = (int)sp;
421 error = compat_10_sys_shmsys(p, uap, retval);
422 if (!error) {
423 SCARG(uap, a4) = (int)isp;
424 isp = stackgap_alloc(&sg, sizeof(*isp));
425 cvt_shmid2ishmid(sp, isp);
426 error = copyout((caddr_t)isp,
427 (caddr_t)SCARG(uap, a4),
428 sizeof(*isp));
429 }
430 return error;
431 }
432 case IBCS2_IPC_SET:
433 {
434 struct ibcs2_shmid_ds *isp;
435 struct shmid_ds *sp;
436 caddr_t sg = stackgap_init(p->p_emul);
437
438 isp = stackgap_alloc(&sg, sizeof(*isp));
439 sp = stackgap_alloc(&sg, sizeof(*sp));
440 error = copyin((caddr_t)SCARG(uap, a4), (caddr_t)isp,
441 sizeof(*isp));
442 if (error)
443 return error;
444 cvt_ishmid2shmid(isp, sp);
445 SCARG(uap, a4) = (int)sp;
446 return compat_10_sys_shmsys(p, uap, retval);
447 }
448 }
449 return compat_10_sys_shmsys(p, uap, retval);
450
451 case 2:
452 return compat_10_sys_shmsys(p, uap, retval);
453
454 case 3:
455 return compat_10_sys_shmsys(p, uap, retval);
456 }
457 return EINVAL;
458 }
459 #endif