1 /*        $NetBSD: netbsd32_conv.h,v 1.48 2023/07/30 06:52:20 rin Exp $         */
2 
3 /*
4  * Copyright (c) 1998, 2001 Matthew R. Green
5  * 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  *
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,
21  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  */
28 
29 #ifndef _COMPAT_NETBSD32_NETBSD32_CONV_H_
30 #define _COMPAT_NETBSD32_NETBSD32_CONV_H_
31 
32 #include <sys/param.h>
33 #include <sys/systm.h>
34 #include <sys/kernel.h>
35 #include <sys/dirent.h>
36 #include <sys/ipc.h>
37 #include <sys/msg.h>
38 #define msg __msg /* Don't ask me! */
39 #include <sys/sem.h>
40 #include <sys/shm.h>
41 #include <sys/socket.h>
42 #include <sys/stat.h>
43 #include <sys/time.h>
44 #include <sys/timex.h>
45 #include <sys/event.h>
46 #include <sys/epoll.h>
47 
48 #include <compat/sys/dirent.h>
49 
50 #include <prop/plistref.h>
51 
52 #include <nv.h>
53 
54 #include <compat/netbsd32/netbsd32.h>
55 
56 /* converters for structures that we need */
57 static __inline void
netbsd32_from_timeval50(const struct timeval * tv,struct netbsd32_timeval50 * tv32)58 netbsd32_from_timeval50(const struct timeval *tv,
59     struct netbsd32_timeval50 *tv32)
60 {
61 
62           memset(tv32, 0, sizeof(*tv32));
63           tv32->tv_sec = (netbsd32_time50_t)tv->tv_sec;
64           tv32->tv_usec = (netbsd32_long)tv->tv_usec;
65 }
66 
67 static __inline void
netbsd32_from_timeval(const struct timeval * tv,struct netbsd32_timeval * tv32)68 netbsd32_from_timeval(const struct timeval *tv,
69     struct netbsd32_timeval *tv32)
70 {
71 
72           memset(tv32, 0, sizeof(*tv32));
73           tv32->tv_sec = (netbsd32_time_t)tv->tv_sec;
74           tv32->tv_usec = tv->tv_usec;
75 }
76 
77 static __inline void
netbsd32_to_timeval50(const struct netbsd32_timeval50 * tv32,struct timeval * tv)78 netbsd32_to_timeval50(const struct netbsd32_timeval50 *tv32,
79     struct timeval *tv)
80 {
81 
82           memset(tv, 0, sizeof(*tv));
83           tv->tv_sec = (time_t)tv32->tv_sec;
84           tv->tv_usec = tv32->tv_usec;
85 }
86 
87 static __inline void
netbsd32_to_timeval(const struct netbsd32_timeval * tv32,struct timeval * tv)88 netbsd32_to_timeval(const struct netbsd32_timeval *tv32,
89     struct timeval *tv)
90 {
91 
92           memset(tv, 0, sizeof(*tv));
93           tv->tv_sec = (time_t)tv32->tv_sec;
94           tv->tv_usec = tv32->tv_usec;
95 }
96 
97 static __inline void
netbsd32_from_itimerval50(const struct itimerval * itv,struct netbsd32_itimerval50 * itv32)98 netbsd32_from_itimerval50(const struct itimerval *itv,
99     struct netbsd32_itimerval50 *itv32)
100 {
101 
102           memset(itv32, 0, sizeof(*itv32));
103           netbsd32_from_timeval50(&itv->it_interval,
104                                    &itv32->it_interval);
105           netbsd32_from_timeval50(&itv->it_value,
106                                    &itv32->it_value);
107 }
108 
109 static __inline void
netbsd32_from_itimerval(const struct itimerval * itv,struct netbsd32_itimerval * itv32)110 netbsd32_from_itimerval(const struct itimerval *itv,
111     struct netbsd32_itimerval *itv32)
112 {
113 
114           memset(itv32, 0, sizeof(*itv32));
115           netbsd32_from_timeval(&itv->it_interval,
116                                    &itv32->it_interval);
117           netbsd32_from_timeval(&itv->it_value,
118                                    &itv32->it_value);
119 }
120 
121 static __inline void
netbsd32_to_itimerval50(const struct netbsd32_itimerval50 * itv32,struct itimerval * itv)122 netbsd32_to_itimerval50(const struct netbsd32_itimerval50 *itv32,
123     struct itimerval *itv)
124 {
125 
126           memset(itv, 0, sizeof(*itv));
127           netbsd32_to_timeval50(&itv32->it_interval, &itv->it_interval);
128           netbsd32_to_timeval50(&itv32->it_value, &itv->it_value);
129 }
130 
131 static __inline void
netbsd32_to_itimerval(const struct netbsd32_itimerval * itv32,struct itimerval * itv)132 netbsd32_to_itimerval(const struct netbsd32_itimerval *itv32,
133     struct itimerval *itv)
134 {
135 
136           memset(itv, 0, sizeof(*itv));
137           netbsd32_to_timeval(&itv32->it_interval, &itv->it_interval);
138           netbsd32_to_timeval(&itv32->it_value, &itv->it_value);
139 }
140 
141 static __inline void
netbsd32_to_timespec50(const struct netbsd32_timespec50 * s32p,struct timespec * p)142 netbsd32_to_timespec50(const struct netbsd32_timespec50 *s32p,
143     struct timespec *p)
144 {
145 
146           memset(p, 0, sizeof(*p));
147           p->tv_sec = (time_t)s32p->tv_sec;
148           p->tv_nsec = (long)s32p->tv_nsec;
149 }
150 
151 static __inline void
netbsd32_to_timespec(const struct netbsd32_timespec * s32p,struct timespec * p)152 netbsd32_to_timespec(const struct netbsd32_timespec *s32p,
153     struct timespec *p)
154 {
155 
156           memset(p, 0, sizeof(*p));
157           p->tv_sec = (time_t)s32p->tv_sec;
158           p->tv_nsec = (long)s32p->tv_nsec;
159 }
160 
161 static __inline void
netbsd32_from_timespec50(const struct timespec * p,struct netbsd32_timespec50 * s32p)162 netbsd32_from_timespec50(const struct timespec *p,
163     struct netbsd32_timespec50 *s32p)
164 {
165 
166           memset(s32p, 0, sizeof(*s32p));
167           s32p->tv_sec = (netbsd32_time50_t)p->tv_sec;
168           s32p->tv_nsec = (netbsd32_long)p->tv_nsec;
169 }
170 
171 static __inline void
netbsd32_from_timespec(const struct timespec * p,struct netbsd32_timespec * s32p)172 netbsd32_from_timespec(const struct timespec *p,
173     struct netbsd32_timespec *s32p)
174 {
175 
176           memset(s32p, 0, sizeof(*s32p));
177           s32p->tv_sec = (netbsd32_time_t)p->tv_sec;
178           s32p->tv_nsec = (netbsd32_long)p->tv_nsec;
179 }
180 
181 static __inline void
netbsd32_from_rusage(const struct rusage * rup,struct netbsd32_rusage * ru32p)182 netbsd32_from_rusage(const struct rusage *rup,
183     struct netbsd32_rusage *ru32p)
184 {
185 
186           memset(ru32p, 0, sizeof(*ru32p));
187           netbsd32_from_timeval(&rup->ru_utime, &ru32p->ru_utime);
188           netbsd32_from_timeval(&rup->ru_stime, &ru32p->ru_stime);
189 #define C(var)      ru32p->var = (netbsd32_long)rup->var
190           C(ru_maxrss);
191           C(ru_ixrss);
192           C(ru_idrss);
193           C(ru_isrss);
194           C(ru_minflt);
195           C(ru_majflt);
196           C(ru_nswap);
197           C(ru_inblock);
198           C(ru_oublock);
199           C(ru_msgsnd);
200           C(ru_msgrcv);
201           C(ru_nsignals);
202           C(ru_nvcsw);
203           C(ru_nivcsw);
204 #undef C
205 }
206 
207 static __inline void
netbsd32_to_rusage(const struct netbsd32_rusage * ru32p,struct rusage * rup)208 netbsd32_to_rusage(const struct netbsd32_rusage *ru32p,
209     struct rusage *rup)
210 {
211 
212           memset(rup, 0, sizeof(*rup));
213           netbsd32_to_timeval(&ru32p->ru_utime, &rup->ru_utime);
214           netbsd32_to_timeval(&ru32p->ru_stime, &rup->ru_stime);
215 #define C(var)      rup->var = (long)ru32p->var
216           C(ru_maxrss);
217           C(ru_ixrss);
218           C(ru_idrss);
219           C(ru_isrss);
220           C(ru_minflt);
221           C(ru_majflt);
222           C(ru_nswap);
223           C(ru_inblock);
224           C(ru_oublock);
225           C(ru_msgsnd);
226           C(ru_msgrcv);
227           C(ru_nsignals);
228           C(ru_nvcsw);
229           C(ru_nivcsw);
230 #undef C
231 }
232 
233 static __inline void
netbsd32_from_rusage50(const struct rusage * rup,struct netbsd32_rusage50 * ru32p)234 netbsd32_from_rusage50(const struct rusage *rup,
235     struct netbsd32_rusage50 *ru32p)
236 {
237 
238           memset(ru32p, 0, sizeof(*ru32p));
239           netbsd32_from_timeval50(&rup->ru_utime, &ru32p->ru_utime);
240           netbsd32_from_timeval50(&rup->ru_stime, &ru32p->ru_stime);
241 #define C(var)      ru32p->var = (netbsd32_long)rup->var
242           C(ru_maxrss);
243           C(ru_ixrss);
244           C(ru_idrss);
245           C(ru_isrss);
246           C(ru_minflt);
247           C(ru_majflt);
248           C(ru_nswap);
249           C(ru_inblock);
250           C(ru_oublock);
251           C(ru_msgsnd);
252           C(ru_msgrcv);
253           C(ru_nsignals);
254           C(ru_nvcsw);
255           C(ru_nivcsw);
256 #undef C
257 }
258 
259 static __inline int
netbsd32_to_iovecin(const struct netbsd32_iovec * iov32p,struct iovec * iovp,int len)260 netbsd32_to_iovecin(const struct netbsd32_iovec *iov32p, struct iovec *iovp,
261     int len)
262 {
263           int i, error=0;
264           uint32_t iov_base;
265           uint32_t iov_len, total_iov_len;
266 
267           /*
268            * We could allocate an iov32p, do a copyin, and translate
269            * each field and then free it all up, or we could copyin
270            * each field separately.  I'm doing the latter to reduce
271            * the number of MALLOC()s.
272            */
273           memset(iovp, 0, sizeof(*iovp));
274           total_iov_len = 0;
275           for (i = 0; i < len; i++, iovp++, iov32p++) {
276                     if ((error = copyin(&iov32p->iov_base, &iov_base, sizeof(iov_base))))
277                         return error;
278                     if ((error = copyin(&iov32p->iov_len, &iov_len, sizeof(iov_len))))
279                         return error;
280                     iovp->iov_base = (void *)(u_long)iov_base;
281                     iovp->iov_len = (size_t)iov_len;
282 
283                     /*
284                      * System calls return ssize_t because -1 is returned
285                      * on error.  Therefore we must restrict the length to
286                      * SSIZE_MAX (NETBSD32_SSIZE_MAX with compat32) to
287                      * avoid garbage return values.
288                      */
289                     total_iov_len += iov_len;
290                     if (iov_len > NETBSD32_SSIZE_MAX ||
291                         total_iov_len > NETBSD32_SSIZE_MAX) {
292                               return EINVAL;
293                               break;
294                     }
295           }
296           return error;
297 }
298 
299 /* msg_iov must be done separately */
300 static __inline void
netbsd32_to_msghdr(const struct netbsd32_msghdr * mhp32,struct msghdr * mhp)301 netbsd32_to_msghdr(const struct netbsd32_msghdr *mhp32, struct msghdr *mhp)
302 {
303 
304           memset(mhp, 0, sizeof(*mhp));
305           mhp->msg_name = NETBSD32PTR64(mhp32->msg_name);
306           mhp->msg_namelen = mhp32->msg_namelen;
307           mhp->msg_iovlen = (size_t)mhp32->msg_iovlen;
308           mhp->msg_control = NETBSD32PTR64(mhp32->msg_control);
309           mhp->msg_controllen = mhp32->msg_controllen;
310           mhp->msg_flags = mhp32->msg_flags;
311 }
312 
313 /* msg_iov must be done separately */
314 static __inline void
netbsd32_from_msghdr(struct netbsd32_msghdr * mhp32,const struct msghdr * mhp)315 netbsd32_from_msghdr(struct netbsd32_msghdr *mhp32, const struct msghdr *mhp)
316 {
317 
318           memset(mhp32, 0, sizeof(*mhp32));
319           NETBSD32PTR32(mhp32->msg_name, mhp->msg_name);
320           mhp32->msg_namelen = mhp->msg_namelen;
321           mhp32->msg_iovlen = mhp->msg_iovlen;
322           NETBSD32PTR32(mhp32->msg_control, mhp->msg_control);
323           mhp32->msg_controllen = mhp->msg_controllen;
324           mhp32->msg_flags = mhp->msg_flags;
325 }
326 
327 static __inline void
netbsd32_to_mmsghdr(const struct netbsd32_mmsghdr * mmsg32,struct mmsghdr * mmsg)328 netbsd32_to_mmsghdr(const struct netbsd32_mmsghdr *mmsg32,
329     struct mmsghdr *mmsg)
330 {
331 
332           memset(mmsg, 0, sizeof(*mmsg));
333           netbsd32_to_msghdr(&mmsg32->msg_hdr, &mmsg->msg_hdr);
334           mmsg->msg_len = mmsg32->msg_len;
335 }
336 
337 static __inline void
netbsd32_from_mmsghdr(struct netbsd32_mmsghdr * mmsg32,const struct mmsghdr * mmsg)338 netbsd32_from_mmsghdr(struct netbsd32_mmsghdr *mmsg32,
339     const struct mmsghdr *mmsg)
340 {
341 
342           memset(mmsg32, 0, sizeof(*mmsg32));
343           netbsd32_from_msghdr(&mmsg32->msg_hdr, &mmsg->msg_hdr);
344           mmsg32->msg_len = mmsg->msg_len;
345 }
346 
347 static __inline void
netbsd32_from_statvfs90(const struct statvfs * sbp,struct netbsd32_statvfs90 * sb32p)348 netbsd32_from_statvfs90(const struct statvfs *sbp, struct netbsd32_statvfs90 *sb32p)
349 {
350 
351           memset(sb32p, 0, sizeof(*sb32p));
352           sb32p->f_flag = sbp->f_flag;
353           sb32p->f_bsize = (netbsd32_u_long)sbp->f_bsize;
354           sb32p->f_frsize = (netbsd32_u_long)sbp->f_frsize;
355           sb32p->f_iosize = (netbsd32_u_long)sbp->f_iosize;
356           sb32p->f_blocks = sbp->f_blocks;
357           sb32p->f_bfree = sbp->f_bfree;
358           sb32p->f_bavail = sbp->f_bavail;
359           sb32p->f_bresvd = sbp->f_bresvd;
360           sb32p->f_files = sbp->f_files;
361           sb32p->f_ffree = sbp->f_ffree;
362           sb32p->f_favail = sbp->f_favail;
363           sb32p->f_fresvd = sbp->f_fresvd;
364           sb32p->f_syncreads = sbp->f_syncreads;
365           sb32p->f_syncwrites = sbp->f_syncwrites;
366           sb32p->f_asyncreads = sbp->f_asyncreads;
367           sb32p->f_asyncwrites = sbp->f_asyncwrites;
368           sb32p->f_fsidx = sbp->f_fsidx;
369           sb32p->f_fsid = (netbsd32_u_long)sbp->f_fsid;
370           sb32p->f_namemax = (netbsd32_u_long)sbp->f_namemax;
371           sb32p->f_owner = sbp->f_owner;
372           sb32p->f_spare[0] = 0;
373           sb32p->f_spare[1] = 0;
374           sb32p->f_spare[2] = 0;
375           sb32p->f_spare[3] = 0;
376 #if 1
377           /* May as well do the whole batch in one go */
378           memcpy(sb32p->f_fstypename, sbp->f_fstypename,
379               sizeof(sb32p->f_fstypename) + sizeof(sb32p->f_mntonname) +
380               sizeof(sb32p->f_mntfromname));
381 #else
382           /* If we want to be careful */
383           memcpy(sb32p->f_fstypename, sbp->f_fstypename, sizeof(sb32p->f_fstypename));
384           memcpy(sb32p->f_mntonname, sbp->f_mntonname, sizeof(sb32p->f_mntonname));
385           memcpy(sb32p->f_mntfromname, sbp->f_mntfromname, sizeof(sb32p->f_mntfromname));
386 #endif
387 }
388 
389 static __inline void
netbsd32_from_statvfs(const struct statvfs * sbp,struct netbsd32_statvfs * sb32p)390 netbsd32_from_statvfs(const struct statvfs *sbp, struct netbsd32_statvfs *sb32p)
391 {
392 
393           memset(sb32p, 0, sizeof(*sb32p));
394           sb32p->f_flag = sbp->f_flag;
395           sb32p->f_bsize = (netbsd32_u_long)sbp->f_bsize;
396           sb32p->f_frsize = (netbsd32_u_long)sbp->f_frsize;
397           sb32p->f_iosize = (netbsd32_u_long)sbp->f_iosize;
398           sb32p->f_blocks = sbp->f_blocks;
399           sb32p->f_bfree = sbp->f_bfree;
400           sb32p->f_bavail = sbp->f_bavail;
401           sb32p->f_bresvd = sbp->f_bresvd;
402           sb32p->f_files = sbp->f_files;
403           sb32p->f_ffree = sbp->f_ffree;
404           sb32p->f_favail = sbp->f_favail;
405           sb32p->f_fresvd = sbp->f_fresvd;
406           sb32p->f_syncreads = sbp->f_syncreads;
407           sb32p->f_syncwrites = sbp->f_syncwrites;
408           sb32p->f_asyncreads = sbp->f_asyncreads;
409           sb32p->f_asyncwrites = sbp->f_asyncwrites;
410           sb32p->f_fsidx = sbp->f_fsidx;
411           sb32p->f_fsid = (netbsd32_u_long)sbp->f_fsid;
412           sb32p->f_namemax = (netbsd32_u_long)sbp->f_namemax;
413           sb32p->f_owner = sbp->f_owner;
414           sb32p->f_spare[0] = 0;
415           sb32p->f_spare[1] = 0;
416           sb32p->f_spare[2] = 0;
417           sb32p->f_spare[3] = 0;
418 #if 1
419           /* May as well do the whole batch in one go */
420           memcpy(sb32p->f_fstypename, sbp->f_fstypename,
421               sizeof(sb32p->f_fstypename) + sizeof(sb32p->f_mntonname) +
422               sizeof(sb32p->f_mntfromname) + sizeof(sb32p->f_mntfromlabel));
423 #else
424           /* If we want to be careful */
425           memcpy(sb32p->f_fstypename, sbp->f_fstypename, sizeof(sb32p->f_fstypename));
426           memcpy(sb32p->f_mntonname, sbp->f_mntonname, sizeof(sb32p->f_mntonname));
427           memcpy(sb32p->f_mntfromname, sbp->f_mntfromname, sizeof(sb32p->f_mntfromname));
428           memcpy(sb32p->f_mntfromlabel, sbp->f_mntfromlabel, sizeof(sb32p->f_mntfromlabel));
429 #endif
430 }
431 
432 static __inline void
netbsd32_from_timex(const struct timex * txp,struct netbsd32_timex * tx32p)433 netbsd32_from_timex(const struct timex *txp, struct netbsd32_timex *tx32p)
434 {
435 
436           memset(tx32p, 0, sizeof(*tx32p));
437           tx32p->modes = txp->modes;
438           tx32p->offset = (netbsd32_long)txp->offset;
439           tx32p->freq = (netbsd32_long)txp->freq;
440           tx32p->maxerror = (netbsd32_long)txp->maxerror;
441           tx32p->esterror = (netbsd32_long)txp->esterror;
442           tx32p->status = txp->status;
443           tx32p->constant = (netbsd32_long)txp->constant;
444           tx32p->precision = (netbsd32_long)txp->precision;
445           tx32p->tolerance = (netbsd32_long)txp->tolerance;
446           tx32p->ppsfreq = (netbsd32_long)txp->ppsfreq;
447           tx32p->jitter = (netbsd32_long)txp->jitter;
448           tx32p->shift = txp->shift;
449           tx32p->stabil = (netbsd32_long)txp->stabil;
450           tx32p->jitcnt = (netbsd32_long)txp->jitcnt;
451           tx32p->calcnt = (netbsd32_long)txp->calcnt;
452           tx32p->errcnt = (netbsd32_long)txp->errcnt;
453           tx32p->stbcnt = (netbsd32_long)txp->stbcnt;
454 }
455 
456 static __inline void
netbsd32_to_timex(const struct netbsd32_timex * tx32p,struct timex * txp)457 netbsd32_to_timex(const struct netbsd32_timex *tx32p, struct timex *txp)
458 {
459 
460           memset(txp, 0, sizeof(*txp));
461           txp->modes = tx32p->modes;
462           txp->offset = (long)tx32p->offset;
463           txp->freq = (long)tx32p->freq;
464           txp->maxerror = (long)tx32p->maxerror;
465           txp->esterror = (long)tx32p->esterror;
466           txp->status = tx32p->status;
467           txp->constant = (long)tx32p->constant;
468           txp->precision = (long)tx32p->precision;
469           txp->tolerance = (long)tx32p->tolerance;
470           txp->ppsfreq = (long)tx32p->ppsfreq;
471           txp->jitter = (long)tx32p->jitter;
472           txp->shift = tx32p->shift;
473           txp->stabil = (long)tx32p->stabil;
474           txp->jitcnt = (long)tx32p->jitcnt;
475           txp->calcnt = (long)tx32p->calcnt;
476           txp->errcnt = (long)tx32p->errcnt;
477           txp->stbcnt = (long)tx32p->stbcnt;
478 }
479 
480 static __inline void
netbsd32_from___stat13(const struct stat * sbp,struct netbsd32_stat13 * sb32p)481 netbsd32_from___stat13(const struct stat *sbp, struct netbsd32_stat13 *sb32p)
482 {
483 
484           memset(sb32p, 0, sizeof *sb32p);
485           sb32p->st_dev = (uint32_t)sbp->st_dev;
486           sb32p->st_ino = sbp->st_ino;
487           sb32p->st_mode = sbp->st_mode;
488           sb32p->st_nlink = sbp->st_nlink;
489           sb32p->st_uid = sbp->st_uid;
490           sb32p->st_gid = sbp->st_gid;
491           sb32p->st_rdev = (uint32_t)sbp->st_rdev;
492           sb32p->st_size = sbp->st_size;
493           sb32p->st_atimespec.tv_sec = (int32_t)sbp->st_atimespec.tv_sec;
494           sb32p->st_atimespec.tv_nsec = (netbsd32_long)sbp->st_atimespec.tv_nsec;
495           sb32p->st_mtimespec.tv_sec = (int32_t)sbp->st_mtimespec.tv_sec;
496           sb32p->st_mtimespec.tv_nsec = (netbsd32_long)sbp->st_mtimespec.tv_nsec;
497           sb32p->st_ctimespec.tv_sec = (int32_t)sbp->st_ctimespec.tv_sec;
498           sb32p->st_ctimespec.tv_nsec = (netbsd32_long)sbp->st_ctimespec.tv_nsec;
499           sb32p->st_blksize = sbp->st_blksize;
500           sb32p->st_blocks = sbp->st_blocks;
501           sb32p->st_flags = sbp->st_flags;
502           sb32p->st_gen = sbp->st_gen;
503           sb32p->st_birthtimespec.tv_sec = (int32_t)sbp->st_birthtimespec.tv_sec;
504           sb32p->st_birthtimespec.tv_nsec = (netbsd32_long)sbp->st_birthtimespec.tv_nsec;
505 }
506 
507 static __inline void
netbsd32_from___stat50(const struct stat * sbp,struct netbsd32_stat50 * sb32p)508 netbsd32_from___stat50(const struct stat *sbp, struct netbsd32_stat50 *sb32p)
509 {
510 
511           memset(sb32p, 0, sizeof *sb32p);
512           sb32p->st_dev = (uint32_t)sbp->st_dev;
513           sb32p->st_ino = sbp->st_ino;
514           sb32p->st_mode = sbp->st_mode;
515           sb32p->st_nlink = sbp->st_nlink;
516           sb32p->st_uid = sbp->st_uid;
517           sb32p->st_gid = sbp->st_gid;
518           sb32p->st_rdev = (uint32_t)sbp->st_rdev;
519           sb32p->st_size = sbp->st_size;
520           sb32p->st_atimespec.tv_sec = (int32_t)sbp->st_atimespec.tv_sec;
521           sb32p->st_atimespec.tv_nsec = (netbsd32_long)sbp->st_atimespec.tv_nsec;
522           sb32p->st_mtimespec.tv_sec = (int32_t)sbp->st_mtimespec.tv_sec;
523           sb32p->st_mtimespec.tv_nsec = (netbsd32_long)sbp->st_mtimespec.tv_nsec;
524           sb32p->st_ctimespec.tv_sec = (int32_t)sbp->st_ctimespec.tv_sec;
525           sb32p->st_ctimespec.tv_nsec = (netbsd32_long)sbp->st_ctimespec.tv_nsec;
526           sb32p->st_birthtimespec.tv_sec = (int32_t)sbp->st_birthtimespec.tv_sec;
527           sb32p->st_birthtimespec.tv_nsec = (netbsd32_long)sbp->st_birthtimespec.tv_nsec;
528           sb32p->st_blksize = sbp->st_blksize;
529           sb32p->st_blocks = sbp->st_blocks;
530           sb32p->st_flags = sbp->st_flags;
531           sb32p->st_gen = sbp->st_gen;
532 }
533 
534 static __inline void
netbsd32_from_stat(const struct stat * sbp,struct netbsd32_stat * sb32p)535 netbsd32_from_stat(const struct stat *sbp, struct netbsd32_stat *sb32p)
536 {
537 
538           memset(sb32p, 0, sizeof *sb32p);
539           sb32p->st_dev = sbp->st_dev;
540           sb32p->st_ino = sbp->st_ino;
541           sb32p->st_mode = sbp->st_mode;
542           sb32p->st_nlink = sbp->st_nlink;
543           sb32p->st_uid = sbp->st_uid;
544           sb32p->st_gid = sbp->st_gid;
545           sb32p->st_rdev = sbp->st_rdev;
546           sb32p->st_size = sbp->st_size;
547           sb32p->st_atimespec.tv_sec = (netbsd32_time_t)sbp->st_atimespec.tv_sec;
548           sb32p->st_atimespec.tv_nsec = (netbsd32_long)sbp->st_atimespec.tv_nsec;
549           sb32p->st_mtimespec.tv_sec = (netbsd32_time_t)sbp->st_mtimespec.tv_sec;
550           sb32p->st_mtimespec.tv_nsec = (netbsd32_long)sbp->st_mtimespec.tv_nsec;
551           sb32p->st_ctimespec.tv_sec = (netbsd32_time_t)sbp->st_ctimespec.tv_sec;
552           sb32p->st_ctimespec.tv_nsec = (netbsd32_long)sbp->st_ctimespec.tv_nsec;
553           sb32p->st_birthtimespec.tv_sec = (netbsd32_time_t)sbp->st_birthtimespec.tv_sec;
554           sb32p->st_birthtimespec.tv_nsec = (netbsd32_long)sbp->st_birthtimespec.tv_nsec;
555           sb32p->st_blksize = sbp->st_blksize;
556           sb32p->st_blocks = sbp->st_blocks;
557           sb32p->st_flags = sbp->st_flags;
558           sb32p->st_gen = sbp->st_gen;
559 }
560 
561 static __inline void
netbsd32_to_ipc_perm(const struct netbsd32_ipc_perm * ip32p,struct ipc_perm * ipp)562 netbsd32_to_ipc_perm(const struct netbsd32_ipc_perm *ip32p,
563     struct ipc_perm *ipp)
564 {
565 
566           memset(ipp, 0, sizeof(*ipp));
567           ipp->cuid = ip32p->cuid;
568           ipp->cgid = ip32p->cgid;
569           ipp->uid = ip32p->uid;
570           ipp->gid = ip32p->gid;
571           ipp->mode = ip32p->mode;
572           ipp->_seq = ip32p->_seq;
573           ipp->_key = (key_t)ip32p->_key;
574 }
575 
576 static __inline void
netbsd32_from_ipc_perm(const struct ipc_perm * ipp,struct netbsd32_ipc_perm * ip32p)577 netbsd32_from_ipc_perm(const struct ipc_perm *ipp,
578     struct netbsd32_ipc_perm *ip32p)
579 {
580 
581           memset(ip32p, 0, sizeof *ip32p);
582           ip32p->cuid = ipp->cuid;
583           ip32p->cgid = ipp->cgid;
584           ip32p->uid = ipp->uid;
585           ip32p->gid = ipp->gid;
586           ip32p->mode = ipp->mode;
587           ip32p->_seq = ipp->_seq;
588           ip32p->_key = (netbsd32_key_t)ipp->_key;
589 }
590 
591 static __inline void
netbsd32_to_msg(const struct netbsd32_msg * m32p,struct msg * mp)592 netbsd32_to_msg(const struct netbsd32_msg *m32p, struct msg *mp)
593 {
594 
595           memset(mp, 0, sizeof(*mp));
596           mp->msg_next = NETBSD32PTR64(m32p->msg_next);
597           mp->msg_type = (long)m32p->msg_type;
598           mp->msg_ts = m32p->msg_ts;
599           mp->msg_spot = m32p->msg_spot;
600 }
601 
602 static __inline void
netbsd32_from_msg(const struct msg * mp,struct netbsd32_msg * m32p)603 netbsd32_from_msg(const struct msg *mp, struct netbsd32_msg *m32p)
604 {
605 
606           memset(m32p, 0, sizeof *m32p);
607           NETBSD32PTR32(m32p->msg_next, mp->msg_next);
608           m32p->msg_type = (netbsd32_long)mp->msg_type;
609           m32p->msg_ts = mp->msg_ts;
610           m32p->msg_spot = mp->msg_spot;
611 }
612 
613 static __inline void
netbsd32_to_msqid_ds50(const struct netbsd32_msqid_ds50 * ds32p,struct msqid_ds * dsp)614 netbsd32_to_msqid_ds50(const struct netbsd32_msqid_ds50 *ds32p,
615     struct msqid_ds *dsp)
616 {
617 
618           memset(dsp, 0, sizeof(*dsp));
619           netbsd32_to_ipc_perm(&ds32p->msg_perm, &dsp->msg_perm);
620           dsp->_msg_cbytes = (u_long)ds32p->_msg_cbytes;
621           dsp->msg_qnum = (u_long)ds32p->msg_qnum;
622           dsp->msg_qbytes = (u_long)ds32p->msg_qbytes;
623           dsp->msg_lspid = ds32p->msg_lspid;
624           dsp->msg_lrpid = ds32p->msg_lrpid;
625           dsp->msg_rtime = (time_t)ds32p->msg_rtime;
626           dsp->msg_stime = (time_t)ds32p->msg_stime;
627           dsp->msg_ctime = (time_t)ds32p->msg_ctime;
628 }
629 
630 static __inline void
netbsd32_to_msqid_ds(const struct netbsd32_msqid_ds * ds32p,struct msqid_ds * dsp)631 netbsd32_to_msqid_ds(const struct netbsd32_msqid_ds *ds32p,
632     struct msqid_ds *dsp)
633 {
634 
635           memset(dsp, 0, sizeof(*dsp));
636           netbsd32_to_ipc_perm(&ds32p->msg_perm, &dsp->msg_perm);
637           dsp->_msg_cbytes = (u_long)ds32p->_msg_cbytes;
638           dsp->msg_qnum = (u_long)ds32p->msg_qnum;
639           dsp->msg_qbytes = (u_long)ds32p->msg_qbytes;
640           dsp->msg_lspid = ds32p->msg_lspid;
641           dsp->msg_lrpid = ds32p->msg_lrpid;
642           dsp->msg_rtime = (time_t)ds32p->msg_rtime;
643           dsp->msg_stime = (time_t)ds32p->msg_stime;
644           dsp->msg_ctime = (time_t)ds32p->msg_ctime;
645 }
646 
647 static __inline void
netbsd32_from_msqid_ds50(const struct msqid_ds * dsp,struct netbsd32_msqid_ds50 * ds32p)648 netbsd32_from_msqid_ds50(const struct msqid_ds *dsp,
649     struct netbsd32_msqid_ds50 *ds32p)
650 {
651 
652           memset(ds32p, 0, sizeof *ds32p);
653           netbsd32_from_ipc_perm(&dsp->msg_perm, &ds32p->msg_perm);
654           ds32p->_msg_cbytes = (netbsd32_u_long)dsp->_msg_cbytes;
655           ds32p->msg_qnum = (netbsd32_u_long)dsp->msg_qnum;
656           ds32p->msg_qbytes = (netbsd32_u_long)dsp->msg_qbytes;
657           ds32p->msg_lspid = dsp->msg_lspid;
658           ds32p->msg_lrpid = dsp->msg_lrpid;
659           ds32p->msg_rtime = (int32_t)dsp->msg_rtime;
660           ds32p->msg_stime = (int32_t)dsp->msg_stime;
661           ds32p->msg_ctime = (int32_t)dsp->msg_ctime;
662 }
663 
664 static __inline void
netbsd32_from_msqid_ds(const struct msqid_ds * dsp,struct netbsd32_msqid_ds * ds32p)665 netbsd32_from_msqid_ds(const struct msqid_ds *dsp,
666     struct netbsd32_msqid_ds *ds32p)
667 {
668 
669           memset(ds32p, 0, sizeof *ds32p);
670           netbsd32_from_ipc_perm(&dsp->msg_perm, &ds32p->msg_perm);
671           ds32p->_msg_cbytes = (netbsd32_u_long)dsp->_msg_cbytes;
672           ds32p->msg_qnum = (netbsd32_u_long)dsp->msg_qnum;
673           ds32p->msg_qbytes = (netbsd32_u_long)dsp->msg_qbytes;
674           ds32p->msg_lspid = dsp->msg_lspid;
675           ds32p->msg_lrpid = dsp->msg_lrpid;
676           ds32p->msg_rtime = dsp->msg_rtime;
677           ds32p->msg_stime = dsp->msg_stime;
678           ds32p->msg_ctime = dsp->msg_ctime;
679 }
680 
681 static __inline void
netbsd32_to_shmid_ds50(const struct netbsd32_shmid_ds50 * ds32p,struct shmid_ds * dsp)682 netbsd32_to_shmid_ds50(const struct netbsd32_shmid_ds50 *ds32p,
683     struct shmid_ds *dsp)
684 {
685 
686           memset(dsp, 0, sizeof(*dsp));
687           netbsd32_to_ipc_perm(&ds32p->shm_perm, &dsp->shm_perm);
688           dsp->shm_segsz = ds32p->shm_segsz;
689           dsp->shm_lpid = ds32p->shm_lpid;
690           dsp->shm_cpid = ds32p->shm_cpid;
691           dsp->shm_nattch = ds32p->shm_nattch;
692           dsp->shm_atime = (time_t)ds32p->shm_atime;
693           dsp->shm_dtime = (time_t)ds32p->shm_dtime;
694           dsp->shm_ctime = (time_t)ds32p->shm_ctime;
695 }
696 
697 static __inline void
netbsd32_to_shmid_ds(const struct netbsd32_shmid_ds * ds32p,struct shmid_ds * dsp)698 netbsd32_to_shmid_ds(const struct netbsd32_shmid_ds *ds32p,
699     struct shmid_ds *dsp)
700 {
701 
702           memset(dsp, 0, sizeof(*dsp));
703           netbsd32_to_ipc_perm(&ds32p->shm_perm, &dsp->shm_perm);
704           dsp->shm_segsz = ds32p->shm_segsz;
705           dsp->shm_lpid = ds32p->shm_lpid;
706           dsp->shm_cpid = ds32p->shm_cpid;
707           dsp->shm_nattch = ds32p->shm_nattch;
708           dsp->shm_atime = (long)ds32p->shm_atime;
709           dsp->shm_dtime = (time_t)ds32p->shm_dtime;
710           dsp->shm_ctime = (time_t)ds32p->shm_ctime;
711 }
712 
713 static __inline void
netbsd32_from_shmid_ds50(const struct shmid_ds * dsp,struct netbsd32_shmid_ds50 * ds32p)714 netbsd32_from_shmid_ds50(const struct shmid_ds *dsp,
715     struct netbsd32_shmid_ds50 *ds32p)
716 {
717 
718           memset(ds32p, 0, sizeof *ds32p);
719           netbsd32_from_ipc_perm(&dsp->shm_perm, &ds32p->shm_perm);
720           ds32p->shm_segsz = dsp->shm_segsz;
721           ds32p->shm_lpid = dsp->shm_lpid;
722           ds32p->shm_cpid = dsp->shm_cpid;
723           ds32p->shm_nattch = dsp->shm_nattch;
724           ds32p->shm_atime = (int32_t)dsp->shm_atime;
725           ds32p->shm_dtime = (int32_t)dsp->shm_dtime;
726           ds32p->shm_ctime = (int32_t)dsp->shm_ctime;
727 }
728 
729 static __inline void
netbsd32_from_shmid_ds(const struct shmid_ds * dsp,struct netbsd32_shmid_ds * ds32p)730 netbsd32_from_shmid_ds(const struct shmid_ds *dsp,
731     struct netbsd32_shmid_ds *ds32p)
732 {
733 
734           memset(ds32p, 0, sizeof *ds32p);
735           netbsd32_from_ipc_perm(&dsp->shm_perm, &ds32p->shm_perm);
736           ds32p->shm_segsz = dsp->shm_segsz;
737           ds32p->shm_lpid = dsp->shm_lpid;
738           ds32p->shm_cpid = dsp->shm_cpid;
739           ds32p->shm_nattch = dsp->shm_nattch;
740           ds32p->shm_atime = (netbsd32_long)dsp->shm_atime;
741           ds32p->shm_dtime = (netbsd32_long)dsp->shm_dtime;
742           ds32p->shm_ctime = (netbsd32_long)dsp->shm_ctime;
743 }
744 
745 static __inline void
netbsd32_to_semid_ds50(const struct netbsd32_semid_ds50 * s32dsp,struct semid_ds * dsp)746 netbsd32_to_semid_ds50(const struct netbsd32_semid_ds50 *s32dsp,
747     struct semid_ds *dsp)
748 {
749 
750           memset(dsp, 0, sizeof(*dsp));
751           netbsd32_to_ipc_perm(&s32dsp->sem_perm, &dsp->sem_perm);
752           dsp->sem_nsems = (time_t)s32dsp->sem_nsems;
753           dsp->sem_otime = (time_t)s32dsp->sem_otime;
754           dsp->sem_ctime = (time_t)s32dsp->sem_ctime;
755 }
756 
757 static __inline void
netbsd32_to_semid_ds(const struct netbsd32_semid_ds * s32dsp,struct semid_ds * dsp)758 netbsd32_to_semid_ds(const struct netbsd32_semid_ds *s32dsp,
759     struct semid_ds *dsp)
760 {
761 
762           memset(dsp, 0, sizeof(*dsp));
763           netbsd32_to_ipc_perm(&s32dsp->sem_perm, &dsp->sem_perm);
764           dsp->sem_nsems = s32dsp->sem_nsems;
765           dsp->sem_otime = s32dsp->sem_otime;
766           dsp->sem_ctime = s32dsp->sem_ctime;
767 }
768 
769 static __inline void
netbsd32_from_semid_ds50(const struct semid_ds * dsp,struct netbsd32_semid_ds50 * s32dsp)770 netbsd32_from_semid_ds50(const struct semid_ds *dsp,
771     struct netbsd32_semid_ds50 *s32dsp)
772 {
773 
774           memset(s32dsp, 0, sizeof *s32dsp);
775           netbsd32_from_ipc_perm(&dsp->sem_perm, &s32dsp->sem_perm);
776           s32dsp->sem_nsems = (int32_t)dsp->sem_nsems;
777           s32dsp->sem_otime = (int32_t)dsp->sem_otime;
778           s32dsp->sem_ctime = (int32_t)dsp->sem_ctime;
779 }
780 
781 static __inline void
netbsd32_from_semid_ds(const struct semid_ds * dsp,struct netbsd32_semid_ds * s32dsp)782 netbsd32_from_semid_ds(const struct semid_ds *dsp,
783     struct netbsd32_semid_ds *s32dsp)
784 {
785 
786           memset(s32dsp, 0, sizeof *s32dsp);
787           netbsd32_from_ipc_perm(&dsp->sem_perm, &s32dsp->sem_perm);
788           s32dsp->sem_nsems = dsp->sem_nsems;
789           s32dsp->sem_otime = dsp->sem_otime;
790           s32dsp->sem_ctime = dsp->sem_ctime;
791 }
792 
793 static __inline void
netbsd32_from_loadavg(struct netbsd32_loadavg * av32,const struct loadavg * av)794 netbsd32_from_loadavg(struct netbsd32_loadavg *av32,
795     const struct loadavg *av)
796 {
797 
798           memset(av32, 0, sizeof(*av32));
799           av32->ldavg[0] = av->ldavg[0];
800           av32->ldavg[1] = av->ldavg[1];
801           av32->ldavg[2] = av->ldavg[2];
802           av32->fscale = (netbsd32_long)av->fscale;
803 }
804 
805 static __inline void
netbsd32_to_kevent(struct netbsd32_kevent * ke32,struct kevent * ke)806 netbsd32_to_kevent(struct netbsd32_kevent *ke32, struct kevent *ke)
807 {
808 
809           memset(ke, 0, sizeof(*ke));
810           ke->ident = ke32->ident;
811           ke->filter = ke32->filter;
812           ke->flags = ke32->flags;
813           ke->fflags = ke32->fflags;
814           ke->data = ke32->data;
815           ke->udata = NETBSD32PTR64(ke32->udata);
816           memcpy(&ke->ext, &ke32->ext, sizeof(ke->ext));
817 }
818 
819 static __inline void
netbsd32_from_kevent(struct kevent * ke,struct netbsd32_kevent * ke32)820 netbsd32_from_kevent(struct kevent *ke, struct netbsd32_kevent *ke32)
821 {
822 
823           memset(ke32, 0, sizeof(*ke32));
824           ke32->ident = ke->ident;
825           ke32->filter = ke->filter;
826           ke32->flags = ke->flags;
827           ke32->fflags = ke->fflags;
828           ke32->data = ke->data;
829           NETBSD32PTR32(ke32->udata, ke->udata);
830           memcpy(&ke32->ext, &ke->ext, sizeof(ke32->ext));
831 }
832 
833 static __inline void
netbsd32_to_sigevent(const struct netbsd32_sigevent * ev32,struct sigevent * ev)834 netbsd32_to_sigevent(const struct netbsd32_sigevent *ev32, struct sigevent *ev)
835 {
836 
837           memset(ev, 0, sizeof(*ev));
838           ev->sigev_notify = ev32->sigev_notify;
839           ev->sigev_signo = ev32->sigev_signo;
840           /*
841            * XXX sival_ptr, sigev_notify_function and
842            *     sigev_notify_attributes are  currently unused
843            */
844           ev->sigev_value.sival_int = ev32->sigev_value.sival_int;
845           ev->sigev_notify_function = NETBSD32PTR64(ev32->sigev_notify_function);
846           ev->sigev_notify_attributes = NETBSD32PTR64(ev32->sigev_notify_attributes);
847 }
848 
849 static __inline int
netbsd32_to_dirent12(char * buf,int nbytes)850 netbsd32_to_dirent12(char *buf, int nbytes)
851 {
852           struct dirent *ndp, *nndp, *endp;
853           struct dirent12 *odp;
854 
855           odp = (struct dirent12 *)(void *)buf;
856           ndp = (struct dirent *)(void *)buf;
857           endp = (struct dirent *)(void *)&buf[nbytes];
858 
859           /*
860            * In-place conversion. This works because odp
861            * is smaller than ndp, but it has to be done
862            * in the right sequence.
863            */
864           for (; ndp < endp; ndp = nndp) {
865                     nndp = _DIRENT_NEXT(ndp);
866                     odp->d_fileno = (uint32_t)ndp->d_fileno;
867                     if (ndp->d_namlen >= sizeof(odp->d_name))
868                               odp->d_namlen = sizeof(odp->d_name) - 1;
869                     else
870                               odp->d_namlen = (uint8_t)ndp->d_namlen;
871                     odp->d_type = ndp->d_type;
872                     (void)memcpy(odp->d_name, ndp->d_name, (size_t)odp->d_namlen);
873                     odp->d_name[odp->d_namlen] = '\0';
874                     odp->d_reclen = _DIRENT_SIZE(odp);
875                     odp = _DIRENT_NEXT(odp);
876           }
877           return ((char *)(void *)odp) - buf;
878 }
879 
880 static __inline int
netbsd32_copyin_plistref(netbsd32_pointer_t n32p,struct plistref * p)881 netbsd32_copyin_plistref(netbsd32_pointer_t n32p, struct plistref *p)
882 {
883           struct netbsd32_plistref n32plist;
884           int error;
885 
886           error = copyin(NETBSD32PTR64(n32p), &n32plist,
887               sizeof(struct netbsd32_plistref));
888           if (error)
889                     return error;
890           p->pref_plist = NETBSD32PTR64(n32plist.pref_plist);
891           p->pref_len = n32plist.pref_len;
892           return 0;
893 }
894 
895 static __inline int
netbsd32_copyout_plistref(netbsd32_pointer_t n32p,struct plistref * p)896 netbsd32_copyout_plistref(netbsd32_pointer_t n32p, struct plistref *p)
897 {
898           struct netbsd32_plistref n32plist;
899 
900           memset(&n32plist, 0, sizeof(n32plist));
901           NETBSD32PTR32(n32plist.pref_plist, p->pref_plist);
902           n32plist.pref_len = p->pref_len;
903           return copyout(&n32plist, NETBSD32PTR64(n32p),
904               sizeof(struct netbsd32_plistref));
905 }
906 
907 static __inline int
netbsd32_copyin_nvlist_ref_t(netbsd32_pointer_t n32p,nvlist_ref_t * p)908 netbsd32_copyin_nvlist_ref_t(netbsd32_pointer_t n32p, nvlist_ref_t *p)
909 {
910           netbsd32_nvlist_ref_t n32nv;
911           int error;
912 
913           error = copyin(NETBSD32PTR64(n32p), &n32nv,
914               sizeof(netbsd32_nvlist_ref_t));
915           if (error)
916                     return error;
917           p->buf = NETBSD32PTR64(n32nv.buf);
918           p->len = n32nv.len;
919           p->flags = n32nv.flags;
920           return 0;
921 }
922 
923 static __inline int
netbsd32_copyout_nvlist_ref_t(netbsd32_pointer_t n32p,nvlist_ref_t * p)924 netbsd32_copyout_nvlist_ref_t(netbsd32_pointer_t n32p, nvlist_ref_t *p)
925 {
926           netbsd32_nvlist_ref_t n32nv;
927 
928           memset(&n32nv, 0, sizeof(n32nv));
929           NETBSD32PTR32(n32nv.buf, p->buf);
930           n32nv.len = p->len;
931           n32nv.flags = p->flags;
932           return copyout(&n32nv, NETBSD32PTR64(n32p),
933               sizeof(netbsd32_nvlist_ref_t));
934 }
935 
936 static __inline void
netbsd32_to_mq_attr(const struct netbsd32_mq_attr * a32,struct mq_attr * attr)937 netbsd32_to_mq_attr(const struct netbsd32_mq_attr *a32,
938     struct mq_attr *attr)
939 {
940 
941           memset(attr, 0, sizeof(*attr));
942           attr->mq_flags = a32->mq_flags;
943           attr->mq_maxmsg = a32->mq_maxmsg;
944           attr->mq_msgsize = a32->mq_msgsize;
945           attr->mq_curmsgs = a32->mq_curmsgs;
946 }
947 
948 static __inline void
netbsd32_from_mq_attr(const struct mq_attr * attr,struct netbsd32_mq_attr * a32)949 netbsd32_from_mq_attr(const struct mq_attr *attr,
950           struct netbsd32_mq_attr *a32)
951 {
952 
953           memset(a32, 0, sizeof(*a32));
954           a32->mq_flags = attr->mq_flags;
955           a32->mq_maxmsg = attr->mq_maxmsg;
956           a32->mq_msgsize = attr->mq_msgsize;
957           a32->mq_curmsgs = attr->mq_curmsgs;
958 }
959 
960 static __inline void
netbsd32_to_epoll_event(const struct netbsd32_epoll_event * ee32,struct epoll_event * ee)961 netbsd32_to_epoll_event(const struct netbsd32_epoll_event *ee32,
962     struct epoll_event *ee)
963 {
964 
965           memset(ee, 0, sizeof(*ee));
966           ee->events = ee32->events;
967           ee->data = ee32->data;
968 }
969 
970 static __inline void
netbsd32_from_epoll_event(const struct epoll_event * ee,struct netbsd32_epoll_event * ee32)971 netbsd32_from_epoll_event(const struct epoll_event *ee,
972     struct netbsd32_epoll_event *ee32)
973 {
974 
975           memset(ee32, 0, sizeof(*ee32));
976           ee32->events = ee->events;
977           ee32->data = ee->data;
978 }
979 
980 #endif /* _COMPAT_NETBSD32_NETBSD32_CONV_H_ */
981