Annotation of sys/compat/osf1/osf1_cvt.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: osf1_cvt.c,v 1.3 2006/02/16 20:32:33 miod Exp $ */
2: /* $NetBSD: osf1_cvt.c,v 1.7 1999/06/26 01:23:23 cgd Exp $ */
3:
4: /*
5: * Copyright (c) 1999 Christopher G. Demetriou. All rights reserved.
6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: * 3. All advertising materials mentioning features or use of this software
16: * must display the following acknowledgement:
17: * This product includes software developed by Christopher G. Demetriou
18: * for the NetBSD Project.
19: * 4. The name of the author may not be used to endorse or promote products
20: * derived from this software without specific prior written permission
21: *
22: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
26: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
27: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
31: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32: */
33:
34: /*
35: * Copyright (c) 1994, 1995 Carnegie-Mellon University.
36: * All rights reserved.
37: *
38: * Author: Chris G. Demetriou
39: *
40: * Permission to use, copy, modify and distribute this software and
41: * its documentation is hereby granted, provided that both the copyright
42: * notice and this permission notice appear in all copies of the
43: * software, derivative works or modified versions, and any portions
44: * thereof, and that both notices appear in supporting documentation.
45: *
46: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
47: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
48: * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
49: *
50: * Carnegie Mellon requests users of this software to return to
51: *
52: * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
53: * School of Computer Science
54: * Carnegie Mellon University
55: * Pittsburgh PA 15213-3890
56: *
57: * any improvements or extensions that they make and grant Carnegie the
58: * rights to redistribute these changes.
59: */
60:
61: #include <sys/param.h>
62: #include <sys/systm.h>
63: #include <sys/namei.h>
64: #include <sys/proc.h>
65: #include <sys/file.h>
66: #include <sys/stat.h>
67: #include <sys/filedesc.h>
68: #include <sys/kernel.h>
69: #include <sys/malloc.h>
70: #include <sys/mman.h>
71: #include <sys/mount.h>
72: #include <sys/signal.h>
73: #include <sys/signalvar.h>
74: #include <sys/reboot.h>
75: #include <sys/syscallargs.h>
76: #include <sys/exec.h>
77: #include <sys/vnode.h>
78: #include <sys/socketvar.h>
79: #include <sys/resource.h>
80: #include <sys/resourcevar.h>
81: #include <sys/wait.h>
82: #include <uvm/uvm_extern.h> /* XXX see mmap emulation */
83:
84: #include <nfs/rpcv2.h>
85: #include <nfs/nfsproto.h>
86: #include <nfs/nfs.h>
87: #include <nfs/nfsmount.h>
88:
89: #include <compat/osf1/osf1.h>
90: #include <compat/osf1/osf1_util.h>
91: #include <compat/osf1/osf1_cvt.h>
92:
93: const struct emul_flags_xtab osf1_access_flags_xtab[] = {
94: #if 0 /* pseudo-flag */
95: { OSF1_F_OK, OSF1_F_OK, F_OK },
96: #endif
97: { OSF1_X_OK, OSF1_X_OK, X_OK },
98: { OSF1_W_OK, OSF1_W_OK, W_OK },
99: { OSF1_R_OK, OSF1_R_OK, R_OK },
100: { 0 }
101: };
102:
103: const struct emul_flags_xtab osf1_fcntl_getsetfd_flags_rxtab[] = {
104: { FD_CLOEXEC, FD_CLOEXEC, OSF1_FD_CLOEXEC },
105: { 0 }
106: };
107:
108: const struct emul_flags_xtab osf1_fcntl_getsetfd_flags_xtab[] = {
109: { OSF1_FD_CLOEXEC, OSF1_FD_CLOEXEC, FD_CLOEXEC },
110: { 0 }
111: };
112:
113: /* flags specific to GETFL/SETFL; also uses open rxtab */
114: const struct emul_flags_xtab osf1_fcntl_getsetfl_flags_rxtab[] = {
115: { FASYNC, FASYNC, OSF1_FASYNC },
116: { 0 }
117: };
118:
119: /* flags specific to GETFL/SETFL; also uses open xtab */
120: const struct emul_flags_xtab osf1_fcntl_getsetfl_flags_xtab[] = {
121: { OSF1_FASYNC, OSF1_FASYNC, FASYNC },
122: { 0 }
123: };
124:
125: const struct emul_flags_xtab osf1_mmap_flags_xtab[] = {
126: { OSF1_MAP_SHARED, OSF1_MAP_SHARED, MAP_SHARED },
127: { OSF1_MAP_PRIVATE, OSF1_MAP_PRIVATE, MAP_PRIVATE },
128: { OSF1_MAP_TYPE, OSF1_MAP_FILE, MAP_FILE },
129: { OSF1_MAP_TYPE, OSF1_MAP_ANON, MAP_ANON },
130: { OSF1_MAP_FIXED, OSF1_MAP_FIXED, MAP_FIXED },
131: #if 0 /* pseudo-flag, and the default */
132: { OSF1_MAP_VARIABLE, OSF1_MAP_VARIABLE, 0 },
133: #endif
134: { OSF1_MAP_HASSEMAPHORE, OSF1_MAP_HASSEMAPHORE, MAP_HASSEMAPHORE },
135: { OSF1_MAP_INHERIT, OSF1_MAP_INHERIT, MAP_INHERIT },
136: #if 0 /* no equivalent +++ */
137: { OSF1_MAP_UNALIGNED, OSF1_MAP_UNALIGNED, ??? },
138: #endif
139: { 0 }
140: };
141:
142: const struct emul_flags_xtab osf1_mmap_prot_xtab[] = {
143: #if 0 /* pseudo-flag */
144: { OSF1_PROT_NONE, OSF1_PROT_NONE, PROT_NONE },
145: #endif
146: { OSF1_PROT_READ, OSF1_PROT_READ, PROT_READ },
147: { OSF1_PROT_WRITE, OSF1_PROT_WRITE, PROT_READ|PROT_WRITE },
148: { OSF1_PROT_EXEC, OSF1_PROT_EXEC, PROT_READ|PROT_EXEC },
149: { 0 }
150: };
151:
152: const struct emul_flags_xtab osf1_nfs_mount_flags_xtab[] = {
153: { OSF1_NFSMNT_SOFT, OSF1_NFSMNT_SOFT, NFSMNT_SOFT, },
154: { OSF1_NFSMNT_WSIZE, OSF1_NFSMNT_WSIZE, NFSMNT_WSIZE, },
155: { OSF1_NFSMNT_RSIZE, OSF1_NFSMNT_RSIZE, NFSMNT_RSIZE, },
156: { OSF1_NFSMNT_TIMEO, OSF1_NFSMNT_TIMEO, NFSMNT_TIMEO, },
157: { OSF1_NFSMNT_RETRANS, OSF1_NFSMNT_RETRANS, NFSMNT_RETRANS, },
158: #if 0 /* no equivalent; needs special handling, see below */
159: { OSF1_NFSMNT_HOSTNAME, OSF1_NFSMNT_HOSTNAME, ???, },
160: #endif
161: { OSF1_NFSMNT_INT, OSF1_NFSMNT_INT, NFSMNT_INT, },
162: { OSF1_NFSMNT_NOCONN, OSF1_NFSMNT_NOCONN, NFSMNT_NOCONN, },
163: #if 0 /* no equivalents */
164: { OSF1_NFSMNT_NOAC, OSF1_NFSMNT_NOAC, ???, },
165: { OSF1_NFSMNT_ACREGMIN, OSF1_NFSMNT_ACREGMIN, ???, },
166: { OSF1_NFSMNT_ACREGMAX, OSF1_NFSMNT_ACREGMAX, ???, },
167: { OSF1_NFSMNT_ACDIRMIN, OSF1_NFSMNT_ACDIRMIN, ???, },
168: { OSF1_NFSMNT_ACDIRMAX, OSF1_NFSMNT_ACDIRMAX, ???, },
169: { OSF1_NFSMNT_NOCTO, OSF1_NFSMNT_NOCTO, ???, },
170: { OSF1_NFSMNT_POSIX, OSF1_NFSMNT_POSIX, ???, },
171: { OSF1_NFSMNT_AUTO, OSF1_NFSMNT_AUTO, ???, },
172: { OSF1_NFSMNT_SEC, OSF1_NFSMNT_SEC, ???, },
173: { OSF1_NFSMNT_TCP, OSF1_NFSMNT_TCP, ???, },
174: { OSF1_NFSMNT_PROPLIST, OSF1_NFSMNT_PROPLIST, ???, },
175: #endif
176: { 0 }
177: };
178:
179: const struct emul_flags_xtab osf1_open_flags_rxtab[] = {
180: { O_ACCMODE, O_RDONLY, OSF1_O_RDONLY },
181: { O_ACCMODE, O_WRONLY, OSF1_O_WRONLY },
182: { O_ACCMODE, O_RDWR, OSF1_O_RDWR },
183: { O_NONBLOCK, O_NONBLOCK, OSF1_O_NONBLOCK },
184: { O_APPEND, O_APPEND, OSF1_O_APPEND },
185: #if 0 /* no equivalent +++ */
186: { ???, ???, O_DEFER },
187: #endif
188: { O_CREAT, O_CREAT, OSF1_O_CREAT },
189: { O_TRUNC, O_TRUNC, OSF1_O_TRUNC },
190: { O_EXCL, O_EXCL, OSF1_O_EXCL },
191: { O_NOCTTY, O_NOCTTY, OSF1_O_NOCTTY },
192: { O_SYNC, O_SYNC, OSF1_O_SYNC },
193: { O_NDELAY, O_NDELAY, OSF1_O_NDELAY },
194: #if 0 /* no equivalent, also same value as O_NDELAY! */
195: { ???, ???, O_DRD },
196: #endif
197: { O_DSYNC, O_DSYNC, OSF1_O_DSYNC },
198: { O_RSYNC, O_RSYNC, OSF1_O_RSYNC },
199: { 0 }
200: };
201:
202: const struct emul_flags_xtab osf1_open_flags_xtab[] = {
203: { OSF1_O_ACCMODE, OSF1_O_RDONLY, O_RDONLY },
204: { OSF1_O_ACCMODE, OSF1_O_WRONLY, O_WRONLY },
205: { OSF1_O_ACCMODE, OSF1_O_RDWR, O_RDWR },
206: { OSF1_O_NONBLOCK, OSF1_O_NONBLOCK, O_NONBLOCK },
207: { OSF1_O_APPEND, OSF1_O_APPEND, O_APPEND },
208: #if 0 /* no equivalent +++ */
209: { OSF1_O_DEFER, OSF1_O_DEFER, ??? },
210: #endif
211: { OSF1_O_CREAT, OSF1_O_CREAT, O_CREAT },
212: { OSF1_O_TRUNC, OSF1_O_TRUNC, O_TRUNC },
213: { OSF1_O_EXCL, OSF1_O_EXCL, O_EXCL },
214: { OSF1_O_NOCTTY, OSF1_O_NOCTTY, O_NOCTTY },
215: { OSF1_O_SYNC, OSF1_O_SYNC, O_SYNC },
216: { OSF1_O_NDELAY, OSF1_O_NDELAY, O_NDELAY },
217: #if 0 /* no equivalent, also same value as O_NDELAY! */
218: { OSF1_O_DRD, OSF1_O_DRD, ??? },
219: #endif
220: { OSF1_O_DSYNC, OSF1_O_DSYNC, O_DSYNC },
221: { OSF1_O_RSYNC, OSF1_O_RSYNC, O_RSYNC },
222: { 0 }
223: };
224:
225: const struct emul_flags_xtab osf1_reboot_opt_xtab[] = {
226: #if 0 /* pseudo-flag */
227: { OSF1_RB_AUTOBOOT, OSF1_RB_AUTOBOOT, RB_AUTOBOOT },
228: #endif
229: { OSF1_RB_ASKNAME, OSF1_RB_ASKNAME, RB_ASKNAME },
230: { OSF1_RB_SINGLE, OSF1_RB_SINGLE, RB_SINGLE },
231: { OSF1_RB_NOSYNC, OSF1_RB_NOSYNC, RB_NOSYNC },
232: #if 0 /* same value as O_NDELAY, only used at boot time? */
233: { OSF1_RB_KDB, OSF1_RB_KDB, RB_KDB },
234: #endif
235: { OSF1_RB_HALT, OSF1_RB_HALT, RB_HALT },
236: { OSF1_RB_INITNAME, OSF1_RB_INITNAME, RB_INITNAME },
237: { OSF1_RB_DFLTROOT, OSF1_RB_DFLTROOT, RB_DFLTROOT },
238: #if 0 /* no equivalents +++ */
239: { OSF1_RB_ALTBOOT, OSF1_RB_ALTBOOT, ??? },
240: { OSF1_RB_UNIPROC, OSF1_RB_UNIPROC, ??? },
241: { OSF1_RB_PARAM, OSF1_RB_PARAM, ??? },
242: #endif
243: { OSF1_RB_DUMP, OSF1_RB_DUMP, RB_DUMP },
244: { 0 }
245: };
246:
247: const struct emul_flags_xtab osf1_sendrecv_msg_flags_xtab[] = {
248: { OSF1_MSG_OOB, OSF1_MSG_OOB, MSG_OOB },
249: { OSF1_MSG_PEEK, OSF1_MSG_PEEK, MSG_PEEK },
250: { OSF1_MSG_DONTROUTE, OSF1_MSG_DONTROUTE, MSG_DONTROUTE },
251: { OSF1_MSG_EOR, OSF1_MSG_EOR, MSG_EOR },
252: { OSF1_MSG_TRUNC, OSF1_MSG_TRUNC, MSG_TRUNC },
253: { OSF1_MSG_CTRUNC, OSF1_MSG_CTRUNC, MSG_CTRUNC },
254: { OSF1_MSG_WAITALL, OSF1_MSG_WAITALL, MSG_WAITALL },
255: { 0 }
256: };
257:
258: const struct emul_flags_xtab osf1_sigaction_flags_rxtab[] = {
259: { SA_ONSTACK, SA_ONSTACK, OSF1_SA_ONSTACK },
260: { SA_RESTART, SA_RESTART, OSF1_SA_RESTART },
261: { SA_NOCLDSTOP, SA_NOCLDSTOP, OSF1_SA_NOCLDSTOP },
262: { SA_NODEFER, SA_NODEFER, OSF1_SA_NODEFER },
263: { SA_RESETHAND, SA_RESETHAND, OSF1_SA_RESETHAND },
264: { SA_NOCLDWAIT, SA_NOCLDWAIT, OSF1_SA_NOCLDWAIT },
265: #if 0 /* XXX not yet */
266: { SA_SIGINFO, SA_SIGINFO, OSF1_SA_SIGINFO },
267: #endif
268: { 0 },
269: };
270:
271: const struct emul_flags_xtab osf1_sigaction_flags_xtab[] = {
272: { OSF1_SA_ONSTACK, OSF1_SA_ONSTACK, SA_ONSTACK },
273: { OSF1_SA_RESTART, OSF1_SA_RESTART, SA_RESTART },
274: { OSF1_SA_NOCLDSTOP, OSF1_SA_NOCLDSTOP, SA_NOCLDSTOP },
275: { OSF1_SA_NODEFER, OSF1_SA_NODEFER, SA_NODEFER },
276: { OSF1_SA_RESETHAND, OSF1_SA_RESETHAND, SA_RESETHAND },
277: { OSF1_SA_NOCLDWAIT, OSF1_SA_NOCLDWAIT, SA_NOCLDWAIT },
278: #if 0 /* XXX not yet */
279: { OSF1_SA_SIGINFO, OSF1_SA_SIGINFO, SA_SIGINFO },
280: #endif
281: { 0 },
282: };
283:
284: const struct emul_flags_xtab osf1_sigaltstack_flags_rxtab[] = {
285: { SS_ONSTACK, SS_ONSTACK, OSF1_SS_ONSTACK },
286: { SS_DISABLE, SS_DISABLE, OSF1_SS_DISABLE },
287: #if 0 /* XXX no equivalents */
288: { ???, ???, OSF1_SS_NOMASK },
289: { ???, ???, OSF1_SS_UCONTEXT },
290: #endif
291: { 0 },
292: };
293:
294: const struct emul_flags_xtab osf1_sigaltstack_flags_xtab[] = {
295: { OSF1_SS_ONSTACK, OSF1_SS_ONSTACK, SS_ONSTACK },
296: { OSF1_SS_DISABLE, OSF1_SS_DISABLE, SS_DISABLE },
297: #if 0 /* XXX no equivalents */
298: { OSF1_SS_NOMASK, OSF1_SS_NOMASK, ??? },
299: { OSF1_SS_UCONTEXT, OSF1_SS_UCONTEXT, ??? },
300: #endif
301: { 0 },
302: };
303:
304: const struct emul_flags_xtab osf1_wait_options_xtab[] = {
305: { OSF1_WNOHANG, OSF1_WNOHANG, WNOHANG },
306: { OSF1_WUNTRACED, OSF1_WUNTRACED, WUNTRACED },
307: { 0 }
308: };
309:
310: void
311: osf1_cvt_flock_from_native(nf, of)
312: const struct flock *nf;
313: struct osf1_flock *of;
314: {
315:
316: memset(of, 0, sizeof *of);
317:
318: of->l_start = nf->l_start;
319: of->l_len = nf->l_len;
320: of->l_pid = nf->l_pid;
321:
322: switch (nf->l_type) {
323: case F_RDLCK:
324: of->l_type = OSF1_F_RDLCK;
325: break;
326:
327: case F_WRLCK:
328: of->l_type = OSF1_F_WRLCK;
329: break;
330:
331: case F_UNLCK:
332: of->l_type = OSF1_F_UNLCK;
333: break;
334: }
335:
336: switch (nf->l_whence) {
337: case SEEK_SET:
338: of->l_whence = OSF1_SEEK_SET;
339: break;
340:
341: case SEEK_CUR:
342: of->l_whence = OSF1_SEEK_CUR;
343: break;
344:
345: case SEEK_END:
346: of->l_whence = OSF1_SEEK_END;
347: break;
348: }
349: }
350:
351: int
352: osf1_cvt_flock_to_native(of, nf)
353: const struct osf1_flock *of;
354: struct flock *nf;
355: {
356:
357: memset(nf, 0, sizeof *nf);
358:
359: nf->l_start = of->l_start;
360: nf->l_len = of->l_len;
361: nf->l_pid = of->l_pid;
362:
363: switch (of->l_type) {
364: case OSF1_F_RDLCK:
365: nf->l_type = F_RDLCK;
366: break;
367:
368: case OSF1_F_WRLCK:
369: nf->l_type = F_WRLCK;
370: break;
371:
372: case OSF1_F_UNLCK:
373: nf->l_type = F_UNLCK;
374: break;
375:
376: default:
377: return (EINVAL);
378: }
379:
380: switch (of->l_whence) {
381: case OSF1_SEEK_SET:
382: nf->l_whence = SEEK_SET;
383: break;
384:
385: case OSF1_SEEK_CUR:
386: nf->l_whence = SEEK_CUR;
387: break;
388:
389: case OSF1_SEEK_END:
390: nf->l_whence = SEEK_END;
391: break;
392:
393: default:
394: return (EINVAL);
395: }
396:
397: return (0);
398: }
399:
400: int
401: osf1_cvt_msghdr_xopen_to_native(omh, bmh)
402: const struct osf1_msghdr_xopen *omh;
403: struct msghdr *bmh;
404: {
405: unsigned long leftovers;
406:
407: memset(bmh, 0, sizeof *bmh);
408: bmh->msg_name = omh->msg_name; /* XXX sockaddr translation */
409: bmh->msg_namelen = omh->msg_namelen;
410: bmh->msg_iov = NULL; /* iovec xlation separate */
411: bmh->msg_iovlen = omh->msg_iovlen;
412:
413: /* XXX we don't translate control messages (yet) */
414: if (bmh->msg_control != NULL || bmh->msg_controllen != 0)
415: {
416: printf("osf1_cvt_msghdr_xopen_to_native: control\n");
417: return (EINVAL);
418: }
419:
420: /* translate flags */
421: bmh->msg_flags = emul_flags_translate(osf1_sendrecv_msg_flags_xtab,
422: omh->msg_flags, &leftovers);
423: if (leftovers != 0)
424: {
425: printf("osf1_cvt_msghdr_xopen_to_native: leftovers 0x%lx\n", leftovers);
426: return (EINVAL);
427: }
428:
429: return (0);
430: }
431:
432: int
433: osf1_cvt_pathconf_name_to_native(oname, bnamep)
434: int oname, *bnamep;
435: {
436: int error;
437:
438: error = 0;
439: switch (oname) {
440: case OSF1__PC_CHOWN_RESTRICTED:
441: *bnamep = _PC_CHOWN_RESTRICTED;
442: break;
443:
444: case OSF1__PC_LINK_MAX:
445: *bnamep = _PC_LINK_MAX;
446: break;
447:
448: case OSF1__PC_MAX_CANON:
449: *bnamep = _PC_MAX_CANON;
450: break;
451:
452: case OSF1__PC_MAX_INPUT:
453: *bnamep = _PC_MAX_INPUT;
454: break;
455:
456: case OSF1__PC_NAME_MAX:
457: *bnamep = _PC_NAME_MAX;
458: break;
459:
460: case OSF1__PC_NO_TRUNC:
461: *bnamep = _PC_NO_TRUNC;
462: break;
463:
464: case OSF1__PC_PATH_MAX:
465: *bnamep = _PC_PATH_MAX;
466: break;
467:
468: case OSF1__PC_PIPE_BUF:
469: *bnamep = _PC_PIPE_BUF;
470: break;
471:
472: case OSF1__PC_VDISABLE:
473: *bnamep = _PC_VDISABLE;
474: break;
475:
476: default:
477: error = EINVAL;
478: break;
479: }
480:
481: return (error);
482: }
483:
484: /*
485: * Convert from as rusage structure to an osf1 rusage structure.
486: */
487: void
488: osf1_cvt_rusage_from_native(ru, oru)
489: const struct rusage *ru;
490: struct osf1_rusage *oru;
491: {
492:
493: oru->ru_utime.tv_sec = ru->ru_utime.tv_sec;
494: oru->ru_utime.tv_usec = ru->ru_utime.tv_usec;
495:
496: oru->ru_stime.tv_sec = ru->ru_stime.tv_sec;
497: oru->ru_stime.tv_usec = ru->ru_stime.tv_usec;
498:
499: oru->ru_maxrss = ru->ru_maxrss;
500: oru->ru_ixrss = ru->ru_ixrss;
501: oru->ru_idrss = ru->ru_idrss;
502: oru->ru_isrss = ru->ru_isrss;
503: oru->ru_minflt = ru->ru_minflt;
504: oru->ru_majflt = ru->ru_majflt;
505: oru->ru_nswap = ru->ru_nswap;
506: oru->ru_inblock = ru->ru_inblock;
507: oru->ru_oublock = ru->ru_oublock;
508: oru->ru_msgsnd = ru->ru_msgsnd;
509: oru->ru_msgrcv = ru->ru_msgrcv;
510: oru->ru_nsignals = ru->ru_nsignals;
511: oru->ru_nvcsw = ru->ru_nvcsw;
512: oru->ru_nivcsw = ru->ru_nivcsw;
513: }
514:
515: /*
516: * XXX: Only a subset of the flags is currently implemented.
517: */
518: void
519: osf1_cvt_sigaction_from_native(bsa, osa)
520: const struct sigaction *bsa;
521: struct osf1_sigaction *osa;
522: {
523: osa->sa__handler = bsa->sa_handler;
524: osf1_cvt_sigset_from_native(&bsa->sa_mask, &osa->sa_mask);
525: osa->sa_flags = 0;
526:
527: /* Translate by hand */
528: if ((bsa->sa_flags & SA_ONSTACK) != 0)
529: osa->sa_flags |= OSF1_SA_ONSTACK;
530: if ((bsa->sa_flags & SA_RESTART) != 0)
531: osa->sa_flags |= OSF1_SA_RESTART;
532: if ((bsa->sa_flags & SA_NOCLDSTOP) != 0)
533: osa->sa_flags |= OSF1_SA_NOCLDSTOP;
534: if ((bsa->sa_flags & SA_NOCLDWAIT) != 0)
535: osa->sa_flags |= OSF1_SA_NOCLDWAIT;
536: if ((bsa->sa_flags & SA_NODEFER) != 0)
537: osa->sa_flags |= OSF1_SA_NODEFER;
538: if ((bsa->sa_flags & SA_RESETHAND) != 0)
539: osa->sa_flags |= OSF1_SA_RESETHAND;
540: if ((bsa->sa_flags & SA_SIGINFO) != 0)
541: osa->sa_flags |= OSF1_SA_SIGINFO;
542: }
543:
544: int
545: osf1_cvt_sigaction_to_native(osa, bsa)
546: const struct osf1_sigaction *osa;
547: struct sigaction *bsa;
548: {
549: bsa->sa_handler = osa->sa__handler;
550: osf1_cvt_sigset_to_native(&osa->sa_mask, &bsa->sa_mask);
551: bsa->sa_flags = 0;
552:
553: /* Translate by hand */
554: if ((osa->sa_flags & OSF1_SA_ONSTACK) != 0)
555: bsa->sa_flags |= SA_ONSTACK;
556: if ((osa->sa_flags & OSF1_SA_RESTART) != 0)
557: bsa->sa_flags |= SA_RESTART;
558: if ((osa->sa_flags & OSF1_SA_RESETHAND) != 0)
559: bsa->sa_flags |= SA_RESETHAND;
560: if ((osa->sa_flags & OSF1_SA_NOCLDSTOP) != 0)
561: bsa->sa_flags |= SA_NOCLDSTOP;
562: if ((osa->sa_flags & OSF1_SA_NOCLDWAIT) != 0)
563: bsa->sa_flags |= SA_NOCLDWAIT;
564: if ((osa->sa_flags & OSF1_SA_NODEFER) != 0)
565: bsa->sa_flags |= SA_NODEFER;
566: if ((osa->sa_flags & OSF1_SA_SIGINFO) != 0)
567: bsa->sa_flags |= SA_SIGINFO;
568:
569: return(0);
570: }
571:
572: void
573: osf1_cvt_sigaltstack_from_native(bss, oss)
574: const struct sigaltstack *bss;
575: struct osf1_sigaltstack *oss;
576: {
577:
578: oss->ss_sp = bss->ss_sp;
579: oss->ss_size = bss->ss_size;
580:
581: /* translate flags */
582: oss->ss_flags = emul_flags_translate(osf1_sigaltstack_flags_rxtab,
583: bss->ss_flags, NULL);
584: }
585:
586: int
587: osf1_cvt_sigaltstack_to_native(oss, bss)
588: const struct osf1_sigaltstack *oss;
589: struct sigaltstack *bss;
590: {
591: unsigned long leftovers;
592:
593: bss->ss_sp = oss->ss_sp;
594: bss->ss_size = oss->ss_size;
595:
596: /* translate flags */
597: bss->ss_flags = emul_flags_translate(osf1_sigaltstack_flags_xtab,
598: oss->ss_flags, &leftovers);
599:
600: if (leftovers != 0) {
601: printf("osf1_cvt_sigaltstack_to_native: leftovers = 0x%lx\n",
602: leftovers);
603: return (EINVAL);
604: }
605:
606: return (0);
607: }
608:
609: void
610: osf1_cvt_sigset_from_native(bss, oss)
611: const sigset_t *bss;
612: osf1_sigset_t *oss;
613: {
614: int i, newsig;
615:
616: osf1_sigemptyset(oss);
617: for (i = 1; i < NSIG; i++) {
618: if (sigismember(bss, i)) {
619: newsig = osf1_signal_rxlist[i];
620: if (newsig)
621: osf1_sigaddset(oss, newsig);
622: }
623: }
624: }
625:
626: int
627: osf1_cvt_sigset_to_native(oss, bss)
628: const osf1_sigset_t *oss;
629: sigset_t *bss;
630: {
631: int i, newsig;
632:
633: sigemptyset(bss);
634: for (i = 1; i < OSF1_NSIG; i++) {
635: if (osf1_sigismember(oss, i)) {
636: newsig = osf1_signal_xlist[i];
637: if (newsig)
638: sigaddset(bss, newsig);
639: }
640: }
641: return (0);
642: }
643:
644: /*
645: * Convert from a stat structure to an osf1 stat structure.
646: */
647: void
648: osf1_cvt_stat_from_native(st, ost)
649: const struct stat *st;
650: struct osf1_stat *ost;
651: {
652:
653: ost->st_dev = osf1_cvt_dev_from_native(st->st_dev);
654: ost->st_ino = st->st_ino;
655: ost->st_mode = st->st_mode;
656: ost->st_nlink = st->st_nlink;
657: ost->st_uid = st->st_uid == -2 ? (u_int16_t) -2 : st->st_uid;
658: ost->st_gid = st->st_gid == -2 ? (u_int16_t) -2 : st->st_gid;
659: ost->st_rdev = osf1_cvt_dev_from_native(st->st_rdev);
660: ost->st_size = st->st_size;
661: ost->st_atime_sec = st->st_atime;
662: ost->st_spare1 = 0;
663: ost->st_mtime_sec = st->st_mtime;
664: ost->st_spare2 = 0;
665: ost->st_ctime_sec = st->st_ctime;
666: ost->st_spare3 = 0;
667: ost->st_blksize = st->st_blksize;
668: ost->st_blocks = st->st_blocks;
669: ost->st_flags = st->st_flags;
670: ost->st_gen = st->st_gen;
671: }
672:
673: void
674: osf1_cvt_statfs_from_native(bsfs, osfs)
675: const struct statfs *bsfs;
676: struct osf1_statfs *osfs;
677: {
678:
679: memset(osfs, 0, sizeof (struct osf1_statfs));
680: if (!strncmp(MOUNT_FFS, bsfs->f_fstypename, MFSNAMELEN))
681: osfs->f_type = OSF1_MOUNT_UFS;
682: else if (!strncmp(MOUNT_NFS, bsfs->f_fstypename, MFSNAMELEN))
683: osfs->f_type = OSF1_MOUNT_NFS;
684: else if (!strncmp(MOUNT_MFS, bsfs->f_fstypename, MFSNAMELEN))
685: osfs->f_type = OSF1_MOUNT_MFS;
686: else
687: /* uh oh... XXX = PC, CDFS, PROCFS, etc. */
688: osfs->f_type = OSF1_MOUNT_ADDON;
689: osfs->f_flags = bsfs->f_flags; /* XXX translate */
690: osfs->f_fsize = bsfs->f_bsize;
691: osfs->f_bsize = bsfs->f_iosize;
692: osfs->f_blocks = bsfs->f_blocks;
693: osfs->f_bfree = bsfs->f_bfree;
694: osfs->f_bavail = bsfs->f_bavail;
695: osfs->f_files = bsfs->f_files;
696: osfs->f_ffree = bsfs->f_ffree;
697: memcpy(&osfs->f_fsid, &bsfs->f_fsid,
698: max(sizeof bsfs->f_fsid, sizeof osfs->f_fsid));
699: /* osfs->f_spare zeroed above */
700: memcpy(osfs->f_mntonname, bsfs->f_mntonname,
701: max(sizeof bsfs->f_mntonname, sizeof osfs->f_mntonname));
702: memcpy(osfs->f_mntfromname, bsfs->f_mntfromname,
703: max(sizeof bsfs->f_mntfromname, sizeof osfs->f_mntfromname));
704: /* XXX osfs->f_xxx should be filled in... */
705: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to osf1_cvt.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / osf1