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