netbsd32_compat_43.c revision 1.4
1 /* $NetBSD: netbsd32_compat_43.c,v 1.4 1998/10/01 14:27:56 eeh Exp $ */ 2 3 /* 4 * Copyright (c) 1998 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 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 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 */ 30 31 #include <sys/param.h> 32 #include <sys/systm.h> 33 #include <sys/fcntl.h> 34 #include <sys/malloc.h> 35 #include <sys/mount.h> 36 #include <sys/proc.h> 37 #include <sys/stat.h> 38 #include <sys/syscallargs.h> 39 #include <sys/time.h> 40 #include <sys/ucred.h> 41 #include <vm/vm.h> /* XXX for <sys/sysctl.h> */ 42 #include <sys/sysctl.h> 43 #include <sys/swap.h> 44 45 #include <compat/sparc32/sparc32.h> 46 #include <compat/sparc32/sparc32_syscallargs.h> 47 48 static void 49 sparc32_from_stat43(sp43, sp32) 50 struct stat43 *sp43; 51 struct sparc32_stat43 *sp32; 52 { 53 54 sp32->st_dev = sp43->st_dev; 55 sp32->st_ino = sp43->st_ino; 56 sp32->st_mode = sp43->st_mode; 57 sp32->st_nlink = sp43->st_nlink; 58 sp32->st_uid = sp43->st_uid; 59 sp32->st_gid = sp43->st_gid; 60 sp32->st_rdev = sp43->st_rdev; 61 sp32->st_size = sp43->st_size; 62 sp32->st_atimespec.tv_sec = sp43->st_atimespec.tv_sec; 63 sp32->st_atimespec.tv_nsec = sp43->st_atimespec.tv_nsec; 64 sp32->st_mtimespec.tv_sec = sp43->st_mtimespec.tv_sec; 65 sp32->st_mtimespec.tv_nsec = sp43->st_mtimespec.tv_nsec; 66 sp32->st_ctimespec.tv_sec = sp43->st_ctimespec.tv_sec; 67 sp32->st_ctimespec.tv_nsec = sp43->st_ctimespec.tv_nsec; 68 sp32->st_blksize = sp43->st_blksize; 69 sp32->st_blocks = sp43->st_blocks; 70 sp32->st_flags = sp43->st_flags; 71 sp32->st_gen = sp43->st_gen; 72 } 73 74 /* file system syscalls */ 75 int 76 compat_43_compat_sparc32_ocreat(p, v, retval) 77 struct proc *p; 78 void *v; 79 register_t *retval; 80 { 81 struct compat_43_compat_sparc32_ocreat_args /* { 82 syscallarg(const sparc32_charp) path; 83 syscallarg(mode_t) mode; 84 } */ *uap = v; 85 struct sys_open_args ua; 86 caddr_t sg; 87 88 SPARC32TOP_UAP(path, const char); 89 SPARC32TO64_UAP(mode); 90 SCARG(&ua, flags) = O_WRONLY | O_CREAT | O_TRUNC; 91 sg = stackgap_init(p->p_emul); 92 SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path)); 93 94 return (sys_open(p, &ua, retval)); 95 } 96 97 int 98 compat_43_compat_sparc32_olseek(p, v, retval) 99 struct proc *p; 100 void *v; 101 register_t *retval; 102 { 103 struct compat_43_compat_sparc32_olseek_args /* { 104 syscallarg(int) fd; 105 syscallarg(sparc32_long) offset; 106 syscallarg(int) whence; 107 } */ *uap = v; 108 struct sys_lseek_args ua; 109 int rv; 110 off_t rt; 111 112 SCARG(&ua, fd) = SCARG(uap, fd); 113 SPARC32TOX_UAP(offset, long); 114 SPARC32TO64_UAP(whence); 115 rv = sys_lseek(p, &ua, (register_t *)&rt); 116 *(sparc32_long *)retval = rt; 117 118 return (rv); 119 } 120 121 int 122 compat_43_compat_sparc32_stat43(p, v, retval) 123 struct proc *p; 124 void *v; 125 register_t *retval; 126 { 127 struct compat_43_compat_sparc32_stat43_args /* { 128 syscallarg(const sparc32_charp) path; 129 syscallarg(sparc32_stat43p_t) ub; 130 } */ *uap = v; 131 struct sparc32_stat43 *sp32; 132 struct stat43 sb43; 133 struct stat43 *sp43 = &sb43; 134 struct compat_43_sys_stat_args ua; 135 caddr_t sg; 136 int rv; 137 138 SPARC32TOP_UAP(path, const char); 139 SCARG(&ua, ub) = &sb43; 140 sg = stackgap_init(p->p_emul); 141 SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path)); 142 143 rv = compat_43_sys_stat(p, &ua, retval); 144 145 sp32 = (struct sparc32_stat43 *)(u_long)SCARG(uap, ub); 146 sparc32_from_stat43(sp43, sp32); 147 148 return (rv); 149 } 150 151 int 152 compat_43_compat_sparc32_lstat43(p, v, retval) 153 struct proc *p; 154 void *v; 155 register_t *retval; 156 { 157 struct compat_43_compat_sparc32_lstat43_args /* { 158 syscallarg(const sparc32_charp) path; 159 syscallarg(sparc32_stat43p_t) ub; 160 } */ *uap = v; 161 struct sparc32_stat43 *sp32; 162 struct stat43 sb43; 163 struct stat43 *sp43 = &sb43; 164 struct compat_43_sys_lstat_args ua; 165 caddr_t sg; 166 int rv; 167 168 SPARC32TOP_UAP(path, const char); 169 SCARG(&ua, ub) = &sb43; 170 sg = stackgap_init(p->p_emul); 171 SPARC32_CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path)); 172 173 rv = compat_43_sys_stat(p, &ua, retval); 174 175 sp32 = (struct sparc32_stat43 *)(u_long)SCARG(uap, ub); 176 sparc32_from_stat43(sp43, sp32); 177 178 return (rv); 179 } 180 181 int 182 compat_43_compat_sparc32_fstat43(p, v, retval) 183 struct proc *p; 184 void *v; 185 register_t *retval; 186 { 187 struct compat_43_compat_sparc32_fstat43_args /* { 188 syscallarg(int) fd; 189 syscallarg(sparc32_stat43p_t) sb; 190 } */ *uap = v; 191 struct sparc32_stat43 *sp32; 192 struct stat43 sb43; 193 struct stat43 *sp43 = &sb43; 194 struct compat_43_sys_fstat_args ua; 195 int rv; 196 197 SPARC32TO64_UAP(fd); 198 SCARG(&ua, sb) = &sb43; 199 rv = compat_43_sys_fstat(p, &ua, retval); 200 201 sp32 = (struct sparc32_stat43 *)(u_long)SCARG(uap, sb); 202 sparc32_from_stat43(sp43, sp32); 203 204 return (rv); 205 } 206 207 int 208 compat_43_compat_sparc32_otruncate(p, v, retval) 209 struct proc *p; 210 void *v; 211 register_t *retval; 212 { 213 struct compat_43_compat_sparc32_otruncate_args /* { 214 syscallarg(const sparc32_charp) path; 215 syscallarg(sparc32_long) length; 216 } */ *uap = v; 217 struct sys_truncate_args ua; 218 219 SPARC32TOP_UAP(path, const char); 220 SPARC32TO64_UAP(length); 221 return (sys_ftruncate(p, &ua, retval)); 222 } 223 224 int 225 compat_43_compat_sparc32_oftruncate(p, v, retval) 226 struct proc *p; 227 void *v; 228 register_t *retval; 229 { 230 struct compat_43_compat_sparc32_oftruncate_args /* { 231 syscallarg(int) fd; 232 syscallarg(sparc32_long) length; 233 } */ *uap = v; 234 struct sys_ftruncate_args ua; 235 236 SPARC32TO64_UAP(fd); 237 SPARC32TO64_UAP(length); 238 return (sys_ftruncate(p, &ua, retval)); 239 } 240 241 int 242 compat_43_compat_sparc32_ogetdirentries(p, v, retval) 243 struct proc *p; 244 void *v; 245 register_t *retval; 246 { 247 struct compat_43_compat_sparc32_ogetdirentries_args /* { 248 syscallarg(int) fd; 249 syscallarg(sparc32_charp) buf; 250 syscallarg(u_int) count; 251 syscallarg(sparc32_longp) basep; 252 } */ *uap = v; 253 struct compat_43_sys_getdirentries_args ua; 254 255 SPARC32TO64_UAP(fd); 256 SPARC32TOP_UAP(buf, char); 257 SPARC32TO64_UAP(count); 258 SPARC32TOP_UAP(basep, long); 259 return (compat_43_sys_getdirentries(p, &ua, retval)); 260 } 261 262 /* kernel syscalls */ 263 int 264 compat_43_compat_sparc32_ogetkerninfo(p, v, retval) 265 struct proc *p; 266 void *v; 267 register_t *retval; 268 { 269 struct compat_43_compat_sparc32_ogetkerninfo_args /* { 270 syscallarg(int) op; 271 syscallarg(sparc32_charp) where; 272 syscallarg(sparc32_intp) size; 273 syscallarg(int) arg; 274 } */ *uap = v; 275 struct compat_43_sys_getkerninfo_args ua; 276 277 SPARC32TO64_UAP(op); 278 SPARC32TOP_UAP(where, char); 279 SPARC32TOP_UAP(size, int); 280 SPARC32TO64_UAP(arg); 281 return (compat_43_sys_getkerninfo(p, &ua, retval)); 282 } 283 284 int 285 compat_43_compat_sparc32_ogethostname(p, v, retval) 286 struct proc *p; 287 void *v; 288 register_t *retval; 289 { 290 struct compat_43_compat_sparc32_ogethostname_args /* { 291 syscallarg(sparc32_charp) hostname; 292 syscallarg(u_int) len; 293 } */ *uap = v; 294 int name; 295 size_t sz; 296 297 name = KERN_HOSTNAME; 298 sz = SCARG(uap, len); 299 return (kern_sysctl(&name, 1, (char *)(u_long)SCARG(uap, hostname), 300 &sz, 0, 0, p)); 301 } 302 303 int 304 compat_43_compat_sparc32_osethostname(p, v, retval) 305 struct proc *p; 306 void *v; 307 register_t *retval; 308 { 309 struct compat_43_compat_sparc32_osethostname_args /* { 310 syscallarg(sparc32_charp) hostname; 311 syscallarg(u_int) len; 312 } */ *uap = v; 313 int name; 314 int error; 315 316 if ((error = suser(p->p_ucred, &p->p_acflag)) != 0) 317 return (error); 318 name = KERN_HOSTNAME; 319 return (kern_sysctl(&name, 1, 0, 0, (char *)(u_long)SCARG(uap, 320 hostname), SCARG(uap, len), p)); 321 } 322 323 int 324 compat_43_compat_sparc32_sethostid(p, v, retval) 325 struct proc *p; 326 void *v; 327 register_t *retval; 328 { 329 struct compat_43_compat_sparc32_sethostid_args /* { 330 syscallarg(int32_t) hostid; 331 } */ *uap = v; 332 struct compat_43_sys_sethostid_args ua; 333 334 SPARC32TO64_UAP(hostid); 335 return (compat_43_sys_sethostid(p, &ua, retval)); 336 } 337 338 int 339 compat_43_compat_sparc32_ogetrlimit(p, v, retval) 340 struct proc *p; 341 void *v; 342 register_t *retval; 343 { 344 struct compat_43_compat_sparc32_ogetrlimit_args /* { 345 syscallarg(int) which; 346 syscallarg(sparc32_orlimitp_t) rlp; 347 } */ *uap = v; 348 struct compat_43_sys_getrlimit_args ua; 349 350 SPARC32TO64_UAP(which); 351 SPARC32TOP_UAP(rlp, struct orlimit); 352 return (compat_43_sys_getrlimit(p, &ua, retval)); 353 } 354 355 int 356 compat_43_compat_sparc32_osetrlimit(p, v, retval) 357 struct proc *p; 358 void *v; 359 register_t *retval; 360 { 361 struct compat_43_compat_sparc32_osetrlimit_args /* { 362 syscallarg(int) which; 363 syscallarg(sparc32_orlimitp_t) rlp; 364 } */ *uap = v; 365 struct compat_43_sys_setrlimit_args ua; 366 367 SPARC32TO64_UAP(which); 368 SPARC32TOP_UAP(rlp, struct orlimit); 369 return (compat_43_sys_setrlimit(p, &ua, retval)); 370 } 371 372 int 373 compat_43_compat_sparc32_killpg(p, v, retval) 374 struct proc *p; 375 void *v; 376 register_t *retval; 377 { 378 struct compat_43_compat_sparc32_killpg_args /* { 379 syscallarg(int) pgid; 380 syscallarg(int) signum; 381 } */ *uap = v; 382 struct compat_43_sys_killpg_args ua; 383 384 SPARC32TO64_UAP(pgid); 385 SPARC32TO64_UAP(signum); 386 return (compat_43_sys_killpg(p, &ua, retval)); 387 } 388 389 /* virtual memory syscalls */ 390 int 391 compat_43_compat_sparc32_ommap(p, v, retval) 392 struct proc *p; 393 void *v; 394 register_t *retval; 395 { 396 struct compat_43_compat_sparc32_ommap_args /* { 397 syscallarg(sparc32_caddr_t) addr; 398 syscallarg(sparc32_size_t) len; 399 syscallarg(int) prot; 400 syscallarg(int) flags; 401 syscallarg(int) fd; 402 syscallarg(sparc32_long) pos; 403 } */ *uap = v; 404 struct compat_43_sys_mmap_args ua; 405 406 SPARC32TOX64_UAP(addr, caddr_t); 407 SPARC32TOX_UAP(len, size_t); 408 SPARC32TO64_UAP(prot); 409 SPARC32TO64_UAP(flags); 410 SPARC32TO64_UAP(fd); 411 SPARC32TOX_UAP(pos, long); 412 return (compat_43_sys_mmap(p, &ua, retval)); 413 } 414 415 /* virtual memory syscalls */ 416 int 417 compat_sparc32_ovadvise(p, v, retval) 418 struct proc *p; 419 void *v; 420 register_t *retval; 421 { 422 struct compat_sparc32_ovadvise_args /* { 423 syscallarg(int) anom; 424 } */ *uap = v; 425 struct sys_ovadvise_args ua; 426 427 SPARC32TO64_UAP(anom); 428 return (sys_ovadvise(p, &ua, retval)); 429 } 430 431 /* network syscalls */ 432 int 433 compat_43_compat_sparc32_oaccept(p, v, retval) 434 struct proc *p; 435 void *v; 436 register_t *retval; 437 { 438 struct compat_43_compat_sparc32_oaccept_args /* { 439 syscallarg(int) s; 440 syscallarg(sparc32_caddr_t) name; 441 syscallarg(sparc32_intp) anamelen; 442 } */ *uap = v; 443 struct compat_43_sys_accept_args ua; 444 445 SPARC32TOX_UAP(s, int); 446 SPARC32TOX64_UAP(name, caddr_t); 447 SPARC32TOP_UAP(anamelen, int); 448 return (compat_43_sys_accept(p, &ua, retval)); 449 } 450 451 int 452 compat_43_compat_sparc32_osend(p, v, retval) 453 struct proc *p; 454 void *v; 455 register_t *retval; 456 { 457 struct compat_43_compat_sparc32_osend_args /* { 458 syscallarg(int) s; 459 syscallarg(sparc32_caddr_t) buf; 460 syscallarg(int) len; 461 syscallarg(int) flags; 462 } */ *uap = v; 463 struct compat_43_sys_send_args ua; 464 465 SPARC32TO64_UAP(s); 466 SPARC32TOX64_UAP(buf, caddr_t); 467 SPARC32TO64_UAP(len); 468 SPARC32TO64_UAP(flags); 469 return (compat_43_sys_send(p, &ua, retval)); 470 } 471 472 int 473 compat_43_compat_sparc32_orecv(p, v, retval) 474 struct proc *p; 475 void *v; 476 register_t *retval; 477 { 478 struct compat_43_compat_sparc32_orecv_args /* { 479 syscallarg(int) s; 480 syscallarg(sparc32_caddr_t) buf; 481 syscallarg(int) len; 482 syscallarg(int) flags; 483 } */ *uap = v; 484 struct compat_43_sys_recv_args ua; 485 486 SPARC32TO64_UAP(s); 487 SPARC32TOX64_UAP(buf, caddr_t); 488 SPARC32TO64_UAP(len); 489 SPARC32TO64_UAP(flags); 490 return (compat_43_sys_recv(p, &ua, retval)); 491 } 492 493 /* 494 * XXX convert these to use a common iovec code to the native 495 * netbsd call. 496 */ 497 int 498 compat_43_compat_sparc32_orecvmsg(p, v, retval) 499 struct proc *p; 500 void *v; 501 register_t *retval; 502 { 503 struct compat_43_compat_sparc32_orecvmsg_args /* { 504 syscallarg(int) s; 505 syscallarg(sparc32_omsghdrp_t) msg; 506 syscallarg(int) flags; 507 } */ *uap = v; 508 struct compat_43_sys_recvmsg_args ua; 509 struct omsghdr omh; 510 struct omsghdr *omhp = &omh; 511 struct sparc32_omsghdr *omhp32; 512 struct iovec *iovec43p; 513 struct sparc32_iovec *iovec32p; 514 int i; 515 516 SPARC32TO64_UAP(s); 517 SPARC32TO64_UAP(flags); 518 519 SCARG(&ua, msg) = omhp; 520 omhp32 = (struct sparc32_omsghdr *)(u_long)SCARG(uap, msg); 521 omhp->msg_name = (caddr_t)(u_long)omhp32->msg_name; 522 omhp->msg_namelen = omhp32->msg_namelen; 523 omhp->msg_iovlen = (size_t)omhp32->msg_iovlen; 524 MALLOC(omhp->msg_iov, struct iovec *, sizeof(struct iovec) * omhp->msg_iovlen, M_TEMP, M_WAITOK); 525 iovec43p = omhp->msg_iov; 526 iovec32p = (struct sparc32_iovec *)(u_long)omhp32->msg_iov; 527 for (i = 0; i < omhp->msg_iovlen; i++, iovec43p++, iovec32p++) { 528 iovec43p->iov_base = (struct iovec *)(u_long)iovec32p->iov_base; 529 iovec43p->iov_len = (size_t)iovec32p->iov_len; 530 } 531 532 omhp->msg_accrights = (caddr_t)(u_long)omhp32->msg_accrights; 533 omhp->msg_accrightslen = omhp32->msg_accrightslen; 534 535 return (compat_43_sys_recvmsg(p, &ua, retval)); 536 } 537 538 int 539 compat_43_compat_sparc32_osendmsg(p, v, retval) 540 struct proc *p; 541 void *v; 542 register_t *retval; 543 { 544 struct compat_43_compat_sparc32_osendmsg_args /* { 545 syscallarg(int) s; 546 syscallarg(sparc32_caddr_t) msg; 547 syscallarg(int) flags; 548 } */ *uap = v; 549 struct compat_43_sys_sendmsg_args ua; 550 struct omsghdr omh; 551 struct omsghdr *omhp = &omh; 552 struct sparc32_omsghdr *omhp32; 553 struct iovec *iovec43p; 554 struct sparc32_iovec *iovec32p; 555 int i; 556 557 SPARC32TO64_UAP(s); 558 SPARC32TO64_UAP(flags); 559 560 SCARG(&ua, msg) = (caddr_t)(u_long)omhp; 561 omhp32 = (struct sparc32_omsghdr *)(u_long)SCARG(uap, msg); 562 omhp->msg_name = (caddr_t)(u_long)omhp32->msg_name; 563 omhp->msg_namelen = omhp32->msg_namelen; 564 omhp->msg_iovlen = (size_t)omhp32->msg_iovlen; 565 MALLOC(omhp->msg_iov, struct iovec *, sizeof(struct iovec) * omhp->msg_iovlen, M_TEMP, M_WAITOK); 566 iovec43p = omhp->msg_iov; 567 iovec32p = (struct sparc32_iovec *)(u_long)omhp32->msg_iov; 568 for (i = 0; i < omhp->msg_iovlen; i++, iovec43p++, iovec32p++) { 569 iovec43p->iov_base = (void *)(u_long)iovec32p->iov_base; 570 iovec43p->iov_len = (size_t)iovec32p->iov_len; 571 } 572 573 omhp->msg_accrights = (caddr_t)(u_long)omhp32->msg_accrights; 574 omhp->msg_accrightslen = omhp32->msg_accrightslen; 575 576 return (compat_43_sys_sendmsg(p, &ua, retval)); 577 } 578 579 int 580 compat_43_compat_sparc32_orecvfrom(p, v, retval) 581 struct proc *p; 582 void *v; 583 register_t *retval; 584 { 585 struct compat_43_compat_sparc32_orecvfrom_args /* { 586 syscallarg(int) s; 587 syscallarg(sparc32_caddr_t) buf; 588 syscallarg(sparc32_size_t) len; 589 syscallarg(int) flags; 590 syscallarg(sparc32_caddr_t) from; 591 syscallarg(sparc32_intp) fromlenaddr; 592 } */ *uap = v; 593 struct compat_43_sys_recvfrom_args ua; 594 595 SPARC32TO64_UAP(s); 596 SPARC32TOX64_UAP(buf, caddr_t); 597 SPARC32TOX_UAP(len, size_t); 598 SPARC32TO64_UAP(flags); 599 SPARC32TOX64_UAP(from, caddr_t); 600 SPARC32TOP_UAP(fromlenaddr, int); 601 return (compat_43_sys_recvfrom(p, &ua, retval)); 602 } 603 604 int 605 compat_43_compat_sparc32_ogetsockname(p, v, retval) 606 struct proc *p; 607 void *v; 608 register_t *retval; 609 { 610 struct compat_43_compat_sparc32_ogetsockname_args /* { 611 syscallarg(int) fdec; 612 syscallarg(sparc32_caddr_t) asa; 613 syscallarg(sparc32_intp) alen; 614 } */ *uap = v; 615 struct compat_43_sys_getsockname_args ua; 616 617 SPARC32TO64_UAP(fdec); 618 SPARC32TOX64_UAP(asa, caddr_t); 619 SPARC32TOP_UAP(alen, int); 620 return (compat_43_sys_getsockname(p, &ua, retval)); 621 } 622 623 int 624 compat_43_compat_sparc32_ogetpeername(p, v, retval) 625 struct proc *p; 626 void *v; 627 register_t *retval; 628 { 629 struct compat_43_compat_sparc32_ogetpeername_args /* { 630 syscallarg(int) fdes; 631 syscallarg(sparc32_caddr_t) asa; 632 syscallarg(sparc32_intp) alen; 633 } */ *uap = v; 634 struct compat_43_sys_getpeername_args ua; 635 636 SPARC32TO64_UAP(fdes); 637 SPARC32TOX64_UAP(asa, caddr_t); 638 SPARC32TOP_UAP(alen, int); 639 return (compat_43_sys_getpeername(p, &ua, retval)); 640 } 641 642 /* signal syscalls */ 643 int 644 compat_43_compat_sparc32_osigvec(p, v, retval) 645 struct proc *p; 646 void *v; 647 register_t *retval; 648 { 649 struct compat_43_compat_sparc32_osigvec_args /* { 650 syscallarg(int) signum; 651 syscallarg(sparc32_sigvecp_t) nsv; 652 syscallarg(sparc32_sigvecp_t) osv; 653 } */ *uap = v; 654 struct compat_43_sys_sigvec_args ua; 655 struct sparc32_sigvec *sv32p; 656 struct sigvec nsv, osv; 657 int rv; 658 659 SPARC32TO64_UAP(signum); 660 if (SCARG(uap, osv)) 661 SCARG(&ua, osv) = &osv; 662 else 663 SCARG(&ua, osv) = NULL; 664 if (SCARG(uap, nsv)) { 665 SCARG(&ua, nsv) = &nsv; 666 sv32p = (struct sparc32_sigvec *)(u_long)SCARG(uap, nsv); 667 nsv.sv_handler = (void *)(u_long)sv32p->sv_handler; 668 nsv.sv_mask = sv32p->sv_mask; 669 nsv.sv_flags = sv32p->sv_flags; 670 } else 671 SCARG(&ua, nsv) = NULL; 672 rv = compat_43_sys_sigvec(p, &ua, retval); 673 if (rv) 674 return (rv); 675 676 if (SCARG(uap, osv)) { 677 sv32p = (struct sparc32_sigvec *)(u_long)SCARG(uap, osv); 678 sv32p->sv_handler = (sparc32_sigvecp_t)(u_long)osv.sv_handler; 679 sv32p->sv_mask = osv.sv_mask; 680 sv32p->sv_flags = osv.sv_flags; 681 } 682 683 return (0); 684 } 685 686 int 687 compat_43_compat_sparc32_sigblock(p, v, retval) 688 struct proc *p; 689 void *v; 690 register_t *retval; 691 { 692 struct compat_43_compat_sparc32_sigblock_args /* { 693 syscallarg(int) mask; 694 } */ *uap = v; 695 struct compat_43_sys_sigblock_args ua; 696 697 SPARC32TO64_UAP(mask); 698 return (compat_43_sys_sigblock(p, &ua, retval)); 699 } 700 701 int 702 compat_43_compat_sparc32_sigsetmask(p, v, retval) 703 struct proc *p; 704 void *v; 705 register_t *retval; 706 { 707 struct compat_43_compat_sparc32_sigsetmask_args /* { 708 syscallarg(int) mask; 709 } */ *uap = v; 710 struct compat_43_sys_sigsetmask_args ua; 711 712 SPARC32TO64_UAP(mask); 713 return (compat_43_sys_sigsetmask(p, &ua, retval)); 714 } 715 716 int 717 compat_43_compat_sparc32_osigstack(p, v, retval) 718 struct proc *p; 719 void *v; 720 register_t *retval; 721 { 722 struct compat_43_compat_sparc32_osigstack_args /* { 723 syscallarg(sparc32_sigstackp_t) nss; 724 syscallarg(sparc32_sigstackp_t) oss; 725 } */ *uap = v; 726 struct compat_43_sys_sigstack_args ua; 727 struct sparc32_sigstack *ss32p; 728 struct sigstack nss, oss; 729 int rv; 730 731 if (SCARG(uap, oss)) 732 SCARG(&ua, oss) = &oss; 733 else 734 SCARG(&ua, oss) = NULL; 735 if (SCARG(uap, nss)) { 736 SCARG(&ua, nss) = &nss; 737 ss32p = (struct sparc32_sigstack *)(u_long)SCARG(uap, nss); 738 nss.ss_sp = (void *)(u_long)ss32p->ss_sp; 739 nss.ss_onstack = ss32p->ss_onstack; 740 } else 741 SCARG(&ua, nss) = NULL; 742 743 rv = compat_43_sys_sigstack(p, &ua, retval); 744 if (rv) 745 return (rv); 746 747 if (SCARG(uap, oss)) { 748 ss32p = (struct sparc32_sigstack *)(u_long)SCARG(uap, oss); 749 ss32p->ss_sp = (sparc32_sigstackp_t)(u_long)oss.ss_sp; 750 ss32p->ss_onstack = oss.ss_onstack; 751 } 752 753 return (0); 754 } 755
Indexes created Tue Sep 23 13:09:54 GMT 2025