netbsd32_compat_43.c revision 1.3
1 /* $NetBSD: netbsd32_compat_43.c,v 1.3 1998/08/29 17:01:16 mrg 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_ogetrlimit(p, v, retval) 325 struct proc *p; 326 void *v; 327 register_t *retval; 328 { 329 struct compat_43_compat_sparc32_ogetrlimit_args /* { 330 syscallarg(int) which; 331 syscallarg(sparc32_orlimitp_t) rlp; 332 } */ *uap = v; 333 struct compat_43_sys_getrlimit_args ua; 334 335 SPARC32TO64_UAP(which); 336 SPARC32TOP_UAP(rlp, struct orlimit); 337 return (compat_43_sys_getrlimit(p, &ua, retval)); 338 } 339 340 int 341 compat_43_compat_sparc32_osetrlimit(p, v, retval) 342 struct proc *p; 343 void *v; 344 register_t *retval; 345 { 346 struct compat_43_compat_sparc32_osetrlimit_args /* { 347 syscallarg(int) which; 348 syscallarg(const sparc32_orlimitp_t) rlp; 349 } */ *uap = v; 350 struct compat_43_sys_setrlimit_args ua; 351 352 SPARC32TO64_UAP(which); 353 SPARC32TOP_UAP(rlp, struct orlimit); 354 return (compat_43_sys_setrlimit(p, &ua, retval)); 355 } 356 357 /* virtual memory syscalls */ 358 int 359 compat_43_compat_sparc32_ommap(p, v, retval) 360 struct proc *p; 361 void *v; 362 register_t *retval; 363 { 364 struct compat_43_compat_sparc32_ommap_args /* { 365 syscallarg(sparc32_caddr_t) addr; 366 syscallarg(sparc32_size_t) len; 367 syscallarg(int) prot; 368 syscallarg(int) flags; 369 syscallarg(int) fd; 370 syscallarg(sparc32_long) pos; 371 } */ *uap = v; 372 struct compat_43_sys_mmap_args ua; 373 374 SPARC32TOX64_UAP(addr, caddr_t); 375 SPARC32TOX_UAP(len, size_t); 376 SPARC32TO64_UAP(prot); 377 SPARC32TO64_UAP(flags); 378 SPARC32TO64_UAP(fd); 379 SPARC32TOX_UAP(pos, long); 380 return (compat_43_sys_mmap(p, &ua, retval)); 381 } 382 383 /* network syscalls */ 384 int 385 compat_43_compat_sparc32_oaccept(p, v, retval) 386 struct proc *p; 387 void *v; 388 register_t *retval; 389 { 390 struct compat_43_compat_sparc32_oaccept_args /* { 391 syscallarg(int) s; 392 syscallarg(sparc32_caddr_t) name; 393 syscallarg(sparc32_intp) anamelen; 394 } */ *uap = v; 395 struct compat_43_sys_accept_args ua; 396 397 SPARC32TOX_UAP(s, int); 398 SPARC32TOX64_UAP(name, caddr_t); 399 SPARC32TOP_UAP(anamelen, int); 400 return (compat_43_sys_accept(p, &ua, retval)); 401 } 402 403 int 404 compat_43_compat_sparc32_osend(p, v, retval) 405 struct proc *p; 406 void *v; 407 register_t *retval; 408 { 409 struct compat_43_compat_sparc32_osend_args /* { 410 syscallarg(int) s; 411 syscallarg(sparc32_caddr_t) buf; 412 syscallarg(int) len; 413 syscallarg(int) flags; 414 } */ *uap = v; 415 struct compat_43_sys_send_args ua; 416 417 SPARC32TO64_UAP(s); 418 SPARC32TOX64_UAP(buf, caddr_t); 419 SPARC32TO64_UAP(len); 420 SPARC32TO64_UAP(flags); 421 return (compat_43_sys_send(p, &ua, retval)); 422 } 423 424 int 425 compat_43_compat_sparc32_orecv(p, v, retval) 426 struct proc *p; 427 void *v; 428 register_t *retval; 429 { 430 struct compat_43_compat_sparc32_orecv_args /* { 431 syscallarg(int) s; 432 syscallarg(sparc32_caddr_t) buf; 433 syscallarg(int) len; 434 syscallarg(int) flags; 435 } */ *uap = v; 436 struct compat_43_sys_recv_args ua; 437 438 SPARC32TO64_UAP(s); 439 SPARC32TOX64_UAP(buf, caddr_t); 440 SPARC32TO64_UAP(len); 441 SPARC32TO64_UAP(flags); 442 return (compat_43_sys_recv(p, &ua, retval)); 443 } 444 445 /* 446 * XXX convert these to use a common iovec code to the native 447 * netbsd call. 448 */ 449 int 450 compat_43_compat_sparc32_orecvmsg(p, v, retval) 451 struct proc *p; 452 void *v; 453 register_t *retval; 454 { 455 struct compat_43_compat_sparc32_orecvmsg_args /* { 456 syscallarg(int) s; 457 syscallarg(sparc32_omsghdrp_t) msg; 458 syscallarg(int) flags; 459 } */ *uap = v; 460 struct compat_43_sys_recvmsg_args ua; 461 struct omsghdr omh; 462 struct omsghdr *omhp = &omh; 463 struct sparc32_omsghdr *omhp32; 464 struct iovec *iovec43p; 465 struct sparc32_iovec *iovec32p; 466 int i; 467 468 SPARC32TO64_UAP(s); 469 SPARC32TO64_UAP(flags); 470 471 SCARG(&ua, msg) = omhp; 472 omhp32 = (struct sparc32_omsghdr *)(u_long)SCARG(uap, msg); 473 omhp->msg_name = (caddr_t)(u_long)omhp32->msg_name; 474 omhp->msg_namelen = omhp32->msg_namelen; 475 omhp->msg_iovlen = (size_t)omhp32->msg_iovlen; 476 MALLOC(omhp->msg_iov, struct iovec *, sizeof(struct iovec) * omhp->msg_iovlen, M_TEMP, M_WAITOK); 477 iovec43p = omhp->msg_iov; 478 iovec32p = (struct sparc32_iovec *)(u_long)omhp32->msg_iov; 479 for (i = 0; i < omhp->msg_iovlen; i++, iovec43p++, iovec32p++) { 480 iovec43p->iov_base = (struct iovec *)(u_long)iovec32p->iov_base; 481 iovec43p->iov_len = (size_t)iovec32p->iov_len; 482 } 483 484 omhp->msg_accrights = (caddr_t)(u_long)omhp32->msg_accrights; 485 omhp->msg_accrightslen = omhp32->msg_accrightslen; 486 487 return (compat_43_sys_recvmsg(p, &ua, retval)); 488 } 489 490 int 491 compat_43_compat_sparc32_osendmsg(p, v, retval) 492 struct proc *p; 493 void *v; 494 register_t *retval; 495 { 496 struct compat_43_compat_sparc32_osendmsg_args /* { 497 syscallarg(int) s; 498 syscallarg(sparc32_caddr_t) msg; 499 syscallarg(int) flags; 500 } */ *uap = v; 501 struct compat_43_sys_sendmsg_args ua; 502 struct omsghdr omh; 503 struct omsghdr *omhp = &omh; 504 struct sparc32_omsghdr *omhp32; 505 struct iovec *iovec43p; 506 struct sparc32_iovec *iovec32p; 507 int i; 508 509 SPARC32TO64_UAP(s); 510 SPARC32TO64_UAP(flags); 511 512 SCARG(&ua, msg) = (caddr_t)(u_long)omhp; 513 omhp32 = (struct sparc32_omsghdr *)(u_long)SCARG(uap, msg); 514 omhp->msg_name = (caddr_t)(u_long)omhp32->msg_name; 515 omhp->msg_namelen = omhp32->msg_namelen; 516 omhp->msg_iovlen = (size_t)omhp32->msg_iovlen; 517 MALLOC(omhp->msg_iov, struct iovec *, sizeof(struct iovec) * omhp->msg_iovlen, M_TEMP, M_WAITOK); 518 iovec43p = omhp->msg_iov; 519 iovec32p = (struct sparc32_iovec *)(u_long)omhp32->msg_iov; 520 for (i = 0; i < omhp->msg_iovlen; i++, iovec43p++, iovec32p++) { 521 iovec43p->iov_base = (void *)(u_long)iovec32p->iov_base; 522 iovec43p->iov_len = (size_t)iovec32p->iov_len; 523 } 524 525 omhp->msg_accrights = (caddr_t)(u_long)omhp32->msg_accrights; 526 omhp->msg_accrightslen = omhp32->msg_accrightslen; 527 528 return (compat_43_sys_sendmsg(p, &ua, retval)); 529 } 530 531 int 532 compat_43_compat_sparc32_orecvfrom(p, v, retval) 533 struct proc *p; 534 void *v; 535 register_t *retval; 536 { 537 struct compat_43_compat_sparc32_orecvfrom_args /* { 538 syscallarg(int) s; 539 syscallarg(sparc32_caddr_t) buf; 540 syscallarg(sparc32_size_t) len; 541 syscallarg(int) flags; 542 syscallarg(sparc32_caddr_t) from; 543 syscallarg(sparc32_intp) fromlenaddr; 544 } */ *uap = v; 545 struct compat_43_sys_recvfrom_args ua; 546 547 SPARC32TO64_UAP(s); 548 SPARC32TOX64_UAP(buf, caddr_t); 549 SPARC32TOX_UAP(len, size_t); 550 SPARC32TO64_UAP(flags); 551 SPARC32TOX64_UAP(from, caddr_t); 552 SPARC32TOP_UAP(fromlenaddr, int); 553 return (compat_43_sys_recvfrom(p, &ua, retval)); 554 } 555 556 int 557 compat_43_compat_sparc32_ogetsockname(p, v, retval) 558 struct proc *p; 559 void *v; 560 register_t *retval; 561 { 562 struct compat_43_compat_sparc32_ogetsockname_args /* { 563 syscallarg(int) fdec; 564 syscallarg(sparc32_caddr_t) asa; 565 syscallarg(sparc32_intp) alen; 566 } */ *uap = v; 567 struct compat_43_sys_getsockname_args ua; 568 569 SPARC32TO64_UAP(fdec); 570 SPARC32TOX64_UAP(asa, caddr_t); 571 SPARC32TOP_UAP(alen, int); 572 return (compat_43_sys_getsockname(p, &ua, retval)); 573 } 574 575 int 576 compat_43_compat_sparc32_ogetpeername(p, v, retval) 577 struct proc *p; 578 void *v; 579 register_t *retval; 580 { 581 struct compat_43_compat_sparc32_ogetpeername_args /* { 582 syscallarg(int) fdes; 583 syscallarg(sparc32_caddr_t) asa; 584 syscallarg(sparc32_intp) alen; 585 } */ *uap = v; 586 struct compat_43_sys_getpeername_args ua; 587 588 SPARC32TO64_UAP(fdes); 589 SPARC32TOX64_UAP(asa, caddr_t); 590 SPARC32TOP_UAP(alen, int); 591 return (compat_43_sys_getpeername(p, &ua, retval)); 592 } 593 594 /* signal syscalls */ 595 int 596 compat_43_compat_sparc32_osigvec(p, v, retval) 597 struct proc *p; 598 void *v; 599 register_t *retval; 600 { 601 struct compat_43_compat_sparc32_osigvec_args /* { 602 syscallarg(int) signum; 603 syscallarg(sparc32_sigvecp_t) nsv; 604 syscallarg(sparc32_sigvecp_t) osv; 605 } */ *uap = v; 606 struct compat_43_sys_sigvec_args ua; 607 struct sparc32_sigvec *sv32p; 608 struct sigvec nsv, osv; 609 int rv; 610 611 SPARC32TO64_UAP(signum); 612 if (SCARG(uap, osv)) 613 SCARG(&ua, osv) = &osv; 614 else 615 SCARG(&ua, osv) = NULL; 616 if (SCARG(uap, nsv)) { 617 SCARG(&ua, nsv) = &nsv; 618 sv32p = (struct sparc32_sigvec *)(u_long)SCARG(uap, nsv); 619 nsv.sv_handler = (void *)(u_long)sv32p->sv_handler; 620 nsv.sv_mask = sv32p->sv_mask; 621 nsv.sv_flags = sv32p->sv_flags; 622 } else 623 SCARG(&ua, nsv) = NULL; 624 rv = compat_43_sys_sigvec(p, &ua, retval); 625 if (rv) 626 return (rv); 627 628 if (SCARG(uap, osv)) { 629 sv32p = (struct sparc32_sigvec *)(u_long)SCARG(uap, osv); 630 sv32p->sv_handler = (sparc32_sigvecp_t)(u_long)osv.sv_handler; 631 sv32p->sv_mask = osv.sv_mask; 632 sv32p->sv_flags = osv.sv_flags; 633 } 634 635 return (0); 636 } 637 638 int 639 compat_43_compat_sparc32_osigstack(p, v, retval) 640 struct proc *p; 641 void *v; 642 register_t *retval; 643 { 644 struct compat_43_compat_sparc32_osigstack_args /* { 645 syscallarg(sparc32_sigstackp_t) nss; 646 syscallarg(sparc32_sigstackp_t) oss; 647 } */ *uap = v; 648 struct compat_43_sys_sigstack_args ua; 649 struct sparc32_sigstack *ss32p; 650 struct sigstack nss, oss; 651 int rv; 652 653 if (SCARG(uap, oss)) 654 SCARG(&ua, oss) = &oss; 655 else 656 SCARG(&ua, oss) = NULL; 657 if (SCARG(uap, nss)) { 658 SCARG(&ua, nss) = &nss; 659 ss32p = (struct sparc32_sigstack *)(u_long)SCARG(uap, nss); 660 nss.ss_sp = (void *)(u_long)ss32p->ss_sp; 661 nss.ss_onstack = ss32p->ss_onstack; 662 } else 663 SCARG(&ua, nss) = NULL; 664 665 rv = compat_43_sys_sigstack(p, &ua, retval); 666 if (rv) 667 return (rv); 668 669 if (SCARG(uap, oss)) { 670 ss32p = (struct sparc32_sigstack *)(u_long)SCARG(uap, oss); 671 ss32p->ss_sp = (sparc32_sigstackp_t)(u_long)oss.ss_sp; 672 ss32p->ss_onstack = oss.ss_onstack; 673 } 674 675 return (0); 676 } 677
Indexes created Tue Sep 23 02:09:52 GMT 2025