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