netbsd32_compat_43.c revision 1.26
1 /* $NetBSD: netbsd32_compat_43.c,v 1.26 2003/06/29 10:39:51 martin 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 * 3. The name of the author may not be used to endorse or promote products 16 * derived from this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 23 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 24 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 25 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 26 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 */ 30 31 #include <sys/cdefs.h> 32 __KERNEL_RCSID(0, "$NetBSD: netbsd32_compat_43.c,v 1.26 2003/06/29 10:39:51 martin Exp $"); 33 34 #if defined(_KERNEL_OPT) 35 #include "opt_compat_43.h" 36 #endif 37 38 #include <sys/param.h> 39 #include <sys/systm.h> 40 #include <sys/fcntl.h> 41 #include <sys/malloc.h> 42 #include <sys/mount.h> 43 #include <sys/proc.h> 44 #include <sys/stat.h> 45 #include <sys/sa.h> 46 #include <sys/syscallargs.h> 47 #include <sys/time.h> 48 #include <sys/ucred.h> 49 #include <uvm/uvm_extern.h> 50 #include <sys/sysctl.h> 51 #include <sys/swap.h> 52 53 #include <compat/netbsd32/netbsd32.h> 54 #include <compat/netbsd32/netbsd32_syscallargs.h> 55 56 int compat_43_netbsd32_sethostid __P((struct lwp *, void *, register_t *)); 57 int compat_43_netbsd32_killpg __P((struct lwp *, void *, register_t *retval)); 58 int compat_43_netbsd32_sigblock __P((struct lwp *, void *, register_t *retval)); 59 int compat_43_netbsd32_sigblock __P((struct lwp *, void *, register_t *retval)); 60 int compat_43_netbsd32_sigsetmask __P((struct lwp *, void *, register_t *retval)); 61 62 void 63 netbsd32_from_stat43(sp43, sp32) 64 struct stat43 *sp43; 65 struct netbsd32_stat43 *sp32; 66 { 67 68 sp32->st_dev = sp43->st_dev; 69 sp32->st_ino = sp43->st_ino; 70 sp32->st_mode = sp43->st_mode; 71 sp32->st_nlink = sp43->st_nlink; 72 sp32->st_uid = sp43->st_uid; 73 sp32->st_gid = sp43->st_gid; 74 sp32->st_rdev = sp43->st_rdev; 75 sp32->st_size = sp43->st_size; 76 sp32->st_atimespec.tv_sec = sp43->st_atimespec.tv_sec; 77 sp32->st_atimespec.tv_nsec = sp43->st_atimespec.tv_nsec; 78 sp32->st_mtimespec.tv_sec = sp43->st_mtimespec.tv_sec; 79 sp32->st_mtimespec.tv_nsec = sp43->st_mtimespec.tv_nsec; 80 sp32->st_ctimespec.tv_sec = sp43->st_ctimespec.tv_sec; 81 sp32->st_ctimespec.tv_nsec = sp43->st_ctimespec.tv_nsec; 82 sp32->st_blksize = sp43->st_blksize; 83 sp32->st_blocks = sp43->st_blocks; 84 sp32->st_flags = sp43->st_flags; 85 sp32->st_gen = sp43->st_gen; 86 } 87 88 /* file system syscalls */ 89 int 90 compat_43_netbsd32_ocreat(l, v, retval) 91 struct lwp *l; 92 void *v; 93 register_t *retval; 94 { 95 struct proc *p = l->l_proc; 96 struct compat_43_netbsd32_ocreat_args /* { 97 syscallarg(const netbsd32_charp) path; 98 syscallarg(mode_t) mode; 99 } */ *uap = v; 100 struct sys_open_args ua; 101 caddr_t sg; 102 103 NETBSD32TOP_UAP(path, const char); 104 NETBSD32TO64_UAP(mode); 105 SCARG(&ua, flags) = O_WRONLY | O_CREAT | O_TRUNC; 106 sg = stackgap_init(p, 0); 107 CHECK_ALT_EXIST(l, &sg, SCARG(&ua, path)); 108 109 return (sys_open(l, &ua, retval)); 110 } 111 112 int 113 compat_43_netbsd32_olseek(l, v, retval) 114 struct lwp *l; 115 void *v; 116 register_t *retval; 117 { 118 struct compat_43_netbsd32_olseek_args /* { 119 syscallarg(int) fd; 120 syscallarg(netbsd32_long) offset; 121 syscallarg(int) whence; 122 } */ *uap = v; 123 struct sys_lseek_args ua; 124 int rv; 125 off_t rt; 126 127 SCARG(&ua, fd) = SCARG(uap, fd); 128 NETBSD32TOX_UAP(offset, long); 129 NETBSD32TO64_UAP(whence); 130 rv = sys_lseek(l, &ua, (register_t *)&rt); 131 *retval = rt; 132 133 return (rv); 134 } 135 136 int 137 compat_43_netbsd32_stat43(l, v, retval) 138 struct lwp *l; 139 void *v; 140 register_t *retval; 141 { 142 struct proc *p = l->l_proc; 143 struct compat_43_netbsd32_stat43_args /* { 144 syscallarg(const netbsd32_charp) path; 145 syscallarg(netbsd32_stat43p_t) ub; 146 } */ *uap = v; 147 struct stat43 sb43, *sgsbp; 148 struct netbsd32_stat43 sb32; 149 struct compat_43_sys_stat_args ua; 150 caddr_t sg = stackgap_init(p, 0); 151 int rv, error; 152 153 NETBSD32TOP_UAP(path, const char); 154 SCARG(&ua, ub) = sgsbp = stackgap_alloc(p, &sg, sizeof(sb43)); 155 CHECK_ALT_EXIST(l, &sg, SCARG(&ua, path)); 156 rv = compat_43_sys_stat(l, &ua, retval); 157 158 error = copyin(sgsbp, &sb43, sizeof(sb43)); 159 if (error) 160 return error; 161 netbsd32_from_stat43(&sb43, &sb32); 162 error = copyout(&sb32, (char *)NETBSD32PTR64(SCARG(uap, ub)), 163 sizeof(sb32)); 164 if (error) 165 return error; 166 167 return (rv); 168 } 169 170 int 171 compat_43_netbsd32_lstat43(l, v, retval) 172 struct lwp *l; 173 void *v; 174 register_t *retval; 175 { 176 struct proc *p = l->l_proc; 177 struct compat_43_netbsd32_lstat43_args /* { 178 syscallarg(const netbsd32_charp) path; 179 syscallarg(netbsd32_stat43p_t) ub; 180 } */ *uap = v; 181 struct stat43 sb43, *sgsbp; 182 struct netbsd32_stat43 sb32; 183 struct compat_43_sys_lstat_args ua; 184 caddr_t sg = stackgap_init(p, 0); 185 int rv, error; 186 187 NETBSD32TOP_UAP(path, const char); 188 SCARG(&ua, ub) = sgsbp = stackgap_alloc(p, &sg, sizeof(sb43)); 189 CHECK_ALT_EXIST(l, &sg, SCARG(&ua, path)); 190 rv = compat_43_sys_stat(l, &ua, retval); 191 192 error = copyin(sgsbp, &sb43, sizeof(sb43)); 193 if (error) 194 return error; 195 netbsd32_from_stat43(&sb43, &sb32); 196 error = copyout(&sb32, (char *)NETBSD32PTR64(SCARG(uap, ub)), 197 sizeof(sb32)); 198 if (error) 199 return error; 200 201 return (rv); 202 } 203 204 int 205 compat_43_netbsd32_fstat43(l, v, retval) 206 struct lwp *l; 207 void *v; 208 register_t *retval; 209 { 210 struct proc *p = l->l_proc; 211 struct compat_43_netbsd32_fstat43_args /* { 212 syscallarg(int) fd; 213 syscallarg(netbsd32_stat43p_t) sb; 214 } */ *uap = v; 215 struct stat43 sb43, *sgsbp; 216 struct netbsd32_stat43 sb32; 217 struct compat_43_sys_fstat_args ua; 218 caddr_t sg = stackgap_init(p, 0); 219 int rv, error; 220 221 NETBSD32TO64_UAP(fd); 222 SCARG(&ua, sb) = sgsbp = stackgap_alloc(p, &sg, sizeof(sb43)); 223 rv = compat_43_sys_fstat(l, &ua, retval); 224 225 error = copyin(sgsbp, &sb43, sizeof(sb43)); 226 if (error) 227 return error; 228 netbsd32_from_stat43(&sb43, &sb32); 229 error = copyout(&sb32, (char *)NETBSD32PTR64(SCARG(uap, sb)), 230 sizeof(sb32)); 231 if (error) 232 return error; 233 234 return (rv); 235 } 236 237 int 238 compat_43_netbsd32_otruncate(l, v, retval) 239 struct lwp *l; 240 void *v; 241 register_t *retval; 242 { 243 struct compat_43_netbsd32_otruncate_args /* { 244 syscallarg(const netbsd32_charp) path; 245 syscallarg(netbsd32_long) length; 246 } */ *uap = v; 247 struct sys_truncate_args ua; 248 249 NETBSD32TOP_UAP(path, const char); 250 NETBSD32TO64_UAP(length); 251 return (sys_ftruncate(l, &ua, retval)); 252 } 253 254 int 255 compat_43_netbsd32_oftruncate(l, v, retval) 256 struct lwp *l; 257 void *v; 258 register_t *retval; 259 { 260 struct compat_43_netbsd32_oftruncate_args /* { 261 syscallarg(int) fd; 262 syscallarg(netbsd32_long) length; 263 } */ *uap = v; 264 struct sys_ftruncate_args ua; 265 266 NETBSD32TO64_UAP(fd); 267 NETBSD32TO64_UAP(length); 268 return (sys_ftruncate(l, &ua, retval)); 269 } 270 271 int 272 compat_43_netbsd32_ogetdirentries(l, v, retval) 273 struct lwp *l; 274 void *v; 275 register_t *retval; 276 { 277 struct compat_43_netbsd32_ogetdirentries_args /* { 278 syscallarg(int) fd; 279 syscallarg(netbsd32_charp) buf; 280 syscallarg(u_int) count; 281 syscallarg(netbsd32_longp) basep; 282 } */ *uap = v; 283 struct compat_43_sys_getdirentries_args ua; 284 285 NETBSD32TO64_UAP(fd); 286 NETBSD32TOP_UAP(buf, char); 287 NETBSD32TO64_UAP(count); 288 NETBSD32TOP_UAP(basep, long); 289 return (compat_43_sys_getdirentries(l, &ua, retval)); 290 } 291 292 /* kernel syscalls */ 293 int 294 compat_43_netbsd32_ogetkerninfo(l, v, retval) 295 struct lwp *l; 296 void *v; 297 register_t *retval; 298 { 299 struct compat_43_netbsd32_ogetkerninfo_args /* { 300 syscallarg(int) op; 301 syscallarg(netbsd32_charp) where; 302 syscallarg(netbsd32_intp) size; 303 syscallarg(int) arg; 304 } */ *uap = v; 305 struct compat_43_sys_getkerninfo_args ua; 306 307 NETBSD32TO64_UAP(op); 308 NETBSD32TOP_UAP(where, char); 309 NETBSD32TOP_UAP(size, int); 310 NETBSD32TO64_UAP(arg); 311 return (compat_43_sys_getkerninfo(l, &ua, retval)); 312 } 313 314 int 315 compat_43_netbsd32_ogethostname(l, v, retval) 316 struct lwp* l; 317 void *v; 318 register_t *retval; 319 { 320 struct compat_43_netbsd32_ogethostname_args /* { 321 syscallarg(netbsd32_charp) hostname; 322 syscallarg(u_int) len; 323 } */ *uap = v; 324 int name; 325 size_t sz; 326 327 name = KERN_HOSTNAME; 328 sz = SCARG(uap, len); 329 return (kern_sysctl(&name, 1, 330 (char *)NETBSD32PTR64(SCARG(uap, hostname)), &sz, 0, 0, l)); 331 } 332 333 int 334 compat_43_netbsd32_osethostname(l, v, retval) 335 struct lwp* l; 336 void *v; 337 register_t *retval; 338 { 339 struct compat_43_netbsd32_osethostname_args /* { 340 syscallarg(netbsd32_charp) hostname; 341 syscallarg(u_int) len; 342 } */ *uap = v; 343 int name; 344 int error; 345 346 if ((error = suser(l->l_proc->p_ucred, &l->l_proc->p_acflag)) != 0) 347 return (error); 348 name = KERN_HOSTNAME; 349 return (kern_sysctl(&name, 1, 0, 0, (char *)NETBSD32PTR64(SCARG(uap, 350 hostname)), SCARG(uap, len), l)); 351 } 352 353 int 354 compat_43_netbsd32_sethostid(l, v, retval) 355 struct lwp* l; 356 void *v; 357 register_t *retval; 358 { 359 struct compat_43_netbsd32_sethostid_args /* { 360 syscallarg(int32_t) hostid; 361 } */ *uap = v; 362 struct compat_43_sys_sethostid_args ua; 363 364 NETBSD32TO64_UAP(hostid); 365 return (compat_43_sys_sethostid(l, &ua, retval)); 366 } 367 368 int 369 compat_43_netbsd32_ogetrlimit(l, v, retval) 370 struct lwp* l; 371 void *v; 372 register_t *retval; 373 { 374 struct compat_43_netbsd32_ogetrlimit_args /* { 375 syscallarg(int) which; 376 syscallarg(netbsd32_orlimitp_t) rlp; 377 } */ *uap = v; 378 struct compat_43_sys_getrlimit_args ua; 379 380 NETBSD32TO64_UAP(which); 381 NETBSD32TOP_UAP(rlp, struct orlimit); 382 return (compat_43_sys_getrlimit(l, &ua, retval)); 383 } 384 385 int 386 compat_43_netbsd32_osetrlimit(l, v, retval) 387 struct lwp* l; 388 void *v; 389 register_t *retval; 390 { 391 struct compat_43_netbsd32_osetrlimit_args /* { 392 syscallarg(int) which; 393 syscallarg(netbsd32_orlimitp_t) rlp; 394 } */ *uap = v; 395 struct compat_43_sys_setrlimit_args ua; 396 397 NETBSD32TO64_UAP(which); 398 NETBSD32TOP_UAP(rlp, struct orlimit); 399 return (compat_43_sys_setrlimit(l, &ua, retval)); 400 } 401 402 int 403 compat_43_netbsd32_killpg(l, v, retval) 404 struct lwp* l; 405 void *v; 406 register_t *retval; 407 { 408 struct compat_43_netbsd32_killpg_args /* { 409 syscallarg(int) pgid; 410 syscallarg(int) signum; 411 } */ *uap = v; 412 struct compat_43_sys_killpg_args ua; 413 414 NETBSD32TO64_UAP(pgid); 415 NETBSD32TO64_UAP(signum); 416 return (compat_43_sys_killpg(l, &ua, retval)); 417 } 418 419 /* virtual memory syscalls */ 420 int 421 compat_43_netbsd32_ommap(l, v, retval) 422 struct lwp* l; 423 void *v; 424 register_t *retval; 425 { 426 struct compat_43_netbsd32_ommap_args /* { 427 syscallarg(netbsd32_caddr_t) addr; 428 syscallarg(netbsd32_size_t) len; 429 syscallarg(int) prot; 430 syscallarg(int) flags; 431 syscallarg(int) fd; 432 syscallarg(netbsd32_long) pos; 433 } */ *uap = v; 434 struct compat_43_sys_mmap_args ua; 435 436 NETBSD32TOX64_UAP(addr, caddr_t); 437 NETBSD32TOX_UAP(len, size_t); 438 NETBSD32TO64_UAP(prot); 439 NETBSD32TO64_UAP(flags); 440 NETBSD32TO64_UAP(fd); 441 NETBSD32TOX_UAP(pos, long); 442 return (compat_43_sys_mmap(l, &ua, retval)); 443 } 444 445 /* network syscalls */ 446 int 447 compat_43_netbsd32_oaccept(l, v, retval) 448 struct lwp* l; 449 void *v; 450 register_t *retval; 451 { 452 struct compat_43_netbsd32_oaccept_args /* { 453 syscallarg(int) s; 454 syscallarg(netbsd32_caddr_t) name; 455 syscallarg(netbsd32_intp) anamelen; 456 } */ *uap = v; 457 struct compat_43_sys_accept_args ua; 458 459 NETBSD32TOX_UAP(s, int); 460 NETBSD32TOX64_UAP(name, caddr_t); 461 NETBSD32TOP_UAP(anamelen, int); 462 return (compat_43_sys_accept(l, &ua, retval)); 463 } 464 465 int 466 compat_43_netbsd32_osend(l, v, retval) 467 struct lwp* l; 468 void *v; 469 register_t *retval; 470 { 471 struct compat_43_netbsd32_osend_args /* { 472 syscallarg(int) s; 473 syscallarg(netbsd32_caddr_t) buf; 474 syscallarg(int) len; 475 syscallarg(int) flags; 476 } */ *uap = v; 477 struct compat_43_sys_send_args ua; 478 479 NETBSD32TO64_UAP(s); 480 NETBSD32TOX64_UAP(buf, caddr_t); 481 NETBSD32TO64_UAP(len); 482 NETBSD32TO64_UAP(flags); 483 return (compat_43_sys_send(l, &ua, retval)); 484 } 485 486 int 487 compat_43_netbsd32_orecv(l, v, retval) 488 struct lwp* l; 489 void *v; 490 register_t *retval; 491 { 492 struct compat_43_netbsd32_orecv_args /* { 493 syscallarg(int) s; 494 syscallarg(netbsd32_caddr_t) buf; 495 syscallarg(int) len; 496 syscallarg(int) flags; 497 } */ *uap = v; 498 struct compat_43_sys_recv_args ua; 499 500 NETBSD32TO64_UAP(s); 501 NETBSD32TOX64_UAP(buf, caddr_t); 502 NETBSD32TO64_UAP(len); 503 NETBSD32TO64_UAP(flags); 504 return (compat_43_sys_recv(l, &ua, retval)); 505 } 506 507 /* 508 * XXX convert these to use a common iovec code to the native 509 * netbsd call. 510 */ 511 int 512 compat_43_netbsd32_orecvmsg(l, v, retval) 513 struct lwp* l; 514 void *v; 515 register_t *retval; 516 { 517 struct proc *p = l->l_proc; 518 struct compat_43_netbsd32_orecvmsg_args /* { 519 syscallarg(int) s; 520 syscallarg(netbsd32_omsghdrp_t) msg; 521 syscallarg(int) flags; 522 } */ *uap = v; 523 struct compat_43_sys_recvmsg_args ua; 524 struct omsghdr omh, *sgsbp; 525 struct netbsd32_omsghdr omh32; 526 struct iovec iov, *sgsbp2; 527 struct netbsd32_iovec iov32, *iovec32p; 528 caddr_t sg = stackgap_init(p, 0); 529 int i, error, rv; 530 531 NETBSD32TO64_UAP(s); 532 NETBSD32TO64_UAP(flags); 533 534 /* 535 * this is annoying: 536 * - copyin the msghdr32 struct 537 * - stackgap_alloc a msghdr struct 538 * - convert msghdr32 to msghdr: 539 * - stackgap_alloc enough space for iovec's 540 * - copy in each iov32, and convert to iov 541 * - copyout converted iov 542 * - copyout converted msghdr 543 * - do real syscall 544 * - copyin the msghdr struct 545 * - convert msghdr to msghdr32 546 * - copyin each iov and convert to iov32 547 * - copyout converted iov32 548 * - copyout converted msghdr32 549 */ 550 error = copyin((caddr_t)NETBSD32PTR64(SCARG(uap, msg)), &omh32, 551 sizeof(omh32)); 552 if (error) 553 return (error); 554 555 SCARG(&ua, msg) = sgsbp = stackgap_alloc(p, &sg, sizeof(omh)); 556 omh.msg_name = (caddr_t)NETBSD32PTR64(omh32.msg_name); 557 omh.msg_namelen = omh32.msg_namelen; 558 omh.msg_iovlen = (size_t)omh32.msg_iovlen; 559 omh.msg_iov = sgsbp2 = stackgap_alloc(p, &sg, sizeof(struct iovec) * omh.msg_iovlen); 560 iovec32p = (struct netbsd32_iovec *)NETBSD32PTR64(omh32.msg_iov); 561 for (i = 0; i < omh.msg_iovlen; i++, sgsbp2++, iovec32p++) { 562 error = copyin(iovec32p, &iov32, sizeof(iov32)); 563 if (error) 564 return (error); 565 iov.iov_base = 566 (struct iovec *)NETBSD32PTR64(iovec32p->iov_base); 567 iov.iov_len = (size_t)iovec32p->iov_len; 568 error = copyout(&iov, sgsbp2, sizeof(iov)); 569 if (error) 570 return (error); 571 } 572 omh.msg_accrights = (caddr_t)NETBSD32PTR64(omh32.msg_accrights); 573 omh.msg_accrightslen = omh32.msg_accrightslen; 574 error = copyout(&omh, sgsbp, sizeof(omh)); 575 if (error) 576 return (error); 577 578 rv = compat_43_sys_recvmsg(l, &ua, retval); 579 580 error = copyin(sgsbp, &omh, sizeof(omh)); 581 if (error) 582 return error; 583 omh32.msg_name = (netbsd32_caddr_t)(u_long)omh.msg_name; 584 omh32.msg_namelen = omh.msg_namelen; 585 omh32.msg_iovlen = (netbsd32_size_t)omh.msg_iovlen; 586 iovec32p = (struct netbsd32_iovec *)NETBSD32PTR64(omh32.msg_iov); 587 sgsbp2 = omh.msg_iov; 588 for (i = 0; i < omh.msg_iovlen; i++, sgsbp2++, iovec32p++) { 589 error = copyin(sgsbp2, &iov, sizeof(iov)); 590 if (error) 591 return (error); 592 iov32.iov_base = (netbsd32_iovecp_t)(u_long)iov.iov_base; 593 iov32.iov_len = (netbsd32_size_t)iov.iov_len; 594 error = copyout(&iov32, iovec32p, sizeof(iov32)); 595 if (error) 596 return (error); 597 } 598 omh32.msg_accrights = (netbsd32_caddr_t)(u_long)omh.msg_accrights; 599 omh32.msg_accrightslen = omh.msg_accrightslen; 600 601 error = copyout(&omh32, (char *)NETBSD32PTR64(SCARG(uap, msg)), 602 sizeof(omh32)); 603 if (error) 604 return error; 605 606 return (rv); 607 } 608 609 int 610 compat_43_netbsd32_osendmsg(l, v, retval) 611 struct lwp* l; 612 void *v; 613 register_t *retval; 614 { 615 struct proc *p = l->l_proc; 616 struct compat_43_netbsd32_osendmsg_args /* { 617 syscallarg(int) s; 618 syscallarg(netbsd32_caddr_t) msg; 619 syscallarg(int) flags; 620 } */ *uap = v; 621 struct compat_43_sys_recvmsg_args ua; 622 struct omsghdr omh, *sgsbp; 623 struct netbsd32_omsghdr omh32; 624 struct iovec iov, *sgsbp2; 625 struct netbsd32_iovec iov32, *iovec32p; 626 caddr_t sg = stackgap_init(p, 0); 627 int i, error, rv; 628 629 NETBSD32TO64_UAP(s); 630 NETBSD32TO64_UAP(flags); 631 632 /* 633 * this is annoying: 634 * - copyin the msghdr32 struct 635 * - stackgap_alloc a msghdr struct 636 * - convert msghdr32 to msghdr: 637 * - stackgap_alloc enough space for iovec's 638 * - copy in each iov32, and convert to iov 639 * - copyout converted iov 640 * - copyout converted msghdr 641 * - do real syscall 642 * - copyin the msghdr struct 643 * - convert msghdr to msghdr32 644 * - copyin each iov and convert to iov32 645 * - copyout converted iov32 646 * - copyout converted msghdr32 647 */ 648 error = copyin((caddr_t)NETBSD32PTR64(SCARG(uap, msg)), &omh32, 649 sizeof(omh32)); 650 if (error) 651 return (error); 652 653 SCARG(&ua, msg) = sgsbp = stackgap_alloc(p, &sg, sizeof(omh)); 654 omh.msg_name = (caddr_t)NETBSD32PTR64(omh32.msg_name); 655 omh.msg_namelen = omh32.msg_namelen; 656 omh.msg_iovlen = (size_t)omh32.msg_iovlen; 657 omh.msg_iov = sgsbp2 = stackgap_alloc(p, &sg, sizeof(struct iovec) * omh.msg_iovlen); 658 iovec32p = (struct netbsd32_iovec *)NETBSD32PTR64(omh32.msg_iov); 659 for (i = 0; i < omh.msg_iovlen; i++, sgsbp2++, iovec32p++) { 660 error = copyin(iovec32p, &iov32, sizeof(iov32)); 661 if (error) 662 return (error); 663 iov.iov_base = 664 (struct iovec *)NETBSD32PTR64(iovec32p->iov_base); 665 iov.iov_len = (size_t)iovec32p->iov_len; 666 error = copyout(&iov, sgsbp2, sizeof(iov)); 667 if (error) 668 return (error); 669 } 670 omh.msg_accrights = (caddr_t)NETBSD32PTR64(omh32.msg_accrights); 671 omh.msg_accrightslen = omh32.msg_accrightslen; 672 error = copyout(&omh, sgsbp, sizeof(omh)); 673 if (error) 674 return (error); 675 676 rv = compat_43_sys_sendmsg(l, &ua, retval); 677 678 error = copyin(sgsbp, &omh, sizeof(omh)); 679 if (error) 680 return error; 681 omh32.msg_name = (netbsd32_caddr_t)(u_long)omh.msg_name; 682 omh32.msg_namelen = omh.msg_namelen; 683 omh32.msg_iovlen = (netbsd32_size_t)omh.msg_iovlen; 684 iovec32p = (struct netbsd32_iovec *)NETBSD32PTR64(omh32.msg_iov); 685 sgsbp2 = omh.msg_iov; 686 for (i = 0; i < omh.msg_iovlen; i++, sgsbp2++, iovec32p++) { 687 error = copyin(sgsbp2, &iov, sizeof(iov)); 688 if (error) 689 return (error); 690 iov32.iov_base = (netbsd32_iovecp_t)(u_long)iov.iov_base; 691 iov32.iov_len = (netbsd32_size_t)iov.iov_len; 692 error = copyout(&iov32, iovec32p, sizeof(iov32)); 693 if (error) 694 return (error); 695 } 696 omh32.msg_accrights = (netbsd32_caddr_t)(u_long)omh.msg_accrights; 697 omh32.msg_accrightslen = omh.msg_accrightslen; 698 699 error = copyout(&omh32, (char *)NETBSD32PTR64(SCARG(uap, msg)), 700 sizeof(omh32)); 701 if (error) 702 return error; 703 704 return (rv); 705 } 706 707 int 708 compat_43_netbsd32_orecvfrom(l, v, retval) 709 struct lwp* l; 710 void *v; 711 register_t *retval; 712 { 713 struct compat_43_netbsd32_orecvfrom_args /* { 714 syscallarg(int) s; 715 syscallarg(netbsd32_caddr_t) buf; 716 syscallarg(netbsd32_size_t) len; 717 syscallarg(int) flags; 718 syscallarg(netbsd32_caddr_t) from; 719 syscallarg(netbsd32_intp) fromlenaddr; 720 } */ *uap = v; 721 struct compat_43_sys_recvfrom_args ua; 722 723 NETBSD32TO64_UAP(s); 724 NETBSD32TOX64_UAP(buf, caddr_t); 725 NETBSD32TOX_UAP(len, size_t); 726 NETBSD32TO64_UAP(flags); 727 NETBSD32TOX64_UAP(from, caddr_t); 728 NETBSD32TOP_UAP(fromlenaddr, int); 729 return (compat_43_sys_recvfrom(l, &ua, retval)); 730 } 731 732 int 733 compat_43_netbsd32_ogetsockname(l, v, retval) 734 struct lwp* l; 735 void *v; 736 register_t *retval; 737 { 738 struct compat_43_netbsd32_ogetsockname_args /* { 739 syscallarg(int) fdec; 740 syscallarg(netbsd32_caddr_t) asa; 741 syscallarg(netbsd32_intp) alen; 742 } */ *uap = v; 743 struct compat_43_sys_getsockname_args ua; 744 745 NETBSD32TO64_UAP(fdec); 746 NETBSD32TOX64_UAP(asa, caddr_t); 747 NETBSD32TOP_UAP(alen, int); 748 return (compat_43_sys_getsockname(l, &ua, retval)); 749 } 750 751 int 752 compat_43_netbsd32_ogetpeername(l, v, retval) 753 struct lwp* l; 754 void *v; 755 register_t *retval; 756 { 757 struct compat_43_netbsd32_ogetpeername_args /* { 758 syscallarg(int) fdes; 759 syscallarg(netbsd32_caddr_t) asa; 760 syscallarg(netbsd32_intp) alen; 761 } */ *uap = v; 762 struct compat_43_sys_getpeername_args ua; 763 764 NETBSD32TO64_UAP(fdes); 765 NETBSD32TOX64_UAP(asa, caddr_t); 766 NETBSD32TOP_UAP(alen, int); 767 return (compat_43_sys_getpeername(l, &ua, retval)); 768 } 769 770 /* signal syscalls */ 771 int 772 compat_43_netbsd32_osigvec(l, v, retval) 773 struct lwp* l; 774 void *v; 775 register_t *retval; 776 { 777 struct proc *p = l->l_proc; 778 struct compat_43_netbsd32_osigvec_args /* { 779 syscallarg(int) signum; 780 syscallarg(netbsd32_sigvecp_t) nsv; 781 syscallarg(netbsd32_sigvecp_t) osv; 782 } */ *uap = v; 783 struct compat_43_sys_sigvec_args ua; 784 struct netbsd32_sigvec sv32; 785 struct sigvec sv, *sgnsvp, *sgosvp; 786 caddr_t sg = stackgap_init(p, 0); 787 int rv, error; 788 789 NETBSD32TO64_UAP(signum); 790 if (SCARG(uap, osv)) 791 SCARG(&ua, osv) = sgosvp = stackgap_alloc(p, &sg, sizeof(sv)); 792 else 793 SCARG(&ua, osv) = NULL; 794 if (SCARG(uap, nsv)) { 795 SCARG(&ua, nsv) = sgnsvp = stackgap_alloc(p, &sg, sizeof(sv)); 796 error = copyin((caddr_t)NETBSD32PTR64(SCARG(uap, nsv)), &sv32, 797 sizeof(sv32)); 798 if (error) 799 return (error); 800 sv.sv_handler = (void *)NETBSD32PTR64(sv32.sv_handler); 801 sv.sv_mask = sv32.sv_mask; 802 sv.sv_flags = sv32.sv_flags; 803 error = copyout(&sv, sgnsvp, sizeof(sv)); 804 if (error) 805 return (error); 806 } else 807 SCARG(&ua, nsv) = NULL; 808 rv = compat_43_sys_sigvec(l, &ua, retval); 809 if (rv) 810 return (rv); 811 812 if (SCARG(uap, osv)) { 813 error = copyin(sgosvp, &sv, sizeof(sv)); 814 if (error) 815 return (error); 816 sv32.sv_handler = (netbsd32_sigvecp_t)(u_long)sv.sv_handler; 817 sv32.sv_mask = sv.sv_mask; 818 sv32.sv_flags = sv.sv_flags; 819 error = copyout(&sv32, (caddr_t)NETBSD32PTR64(SCARG(uap, osv)), 820 sizeof(sv32)); 821 if (error) 822 return (error); 823 } 824 825 return (0); 826 } 827 828 int 829 compat_43_netbsd32_sigblock(l, v, retval) 830 struct lwp* l; 831 void *v; 832 register_t *retval; 833 { 834 struct compat_43_netbsd32_sigblock_args /* { 835 syscallarg(int) mask; 836 } */ *uap = v; 837 struct compat_43_sys_sigblock_args ua; 838 839 NETBSD32TO64_UAP(mask); 840 return (compat_43_sys_sigblock(l, &ua, retval)); 841 } 842 843 int 844 compat_43_netbsd32_sigsetmask(l, v, retval) 845 struct lwp* l; 846 void *v; 847 register_t *retval; 848 { 849 struct compat_43_netbsd32_sigsetmask_args /* { 850 syscallarg(int) mask; 851 } */ *uap = v; 852 struct compat_43_sys_sigsetmask_args ua; 853 854 NETBSD32TO64_UAP(mask); 855 return (compat_43_sys_sigsetmask(l, &ua, retval)); 856 } 857 858 int 859 compat_43_netbsd32_osigstack(l, v, retval) 860 struct lwp* l; 861 void *v; 862 register_t *retval; 863 { 864 struct proc *p = l->l_proc; 865 struct compat_43_netbsd32_osigstack_args /* { 866 syscallarg(netbsd32_sigstackp_t) nss; 867 syscallarg(netbsd32_sigstackp_t) oss; 868 } */ *uap = v; 869 struct compat_43_sys_sigstack_args ua; 870 struct netbsd32_sigstack ss32; 871 struct sigstack ss, *sgossp, *sgnssp; 872 caddr_t sg = stackgap_init(p, 0); 873 int error, rv; 874 875 if (SCARG(uap, oss)) 876 SCARG(&ua, oss) = sgossp = stackgap_alloc(p, &sg, sizeof(ss)); 877 else 878 SCARG(&ua, oss) = NULL; 879 if (SCARG(uap, nss)) { 880 SCARG(&ua, nss) = sgnssp = stackgap_alloc(p, &sg, sizeof(ss)); 881 error = copyin((caddr_t)NETBSD32PTR64(SCARG(uap, nss)), &ss32, 882 sizeof(ss32)); 883 if (error) 884 return (error); 885 ss.ss_sp = (void *)NETBSD32PTR64(ss32.ss_sp); 886 ss.ss_onstack = ss32.ss_onstack; 887 error = copyout(&ss, sgnssp, sizeof(ss)); 888 if (error) 889 return (error); 890 } else 891 SCARG(&ua, nss) = NULL; 892 893 rv = compat_43_sys_sigstack(l, &ua, retval); 894 if (rv) 895 return (rv); 896 897 if (SCARG(uap, oss)) { 898 error = copyin(sgossp, &ss, sizeof(ss)); 899 if (error) 900 return (error); 901 ss32.ss_sp = (netbsd32_sigstackp_t)(u_long)ss.ss_sp; 902 ss32.ss_onstack = ss.ss_onstack; 903 error = copyout(&ss32, (caddr_t)NETBSD32PTR64(SCARG(uap, oss)), 904 sizeof(ss32)); 905 if (error) 906 return (error); 907 } 908 909 return (0); 910 } 911
Indexes created Thu Oct 02 14:10:14 GMT 2025