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