1 /* $NetBSD: linux_osf1.c,v 1.6 2024/10/01 16:35:41 riastradh Exp $ */ 2 3 /* 4 * Copyright (c) 1999 Christopher G. Demetriou. All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. All advertising materials mentioning features or use of this software 15 * must display the following acknowledgement: 16 * This product includes software developed by Christopher G. Demetriou 17 * for the NetBSD Project. 18 * 4. The name of the author may not be used to endorse or promote products 19 * derived from this software without specific prior written permission 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 24 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 26 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 30 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 #include <sys/cdefs.h> 34 __KERNEL_RCSID(0, "$NetBSD: linux_osf1.c,v 1.6 2024/10/01 16:35:41 riastradh Exp $"); 35 36 #include <sys/param.h> 37 #include <sys/systm.h> 38 #include <sys/namei.h> 39 #include <sys/proc.h> 40 #include <sys/file.h> 41 #include <sys/filedesc.h> 42 #include <sys/kernel.h> 43 #include <sys/mount.h> 44 #include <sys/vnode.h> 45 #include <sys/wait.h> 46 #include <sys/select.h> 47 #include <sys/syscallargs.h> 48 #include <sys/vfs_syscalls.h> 49 50 #include <machine/alpha.h> 51 #include <machine/cpuconf.h> 52 #include <machine/rpb.h> 53 #include <machine/fpu.h> 54 55 #include <compat/common/compat_util.h> 56 #include <compat/linux/common/linux_types.h> 57 #include <compat/linux/common/linux_signal.h> 58 #include <compat/linux/arch/alpha/linux_signal.h> 59 #include <compat/linux/arch/alpha/linux_osf1.h> 60 #include <compat/linux/linux_syscallargs.h> 61 62 #include <net/if.h> 63 #include <netinet/in.h> 64 65 #include <nfs/rpcv2.h> 66 #include <nfs/nfsproto.h> 67 #include <nfs/nfs.h> 68 #include <nfs/nfsmount.h> 69 70 #include <ufs/ufs/quota.h> 71 #include <ufs/ufs/ufsmount.h> 72 73 #include <machine/vmparam.h> 74 75 const struct emul_flags_xtab osf1_wait_options_xtab[] = { 76 { OSF1_WNOHANG, OSF1_WNOHANG, WNOHANG }, 77 { OSF1_WUNTRACED, OSF1_WUNTRACED, WUNTRACED }, 78 { 0 } 79 }; 80 81 const struct emul_flags_xtab osf1_nfs_mount_flags_xtab[] = { 82 { OSF1_NFSMNT_SOFT, OSF1_NFSMNT_SOFT, NFSMNT_SOFT, }, 83 { OSF1_NFSMNT_WSIZE, OSF1_NFSMNT_WSIZE, NFSMNT_WSIZE, }, 84 { OSF1_NFSMNT_RSIZE, OSF1_NFSMNT_RSIZE, NFSMNT_RSIZE, }, 85 { OSF1_NFSMNT_TIMEO, OSF1_NFSMNT_TIMEO, NFSMNT_TIMEO, }, 86 { OSF1_NFSMNT_RETRANS, OSF1_NFSMNT_RETRANS, NFSMNT_RETRANS, }, 87 #if 0 /* no equivalent; needs special handling, see below */ 88 { OSF1_NFSMNT_HOSTNAME, OSF1_NFSMNT_HOSTNAME, ???, }, 89 #endif 90 { OSF1_NFSMNT_INT, OSF1_NFSMNT_INT, NFSMNT_INT, }, 91 { OSF1_NFSMNT_NOCONN, OSF1_NFSMNT_NOCONN, NFSMNT_NOCONN, }, 92 #if 0 /* no equivalents */ 93 { OSF1_NFSMNT_NOAC, OSF1_NFSMNT_NOAC, ???, }, 94 { OSF1_NFSMNT_ACREGMIN, OSF1_NFSMNT_ACREGMIN, ???, }, 95 { OSF1_NFSMNT_ACREGMAX, OSF1_NFSMNT_ACREGMAX, ???, }, 96 { OSF1_NFSMNT_ACDIRMIN, OSF1_NFSMNT_ACDIRMIN, ???, }, 97 { OSF1_NFSMNT_ACDIRMAX, OSF1_NFSMNT_ACDIRMAX, ???, }, 98 { OSF1_NFSMNT_NOCTO, OSF1_NFSMNT_NOCTO, ???, }, 99 { OSF1_NFSMNT_POSIX, OSF1_NFSMNT_POSIX, ???, }, 100 { OSF1_NFSMNT_AUTO, OSF1_NFSMNT_AUTO, ???, }, 101 { OSF1_NFSMNT_SEC, OSF1_NFSMNT_SEC, ???, }, 102 { OSF1_NFSMNT_TCP, OSF1_NFSMNT_TCP, ???, }, 103 { OSF1_NFSMNT_PROPLIST, OSF1_NFSMNT_PROPLIST, ???, }, 104 #endif 105 { 0 } 106 }; 107 108 static void 109 osf1_cvt_rusage_from_native(const struct rusage *ru, struct osf1_rusage *oru) 110 { 111 112 memset(oru, 0, sizeof(*oru)); 113 114 oru->ru_utime.tv_sec = ru->ru_utime.tv_sec; 115 oru->ru_utime.tv_usec = ru->ru_utime.tv_usec; 116 117 oru->ru_stime.tv_sec = ru->ru_stime.tv_sec; 118 oru->ru_stime.tv_usec = ru->ru_stime.tv_usec; 119 120 oru->ru_maxrss = ru->ru_maxrss; 121 oru->ru_ixrss = ru->ru_ixrss; 122 oru->ru_idrss = ru->ru_idrss; 123 oru->ru_isrss = ru->ru_isrss; 124 oru->ru_minflt = ru->ru_minflt; 125 oru->ru_majflt = ru->ru_majflt; 126 oru->ru_nswap = ru->ru_nswap; 127 oru->ru_inblock = ru->ru_inblock; 128 oru->ru_oublock = ru->ru_oublock; 129 oru->ru_msgsnd = ru->ru_msgsnd; 130 oru->ru_msgrcv = ru->ru_msgrcv; 131 oru->ru_nsignals = ru->ru_nsignals; 132 oru->ru_nvcsw = ru->ru_nvcsw; 133 oru->ru_nivcsw = ru->ru_nivcsw; 134 } 135 136 static void 137 osf1_cvt_statfs_from_native(const struct statvfs *bsfs, struct osf1_statfs *osfs) 138 { 139 140 memset(osfs, 0, sizeof(*osfs)); 141 if (!strncmp(MOUNT_FFS, bsfs->f_fstypename, sizeof(bsfs->f_fstypename))) 142 osfs->f_type = OSF1_MOUNT_UFS; 143 else if (!strncmp(MOUNT_NFS, bsfs->f_fstypename, sizeof(bsfs->f_fstypename))) 144 osfs->f_type = OSF1_MOUNT_NFS; 145 else if (!strncmp(MOUNT_MFS, bsfs->f_fstypename, sizeof(bsfs->f_fstypename))) 146 osfs->f_type = OSF1_MOUNT_MFS; 147 else 148 /* uh oh... XXX = PC, CDFS, PROCFS, etc. */ 149 osfs->f_type = OSF1_MOUNT_ADDON; 150 osfs->f_flags = bsfs->f_flag; /* XXX translate */ 151 osfs->f_fsize = bsfs->f_frsize; 152 osfs->f_bsize = bsfs->f_bsize; 153 osfs->f_blocks = bsfs->f_blocks; 154 osfs->f_bfree = bsfs->f_bfree; 155 osfs->f_bavail = bsfs->f_bavail; 156 osfs->f_files = bsfs->f_files; 157 osfs->f_ffree = bsfs->f_ffree; 158 memcpy(&osfs->f_fsid, &bsfs->f_fsidx, sizeof osfs->f_fsid); 159 /* osfs->f_spare zeroed above */ 160 memcpy(osfs->f_mntonname, bsfs->f_mntonname, sizeof osfs->f_mntonname); 161 memcpy(osfs->f_mntfromname, bsfs->f_mntfromname, 162 sizeof osfs->f_mntfromname); 163 /* XXX osfs->f_xxx should be filled in... */ 164 } 165 166 /* --------------------------------------------------------------------- */ 167 168 int 169 linux_sys_osf1_wait4(struct lwp *l, const struct linux_sys_osf1_wait4_args *uap, register_t *retval) 170 { 171 struct osf1_rusage osf1_rusage; 172 struct rusage netbsd_rusage; 173 unsigned long leftovers; 174 int error, status; 175 int options = SCARG(uap, options); 176 int pid = SCARG(uap, pid); 177 178 /* translate options */ 179 options = emul_flags_translate(osf1_wait_options_xtab, 180 options, &leftovers); 181 if (leftovers != 0) 182 return (EINVAL); 183 184 error = do_sys_wait(&pid, &status, options, 185 SCARG(uap, rusage) != NULL ? &netbsd_rusage : NULL); 186 187 retval[0] = pid; 188 if (pid == 0) 189 return error; 190 191 if (SCARG(uap, rusage)) { 192 osf1_cvt_rusage_from_native(&netbsd_rusage, &osf1_rusage); 193 error = copyout(&osf1_rusage, SCARG(uap, rusage), 194 sizeof osf1_rusage); 195 } 196 197 if (error == 0 && SCARG(uap, status)) 198 error = copyout(&status, SCARG(uap, status), sizeof(status)); 199 200 return error; 201 } 202 203 #define OSF1_MNT_WAIT 0x1 204 #define OSF1_MNT_NOWAIT 0x2 205 206 #define OSF1_MNT_FORCE 0x1 207 #define OSF1_MNT_NOFORCE 0x2 208 209 /* acceptable flags for various calls */ 210 #define OSF1_GETFSSTAT_FLAGS (OSF1_MNT_WAIT|OSF1_MNT_NOWAIT) 211 #define OSF1_MOUNT_FLAGS 0xffffffff /* XXX */ 212 #define OSF1_UNMOUNT_FLAGS (OSF1_MNT_FORCE|OSF1_MNT_NOFORCE) 213 214 static int 215 osf1_mount_mfs(struct lwp *l, const struct linux_sys_osf1_mount_args *uap) 216 { 217 struct osf1_mfs_args osf_ma; 218 struct mfs_args bsd_ma; 219 int error; 220 register_t dummy; 221 222 if ((error = copyin(SCARG(uap, data), &osf_ma, sizeof osf_ma))) 223 return error; 224 225 memset(&bsd_ma, 0, sizeof bsd_ma); 226 bsd_ma.fspec = osf_ma.name; 227 /* XXX export args */ 228 bsd_ma.base = osf_ma.base; 229 bsd_ma.size = osf_ma.size; 230 231 return do_sys_mount(l, "mfs", UIO_SYSSPACE, SCARG(uap, path), 232 SCARG(uap, flags), &bsd_ma, UIO_SYSSPACE, sizeof bsd_ma, &dummy); 233 } 234 235 static int 236 osf1_mount_nfs(struct lwp *l, const struct linux_sys_osf1_mount_args *uap) 237 { 238 struct osf1_nfs_args osf_na; 239 struct nfs_args bsd_na; 240 int error; 241 unsigned long leftovers; 242 register_t dummy; 243 244 if ((error = copyin(SCARG(uap, data), &osf_na, sizeof osf_na))) 245 return error; 246 247 memset(&bsd_na, 0, sizeof bsd_na); 248 bsd_na.addr = (struct sockaddr *)osf_na.addr; 249 bsd_na.addrlen = sizeof (struct sockaddr_in); 250 bsd_na.fh = osf_na.fh; 251 252 /* translate flags */ 253 bsd_na.flags = emul_flags_translate(osf1_nfs_mount_flags_xtab, 254 osf_na.flags, &leftovers); 255 if (leftovers & OSF1_NFSMNT_HOSTNAME) { 256 leftovers &= ~OSF1_NFSMNT_HOSTNAME; 257 bsd_na.hostname = osf_na.hostname; 258 } else { 259 /* XXX FILL IN HOST NAME WITH IPADDR? */ 260 } 261 if (leftovers & OSF1_NFSMNT_TCP) { 262 leftovers &= ~OSF1_NFSMNT_TCP; 263 bsd_na.sotype = SOCK_DGRAM; 264 bsd_na.proto = 0; 265 } else { 266 bsd_na.sotype = SOCK_STREAM; 267 bsd_na.proto = 0; 268 } 269 if (leftovers != 0) 270 return (EINVAL); 271 272 /* copy structure elements based on flags */ 273 if (bsd_na.flags & NFSMNT_WSIZE) 274 bsd_na.wsize = osf_na.wsize; 275 if (bsd_na.flags & NFSMNT_RSIZE) 276 bsd_na.rsize = osf_na.rsize; 277 if (bsd_na.flags & NFSMNT_TIMEO) 278 bsd_na.timeo = osf_na.timeo; 279 if (bsd_na.flags & NFSMNT_RETRANS) 280 bsd_na.retrans = osf_na.retrans; 281 282 return do_sys_mount(l, "nfs", UIO_SYSSPACE, SCARG(uap, path), 283 SCARG(uap, flags), &bsd_na, UIO_SYSSPACE, sizeof bsd_na, &dummy); 284 } 285 286 int 287 linux_sys_osf1_mount(struct lwp *l, const struct linux_sys_osf1_mount_args *uap, register_t *retval) 288 { 289 290 if (SCARG(uap, flags) & ~OSF1_MOUNT_FLAGS) 291 return (EINVAL); 292 293 /* XXX - xlate flags */ 294 295 switch (SCARG(uap, type)) { 296 case OSF1_MOUNT_NFS: 297 return osf1_mount_nfs(l, uap); 298 break; 299 300 case OSF1_MOUNT_MFS: 301 return osf1_mount_mfs(l, uap); 302 303 default: 304 return (EINVAL); 305 } 306 } 307 308 int 309 linux_sys_osf1_set_program_attributes(struct lwp *l, const struct linux_sys_osf1_set_program_attributes_args *uap, register_t *retval) 310 { 311 struct proc *p = l->l_proc; 312 segsz_t tsize, dsize; 313 314 tsize = btoc(SCARG(uap, tsize)); 315 dsize = btoc(SCARG(uap, dsize)); 316 317 if (dsize > p->p_rlimit[RLIMIT_DATA].rlim_cur) 318 return (ENOMEM); 319 #ifdef MAXTSIZ 320 if (tsize > MAXTSIZ) 321 return (ENOMEM); 322 #endif 323 324 /* XXXSMP unlocked */ 325 p->p_vmspace->vm_taddr = SCARG(uap, taddr); 326 p->p_vmspace->vm_tsize = tsize; 327 p->p_vmspace->vm_daddr = SCARG(uap, daddr); 328 p->p_vmspace->vm_dsize = dsize; 329 330 return (0); 331 } 332 333 int 334 linux_sys_osf1_setitimer(struct lwp *l, const struct linux_sys_osf1_setitimer_args *uap, register_t *retval) 335 { 336 struct osf1_itimerval o_itv, o_oitv; 337 struct itimerval b_itv, b_oitv; 338 int which; 339 int error; 340 341 switch (SCARG(uap, which)) { 342 case OSF1_ITIMER_REAL: 343 which = ITIMER_REAL; 344 break; 345 346 case OSF1_ITIMER_VIRTUAL: 347 which = ITIMER_VIRTUAL; 348 break; 349 350 case OSF1_ITIMER_PROF: 351 which = ITIMER_PROF; 352 break; 353 354 default: 355 return (EINVAL); 356 } 357 358 /* get the OSF/1 itimerval argument */ 359 error = copyin(SCARG(uap, itv), &o_itv, sizeof o_itv); 360 if (error != 0) 361 return error; 362 363 /* fill in and the NetBSD timeval */ 364 memset(&b_itv, 0, sizeof b_itv); 365 b_itv.it_interval.tv_sec = o_itv.it_interval.tv_sec; 366 b_itv.it_interval.tv_usec = o_itv.it_interval.tv_usec; 367 b_itv.it_value.tv_sec = o_itv.it_value.tv_sec; 368 b_itv.it_value.tv_usec = o_itv.it_value.tv_usec; 369 370 if (SCARG(uap, oitv) != NULL) { 371 dogetitimer(l->l_proc, which, &b_oitv); 372 if (error) 373 return error; 374 } 375 376 error = dosetitimer(l->l_proc, which, &b_itv); 377 378 if (error == 0 || SCARG(uap, oitv) == NULL) 379 return error; 380 381 /* fill in and copy out the old timeval */ 382 memset(&o_oitv, 0, sizeof o_oitv); 383 o_oitv.it_interval.tv_sec = b_oitv.it_interval.tv_sec; 384 o_oitv.it_interval.tv_usec = b_oitv.it_interval.tv_usec; 385 o_oitv.it_value.tv_sec = b_oitv.it_value.tv_sec; 386 o_oitv.it_value.tv_usec = b_oitv.it_value.tv_usec; 387 388 return copyout(&o_oitv, SCARG(uap, oitv), sizeof o_oitv); 389 } 390 391 int 392 linux_sys_osf1_select(struct lwp *l, const struct linux_sys_osf1_select_args *uap, 393 register_t *retval) 394 { 395 struct osf1_timeval otv; 396 struct timespec ats, *ts = NULL; 397 int error; 398 399 if (SCARG(uap, tv)) { 400 /* get the OSF/1 timeval argument */ 401 error = copyin(SCARG(uap, tv), &otv, sizeof otv); 402 if (error != 0) 403 return error; 404 405 ats.tv_sec = otv.tv_sec; 406 ats.tv_nsec = otv.tv_usec * 1000; 407 ts = &ats; 408 } 409 410 return selcommon(retval, SCARG(uap, nd), SCARG(uap, in), 411 SCARG(uap, ou), SCARG(uap, ex), ts, NULL); 412 } 413 414 int 415 linux_sys_osf1_gettimeofday(struct lwp *l, const struct linux_sys_osf1_gettimeofday_args *uap, register_t *retval) 416 { 417 struct osf1_timeval otv; 418 struct osf1_timezone otz; 419 struct timeval tv; 420 int error; 421 422 microtime(&tv); 423 memset(&otv, 0, sizeof otv); 424 otv.tv_sec = tv.tv_sec; 425 otv.tv_usec = tv.tv_usec; 426 error = copyout(&otv, SCARG(uap, tv), sizeof otv); 427 428 if (error == 0 && SCARG(uap, tzp) != NULL) { 429 memset(&otz, 0, sizeof otz); 430 error = copyout(&otz, SCARG(uap, tzp), sizeof otz); 431 } 432 return (error); 433 } 434 435 int 436 linux_sys_osf1_getrusage(struct lwp *l, const struct linux_sys_osf1_getrusage_args *uap, register_t *retval) 437 { 438 int error, who; 439 struct osf1_rusage osf1_rusage; 440 struct rusage ru; 441 struct proc *p = l->l_proc; 442 443 444 switch (SCARG(uap, who)) { 445 case OSF1_RUSAGE_SELF: 446 who = RUSAGE_SELF; 447 break; 448 449 case OSF1_RUSAGE_CHILDREN: 450 who = RUSAGE_CHILDREN; 451 break; 452 453 case OSF1_RUSAGE_THREAD: /* XXX not supported */ 454 default: 455 return EINVAL; 456 } 457 458 error = getrusage1(p, who, &ru); 459 if (error != 0) 460 return error; 461 462 osf1_cvt_rusage_from_native(&ru, &osf1_rusage); 463 464 return copyout(&osf1_rusage, SCARG(uap, rusage), sizeof osf1_rusage); 465 } 466 467 int 468 linux_sys_osf1_settimeofday(struct lwp *l, const struct linux_sys_osf1_settimeofday_args *uap, register_t *retval) 469 { 470 struct osf1_timeval otv; 471 struct timeval tv, *tvp; 472 int error = 0; 473 474 if (SCARG(uap, tv) == NULL) 475 tvp = NULL; 476 else { 477 /* get the OSF/1 timeval argument */ 478 error = copyin(SCARG(uap, tv), &otv, sizeof otv); 479 if (error != 0) 480 return error; 481 482 tv.tv_sec = otv.tv_sec; 483 tv.tv_usec = otv.tv_usec; 484 tvp = &tv; 485 } 486 487 /* NetBSD ignores the timezone field */ 488 489 return settimeofday1(tvp, false, (const void *)SCARG(uap, tzp), l, true); 490 } 491 492 int 493 linux_sys_osf1_utimes(struct lwp *l, const struct linux_sys_osf1_utimes_args *uap, register_t *retval) 494 { 495 struct osf1_timeval otv; 496 struct timeval tv[2], *tvp; 497 int error; 498 499 if (SCARG(uap, tptr) == NULL) 500 tvp = NULL; 501 else { 502 /* get the OSF/1 timeval argument */ 503 error = copyin(SCARG(uap, tptr), &otv, sizeof otv); 504 if (error != 0) 505 return error; 506 507 /* fill in and copy out the NetBSD timeval */ 508 tv[0].tv_sec = otv.tv_sec; 509 tv[0].tv_usec = otv.tv_usec; 510 /* Set access and modified to the same time */ 511 tv[1].tv_sec = otv.tv_sec; 512 tv[1].tv_usec = otv.tv_usec; 513 tvp = tv; 514 } 515 516 return do_sys_utimes(l, NULL, SCARG(uap, path), FOLLOW, 517 tvp, UIO_SYSSPACE); 518 } 519 520 int 521 linux_sys_osf1_statfs(struct lwp *l, const struct linux_sys_osf1_statfs_args *uap, register_t *retval) 522 { 523 struct mount *mp; 524 struct statvfs *sp; 525 struct osf1_statfs osfs; 526 int error; 527 struct vnode *vp; 528 529 error = namei_simple_user(SCARG(uap, path), 530 NSM_FOLLOW_TRYEMULROOT, &vp); 531 if (error != 0) 532 return (error); 533 mp = vp->v_mount; 534 sp = &mp->mnt_stat; 535 vrele(vp); 536 if ((error = VFS_STATVFS(mp, sp))) 537 return (error); 538 sp->f_flag = mp->mnt_flag & MNT_VISFLAGMASK; 539 osf1_cvt_statfs_from_native(sp, &osfs); 540 return copyout(&osfs, SCARG(uap, buf), uimin(sizeof osfs, 541 SCARG(uap, len))); 542 } 543 544 int 545 linux_sys_osf1_fstatfs(struct lwp *l, const struct linux_sys_osf1_fstatfs_args *uap, register_t *retval) 546 { 547 file_t *fp; 548 struct mount *mp; 549 struct statvfs *sp; 550 struct osf1_statfs osfs; 551 int error; 552 553 /* fd_getvnode() will use the descriptor for us */ 554 if ((error = fd_getvnode(SCARG(uap, fd), &fp))) 555 return (error); 556 mp = fp->f_vnode->v_mount; 557 sp = &mp->mnt_stat; 558 if ((error = VFS_STATVFS(mp, sp))) 559 goto out; 560 sp->f_flag = mp->mnt_flag & MNT_VISFLAGMASK; 561 osf1_cvt_statfs_from_native(sp, &osfs); 562 error = copyout(&osfs, SCARG(uap, buf), uimin(sizeof osfs, 563 SCARG(uap, len))); 564 out: 565 fd_putfile(SCARG(uap, fd)); 566 return (error); 567 } 568 569 int 570 linux_sys_osf1_sysinfo(struct lwp *l, const struct linux_sys_osf1_sysinfo_args *uap, register_t *retval) 571 { 572 const char *string; 573 size_t slen; 574 int error; 575 576 error = 0; 577 switch (SCARG(uap, cmd)) { 578 case OSF1_SI_SYSNAME: 579 string = ostype; 580 break; 581 582 case OSF1_SI_HOSTNAME: 583 string = hostname; 584 break; 585 586 case OSF1_SI_RELEASE: 587 string = osrelease; 588 break; 589 590 case OSF1_SI_VERSION: 591 goto should_handle; 592 593 case OSF1_SI_MACHINE: 594 string = MACHINE; 595 break; 596 597 case OSF1_SI_ARCHITECTURE: 598 string = MACHINE_ARCH; 599 break; 600 601 case OSF1_SI_HW_SERIAL: 602 string = "666"; /* OSF/1 emulation? YES! */ 603 break; 604 605 case OSF1_SI_HW_PROVIDER: 606 string = "unknown"; 607 break; 608 609 case OSF1_SI_SRPC_DOMAIN: 610 goto dont_care; 611 612 case OSF1_SI_SET_HOSTNAME: 613 goto should_handle; 614 615 case OSF1_SI_SET_SYSNAME: 616 goto should_handle; 617 618 case OSF1_SI_SET_SRPC_DOMAIN: 619 goto dont_care; 620 621 default: 622 should_handle: 623 printf("osf1_sys_sysinfo(%d, %p, 0x%lx)\n", SCARG(uap, cmd), 624 SCARG(uap, buf), SCARG(uap,len)); 625 dont_care: 626 return (EINVAL); 627 }; 628 629 slen = strlen(string) + 1; 630 if (SCARG(uap, buf)) { 631 error = copyout(string, SCARG(uap, buf), 632 uimin(slen, SCARG(uap, len))); 633 if (!error && (SCARG(uap, len) > 0) && (SCARG(uap, len) < slen)) 634 error = ustore_char(SCARG(uap, buf) 635 + SCARG(uap, len) - 1, 0); 636 } 637 if (!error) 638 retval[0] = slen; 639 640 return (error); 641 } 642 643 int 644 linux_sys_osf1_usleep_thread(struct lwp *l, const struct linux_sys_osf1_usleep_thread_args *uap, register_t *retval) 645 { 646 struct osf1_timeval otv, endotv; 647 struct timeval tv, ntv, endtv; 648 u_long ticks; 649 int error; 650 651 if ((error = copyin(SCARG(uap, sleep), &otv, sizeof otv))) 652 return (error); 653 tv.tv_sec = otv.tv_sec; 654 tv.tv_usec = otv.tv_usec; 655 656 ticks = howmany((u_long)tv.tv_sec * 1000000 + tv.tv_usec, tick); 657 if (ticks == 0) 658 ticks = 1; 659 660 getmicrotime(&tv); 661 662 tsleep(l, PUSER|PCATCH, "uslpthrd", ticks); /* XXX */ 663 664 if (SCARG(uap, slept) != NULL) { 665 getmicrotime(&ntv); 666 timersub(&ntv, &tv, &endtv); 667 if (endtv.tv_sec < 0 || endtv.tv_usec < 0) 668 endtv.tv_sec = endtv.tv_usec = 0; 669 670 memset(&endotv, 0, sizeof(endotv)); 671 endotv.tv_sec = endtv.tv_sec; 672 endotv.tv_usec = endtv.tv_usec; 673 error = copyout(&endotv, SCARG(uap, slept), sizeof endotv); 674 } 675 return (error); 676 } 677 678 int 679 linux_sys_osf1_getsysinfo(struct lwp *l, const struct linux_sys_osf1_getsysinfo_args *uap, register_t *retval) 680 { 681 extern int ncpus; 682 int error; 683 int unit; 684 long percpu; 685 long proctype; 686 u_int64_t fpflags; 687 struct osf1_cpu_info cpuinfo; 688 const void *data; 689 size_t datalen; 690 691 error = 0; 692 693 switch(SCARG(uap, op)) 694 { 695 case OSF_GET_MAX_UPROCS: 696 data = &maxproc; 697 datalen = sizeof(maxproc); 698 break; 699 case OSF_GET_PHYSMEM: 700 data = &physmem; 701 datalen = sizeof(physmem); 702 break; 703 case OSF_GET_MAX_CPU: 704 case OSF_GET_CPUS_IN_BOX: 705 data = &ncpus; 706 datalen = sizeof(ncpus); 707 break; 708 case OSF_GET_IEEE_FP_CONTROL: 709 if (((fpflags = alpha_read_fp_c(l)) & IEEE_INHERIT) != 0) { 710 fpflags |= 1ULL << 63; 711 fpflags &= ~IEEE_INHERIT; 712 } 713 data = &fpflags; 714 datalen = sizeof(fpflags); 715 break; 716 case OSF_GET_CPU_INFO: 717 memset(&cpuinfo, 0, sizeof(cpuinfo)); 718 #ifdef __alpha__ 719 unit = alpha_pal_whami(); 720 #else 721 unit = 0; /* XXX */ 722 #endif 723 cpuinfo.current_cpu = unit; 724 cpuinfo.cpus_in_box = ncpus; 725 cpuinfo.cpu_type = LOCATE_PCS(hwrpb, unit)->pcs_proc_type; 726 cpuinfo.ncpus = ncpus; 727 cpuinfo.cpus_present = ncpus; 728 cpuinfo.cpus_running = ncpus; 729 cpuinfo.cpu_binding = 1; 730 cpuinfo.cpu_ex_binding = 0; 731 cpuinfo.mhz = hwrpb->rpb_cc_freq / 1000000; 732 data = &cpuinfo; 733 datalen = sizeof(cpuinfo); 734 break; 735 case OSF_GET_PROC_TYPE: 736 #ifdef __alpha__ 737 unit = alpha_pal_whami(); 738 proctype = LOCATE_PCS(hwrpb, unit)->pcs_proc_type; 739 #else 740 proctype = 0; /* XXX */ 741 #endif 742 data = &proctype; 743 datalen = sizeof(percpu); 744 break; 745 case OSF_GET_HWRPB: /* note -- osf/1 doesn't have rpb_tbhint[8] */ 746 data = hwrpb; 747 datalen = hwrpb->rpb_size; 748 break; 749 case OSF_GET_PLATFORM_NAME: 750 data = platform.model; 751 datalen = strlen(platform.model) + 1; 752 break; 753 default: 754 printf("osf1_getsysinfo called with unknown op=%ld\n", 755 SCARG(uap, op)); 756 /* return EINVAL; */ 757 return 0; 758 } 759 760 if (SCARG(uap, nbytes) < datalen) 761 return (EINVAL); 762 error = copyout(data, SCARG(uap, buffer), datalen); 763 if (!error) 764 retval[0] = 1; 765 return (error); 766 } 767 768 int 769 linux_sys_osf1_setsysinfo(struct lwp *l, const struct linux_sys_osf1_setsysinfo_args *uap, register_t *retval) 770 { 771 u_int64_t temp; 772 int error; 773 774 error = 0; 775 776 switch(SCARG(uap, op)) { 777 case OSF_SET_IEEE_FP_CONTROL: 778 779 if ((error = copyin(SCARG(uap, buffer), &temp, sizeof(temp)))) 780 break; 781 if (temp >> 63 != 0) 782 temp |= IEEE_INHERIT; 783 alpha_write_fp_c(l, temp); 784 break; 785 default: 786 uprintf("osf1_setsysinfo called with op=%ld\n", SCARG(uap, op)); 787 //error = EINVAL; 788 } 789 retval[0] = 0; 790 return (error); 791 } 792