![[BACK]](/icons/back.gif){kind=icon}
Return to ibcs2_ipc.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / ibcs2|
Return to ibcs2_ipc.c CVS log | Up to [local] / sys / compat / ibcs2 |
1.1 nbrk 1: /* $OpenBSD: ibcs2_ipc.c,v 1.7 2002/03/14 01:26:50 millert Exp $ */
2: /* $NetBSD: ibcs2_ipc.c,v 1.7 1997/01/18 01:51:41 mycroft Exp $ */
3:
4: /*
5: * Copyright (c) 1995 Scott Bartram
6: * All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. The name of the author may not be used to endorse or promote products
14: * derived from this software without specific prior written permission
15: *
16: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
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: * iBCS2 msgsys call
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: syscallarg(int) which;
138: syscallarg(int) a2;
139: syscallarg(int) a3;
140: syscallarg(int) a4;
141: syscallarg(int) a5;
142: syscallarg(int) a6;
143: } */ *uap = v;
144:
145: switch (SCARG(uap, which)) {
146: case 0: /* msgget */
147: SCARG(uap, which) = 1;
148: return compat_10_sys_msgsys(p, uap, retval);
149: case 1: { /* msgctl */
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: /* msgrcv */
178: SCARG(uap, which) = 3;
179: return compat_10_sys_msgsys(p, uap, retval);
180: case 3: /* msgsnd */
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: * iBCS2 semsys call
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: syscallarg(int) which;
276: syscallarg(int) a2;
277: syscallarg(int) a3;
278: syscallarg(int) a4;
279: syscallarg(int) a5;
280: } */ *uap = v;
281: int error;
282:
283: switch (SCARG(uap, which)) {
284: case 0: /* semctl */
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: /* semget */
326: return compat_10_sys_semsys(p, uap, retval);
327:
328: case 2: /* semop */
329: return compat_10_sys_semsys(p, uap, retval);
330: }
331: return EINVAL;
332: }
333: #endif
334:
335:
336: #ifdef SYSVSHM
337: /*
338: * iBCS2 shmsys call
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; /* ignored anyway */
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; /* ignored anyway */
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: syscallarg(int) which;
400: syscallarg(int) a2;
401: syscallarg(int) a3;
402: syscallarg(int) a4;
403: } */ *uap = v;
404: int error;
405:
406: switch (SCARG(uap, which)) {
407: case 0: /* shmat */
408: return compat_10_sys_shmsys(p, uap, retval);
409:
410: case 1: /* shmctl */
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: /* shmdt */
452: return compat_10_sys_shmsys(p, uap, retval);
453:
454: case 3: /* shmget */
455: return compat_10_sys_shmsys(p, uap, retval);
456: }
457: return EINVAL;
458: }
459: #endif