sys/emulation/svr4/svr4_stat.c

   1 /*
   2  * Copyright (c) 1998 Mark Newton
   3  * Copyright (c) 1994 Christos Zoulas
   4  * 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. The name of the author may not be used to endorse or promote products
  15  *    derived from this software without specific prior written permission
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * $FreeBSD: src/sys/svr4/svr4_stat.c,v 1.6 1999/12/08 12:00:48 newton Exp $
  29  */
  30
  31 #include <sys/param.h>
  32 #include <sys/systm.h>
  33 #include <sys/proc.h>
  34 #include <sys/stat.h>
  35 #include <sys/filedesc.h>
  36 #include <sys/kernel.h>
  37 #include <sys/unistd.h>
  38 #include <sys/time.h>
  39 #include <sys/sysctl.h>
  40 #include <sys/sysproto.h>
  41
  42 #include <vm/vm.h>
  43
  44 #include <netinet/in.h>
  45
  46 #include <svr4/svr4.h>
  47 #include <svr4/svr4_types.h>
  48 #include <svr4/svr4_signal.h>
  49 #include <svr4/svr4_proto.h>
  50 #include <svr4/svr4_util.h>
  51 #include <svr4/svr4_stat.h>
  52 #include <svr4/svr4_ustat.h>
  53 #include <svr4/svr4_utsname.h>
  54 #include <svr4/svr4_systeminfo.h>
  55 #include <svr4/svr4_socket.h>
  56 #include <svr4/svr4_time.h>
  57 #if defined(NOTYET)
  58 #include "svr4_fuser.h"
  59 #endif
  60
  61 #ifdef sparc
  62 /*
  63  * Solaris-2.4 on the sparc has the old stat call using the new
  64  * stat data structure...
  65  */
  66 # define SVR4_NO_OSTAT
  67 #endif
  68
  69 struct svr4_ustat_args {
  70         svr4_dev_t              dev;
  71         struct svr4_ustat * name;
  72 };
  73
  74 static void bsd_to_svr4_xstat __P((struct stat *, struct svr4_xstat *));
  75 static void bsd_to_svr4_stat64 __P((struct stat *, struct svr4_stat64 *));
  76 int svr4_ustat __P((struct proc *, struct svr4_ustat_args *));
  77 static int svr4_to_bsd_pathconf __P((int));
  78
  79 /*
  80  * SVR4 uses named pipes as named sockets, so we tell programs
  81  * that sockets are named pipes with mode 0
  82  */
  83 #define BSD_TO_SVR4_MODE(mode) (S_ISSOCK(mode) ? S_IFIFO : (mode))
  84
  85
  86 #ifndef SVR4_NO_OSTAT
  87 static void bsd_to_svr4_stat __P((struct stat *, struct svr4_stat *));
  88
  89 static void
  90 bsd_to_svr4_stat(st, st4)
  91         struct stat             *st;
  92         struct svr4_stat        *st4;
  93 {
  94         memset(st4, 0, sizeof(*st4));
  95         st4->st_dev = bsd_to_svr4_odev_t(st->st_dev);
  96         st4->st_ino = st->st_ino;
  97         st4->st_mode = BSD_TO_SVR4_MODE(st->st_mode);
  98         st4->st_nlink = st->st_nlink;
  99         st4->st_uid = st->st_uid;
 100         st4->st_gid = st->st_gid;
 101         st4->st_rdev = bsd_to_svr4_odev_t(st->st_rdev);
 102         st4->st_size = st->st_size;
 103         st4->st_atim = st->st_atimespec.tv_sec;
 104         st4->st_mtim = st->st_mtimespec.tv_sec;
 105         st4->st_ctim = st->st_ctimespec.tv_sec;
 106 }
 107 #endif
 108
 109
 110 static void
 111 bsd_to_svr4_xstat(st, st4)
 112         struct stat             *st;
 113         struct svr4_xstat       *st4;
 114 {
 115         memset(st4, 0, sizeof(*st4));
 116         st4->st_dev = bsd_to_svr4_dev_t(st->st_dev);
 117         st4->st_ino = st->st_ino;
 118         st4->st_mode = BSD_TO_SVR4_MODE(st->st_mode);
 119         st4->st_nlink = st->st_nlink;
 120         st4->st_uid = st->st_uid;
 121         st4->st_gid = st->st_gid;
 122         st4->st_rdev = bsd_to_svr4_dev_t(st->st_rdev);
 123         st4->st_size = st->st_size;
 124         st4->st_atim = st->st_atimespec;
 125         st4->st_mtim = st->st_mtimespec;
 126         st4->st_ctim = st->st_ctimespec;
 127         st4->st_blksize = st->st_blksize;
 128         st4->st_blocks = st->st_blocks;
 129         strcpy(st4->st_fstype, "unknown");
 130 }
 131
 132
 133 static void
 134 bsd_to_svr4_stat64(st, st4)
 135         struct stat             *st;
 136         struct svr4_stat64      *st4;
 137 {
 138         memset(st4, 0, sizeof(*st4));
 139         st4->st_dev = bsd_to_svr4_dev_t(st->st_dev);
 140         st4->st_ino = st->st_ino;
 141         st4->st_mode = BSD_TO_SVR4_MODE(st->st_mode);
 142         st4->st_nlink = st->st_nlink;
 143         st4->st_uid = st->st_uid;
 144         st4->st_gid = st->st_gid;
 145         st4->st_rdev = bsd_to_svr4_dev_t(st->st_rdev);
 146         st4->st_size = st->st_size;
 147         st4->st_atim = st->st_atimespec;
 148         st4->st_mtim = st->st_mtimespec;
 149         st4->st_ctim = st->st_ctimespec;
 150         st4->st_blksize = st->st_blksize;
 151         st4->st_blocks = st->st_blocks;
 152         strcpy(st4->st_fstype, "unknown");
 153 }
 154
 155 int
 156 svr4_sys_stat(p, uap)
 157         struct proc *p;
 158         struct svr4_sys_stat_args *uap;
 159 {
 160         struct stat             st;
 161         struct svr4_stat        svr4_st;
 162         struct stat_args        cup;
 163         int                     error;
 164         caddr_t sg = stackgap_init();
 165
 166         CHECKALTEXIST(p, &sg, SCARG(uap, path));
 167
 168         SCARG(&cup, path) = SCARG(uap, path);
 169         SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(struct stat));
 170
 171
 172         if ((error = stat(p, &cup)) != 0)
 173                 return error;
 174
 175         if ((error = copyin(SCARG(&cup, ub), &st, sizeof st)) != 0)
 176                 return error;
 177
 178         bsd_to_svr4_stat(&st, &svr4_st);
 179
 180         if (S_ISSOCK(st.st_mode))
 181                 (void) svr4_add_socket(p, SCARG(uap, path), &st);
 182
 183         if ((error = copyout(&svr4_st, SCARG(uap, ub), sizeof svr4_st)) != 0)
 184                 return error;
 185
 186         return 0;
 187 }
 188
 189
 190 int
 191 svr4_sys_lstat(p, uap)
 192         register struct proc *p;
 193         struct svr4_sys_lstat_args *uap;
 194 {
 195         struct stat             st;
 196         struct svr4_stat        svr4_st;
 197         struct lstat_args       cup;
 198         int                     error;
 199         caddr_t                 sg = stackgap_init();
 200
 201         CHECKALTEXIST(p, &sg, SCARG(uap, path));
 202
 203         SCARG(&cup, path) = SCARG(uap, path);
 204         SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(struct stat));
 205
 206         if ((error = lstat(p, &cup)) != 0)
 207                 return error;
 208
 209         if ((error = copyin(SCARG(&cup, ub), &st, sizeof st)) != 0)
 210                 return error;
 211
 212         bsd_to_svr4_stat(&st, &svr4_st);
 213
 214         if (S_ISSOCK(st.st_mode))
 215                 (void) svr4_add_socket(p, SCARG(uap, path), &st);
 216
 217         if ((error = copyout(&svr4_st, SCARG(uap, ub), sizeof svr4_st)) != 0)
 218                 return error;
 219
 220         return 0;
 221 }
 222
 223
 224 int
 225 svr4_sys_fstat(p, uap)
 226         register struct proc *p;
 227         struct svr4_sys_fstat_args *uap;
 228 {
 229         struct stat             st;
 230         struct svr4_stat        svr4_st;
 231         struct fstat_args       cup;
 232         int                     error;
 233         caddr_t                 sg = stackgap_init();
 234
 235         SCARG(&cup, fd) = SCARG(uap, fd);
 236         SCARG(&cup, sb) = stackgap_alloc(&sg, sizeof(struct stat));
 237
 238         if ((error = fstat(p, &cup)) != 0)
 239                 return error;
 240
 241         if ((error = copyin(SCARG(&cup, sb), &st, sizeof st)) != 0)
 242                 return error;
 243
 244         bsd_to_svr4_stat(&st, &svr4_st);
 245
 246         if ((error = copyout(&svr4_st, SCARG(uap, sb), sizeof svr4_st)) != 0)
 247                 return error;
 248
 249         return 0;
 250 }
 251
 252
 253 int
 254 svr4_sys_xstat(p, uap)
 255         register struct proc *p;
 256         struct svr4_sys_xstat_args *uap;
 257 {
 258         struct stat             st;
 259         struct svr4_xstat       svr4_st;
 260         struct stat_args        cup;
 261         int                     error;
 262
 263         caddr_t sg = stackgap_init();
 264         CHECKALTEXIST(p, &sg, SCARG(uap, path));
 265
 266         SCARG(&cup, path) = SCARG(uap, path);
 267         SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(struct stat));
 268
 269         if ((error = stat(p, &cup)) != 0)
 270                 return error;
 271
 272         if ((error = copyin(SCARG(&cup, ub), &st, sizeof st)) != 0)
 273                 return error;
 274
 275         bsd_to_svr4_xstat(&st, &svr4_st);
 276
 277 #if defined(SOCKET_NOTYET)
 278         if (S_ISSOCK(st.st_mode))
 279                 (void) svr4_add_socket(p, SCARG(uap, path), &st);
 280 #endif
 281
 282         if ((error = copyout(&svr4_st, SCARG(uap, ub), sizeof svr4_st)) != 0)
 283                 return error;
 284
 285         return 0;
 286 }
 287
 288 int
 289 svr4_sys_lxstat(p, uap)
 290         register struct proc *p;
 291         struct svr4_sys_lxstat_args *uap;
 292 {
 293         struct stat             st;
 294         struct svr4_xstat       svr4_st;
 295         struct lstat_args       cup;
 296         int                     error;
 297         caddr_t sg = stackgap_init();
 298         CHECKALTEXIST(p, &sg, SCARG(uap, path));
 299
 300         SCARG(&cup, path) = SCARG(uap, path);
 301         SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(struct stat));
 302
 303         if ((error = lstat(p, &cup)) != 0)
 304                 return error;
 305
 306         if ((error = copyin(SCARG(&cup, ub), &st, sizeof st)) != 0)
 307                 return error;
 308
 309         bsd_to_svr4_xstat(&st, &svr4_st);
 310
 311 #if defined(SOCKET_NOTYET)
 312         if (S_ISSOCK(st.st_mode))
 313                 (void) svr4_add_socket(p, SCARG(uap, path), &st);
 314 #endif
 315         if ((error = copyout(&svr4_st, SCARG(uap, ub), sizeof svr4_st)) != 0)
 316                 return error;
 317
 318         return 0;
 319 }
 320
 321
 322 int
 323 svr4_sys_fxstat(p, uap)
 324         register struct proc *p;
 325         struct svr4_sys_fxstat_args *uap;
 326 {
 327         struct stat             st;
 328         struct svr4_xstat       svr4_st;
 329         struct fstat_args       cup;
 330         int                     error;
 331
 332         caddr_t sg = stackgap_init();
 333
 334         SCARG(&cup, fd) = SCARG(uap, fd);
 335         SCARG(&cup, sb) = stackgap_alloc(&sg, sizeof(struct stat));
 336
 337         if ((error = fstat(p, &cup)) != 0)
 338                 return error;
 339
 340         if ((error = copyin(SCARG(&cup, sb), &st, sizeof st)) != 0)
 341                 return error;
 342
 343         bsd_to_svr4_xstat(&st, &svr4_st);
 344
 345         if ((error = copyout(&svr4_st, SCARG(uap, sb), sizeof svr4_st)) != 0)
 346                 return error;
 347
 348         return 0;
 349 }
 350
 351 int
 352 svr4_sys_stat64(p, uap)
 353         register struct proc *p;
 354         struct svr4_sys_stat64_args *uap;
 355 {
 356         struct stat             st;
 357         struct svr4_stat64      svr4_st;
 358         struct stat_args        cup;
 359         int                     error;
 360         caddr_t                 sg = stackgap_init();
 361
 362         CHECKALTEXIST(p, &sg, SCARG(uap, path));
 363
 364         SCARG(&cup, path) = SCARG(uap, path);
 365         SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(struct stat));
 366
 367         if ((error = stat(p, &cup)) != 0)
 368                 return error;
 369
 370         if ((error = copyin(SCARG(&cup, ub), &st, sizeof st)) != 0)
 371                 return error;
 372
 373         bsd_to_svr4_stat64(&st, &svr4_st);
 374
 375         if (S_ISSOCK(st.st_mode))
 376                 (void) svr4_add_socket(p, SCARG(uap, path), &st);
 377
 378         if ((error = copyout(&svr4_st, SCARG(uap, sb), sizeof svr4_st)) != 0)
 379                 return error;
 380
 381         return 0;
 382 }
 383
 384
 385 int
 386 svr4_sys_lstat64(p, uap)
 387         register struct proc *p;
 388         struct svr4_sys_lstat64_args *uap;
 389 {
 390         struct stat             st;
 391         struct svr4_stat64      svr4_st;
 392         struct stat_args        cup;
 393         int                     error;
 394         caddr_t                 sg = stackgap_init();
 395
 396         CHECKALTEXIST(p, &sg, (char *) SCARG(uap, path));
 397
 398         SCARG(&cup, path) = SCARG(uap, path);
 399         SCARG(&cup, ub) = stackgap_alloc(&sg, sizeof(struct stat));
 400
 401         if ((error = lstat(p, (struct lstat_args *)&cup)) != 0)
 402                 return error;
 403
 404         if ((error = copyin(SCARG(&cup, ub), &st, sizeof st)) != 0)
 405                 return error;
 406
 407         bsd_to_svr4_stat64(&st, &svr4_st);
 408
 409         if (S_ISSOCK(st.st_mode))
 410                 (void) svr4_add_socket(p, SCARG(uap, path), &st);
 411
 412         if ((error = copyout(&svr4_st, SCARG(uap, sb), sizeof svr4_st)) != 0)
 413                 return error;
 414
 415         return 0;
 416 }
 417
 418
 419 int
 420 svr4_sys_fstat64(p, uap)
 421         register struct proc *p;
 422         struct svr4_sys_fstat64_args *uap;
 423 {
 424         struct stat             st;
 425         struct svr4_stat64      svr4_st;
 426         struct fstat_args       cup;
 427         int                     error;
 428         caddr_t sg = stackgap_init();
 429
 430         SCARG(&cup, fd) = SCARG(uap, fd);
 431         SCARG(&cup, sb) = stackgap_alloc(&sg, sizeof(struct stat));
 432
 433         if ((error = fstat(p, &cup)) != 0)
 434                 return error;
 435
 436         if ((error = copyin(SCARG(&cup, sb), &st, sizeof st)) != 0)
 437                 return error;
 438
 439         bsd_to_svr4_stat64(&st, &svr4_st);
 440
 441         if ((error = copyout(&svr4_st, SCARG(uap, sb), sizeof svr4_st)) != 0)
 442                 return error;
 443
 444         return 0;
 445 }
 446
 447
 448 int
 449 svr4_ustat(p, uap)
 450         register struct proc *p;
 451         struct svr4_ustat_args *uap;
 452 {
 453         struct svr4_ustat       us;
 454         int                     error;
 455
 456         memset(&us, 0, sizeof us);
 457
 458         /*
 459          * XXX: should set f_tfree and f_tinode at least
 460          * How do we translate dev -> fstat? (and then to svr4_ustat)
 461          */
 462         if ((error = copyout(&us, SCARG(uap, name), sizeof us)) != 0)
 463                 return (error);
 464
 465         return 0;
 466 }
 467
 468 /*extern char ostype[], hostname[], osrelease[], version[], machine[];*/
 469
 470 int
 471 svr4_sys_uname(p, uap)
 472         register struct proc *p;
 473         struct svr4_sys_uname_args *uap;
 474 {
 475         struct svr4_utsname     sut;
 476
 477
 478         memset(&sut, 0, sizeof(sut));
 479
 480         strncpy(sut.sysname, ostype, sizeof(sut.sysname));
 481         sut.sysname[sizeof(sut.sysname) - 1] = '\0';
 482
 483         strncpy(sut.nodename, hostname, sizeof(sut.nodename));
 484         sut.nodename[sizeof(sut.nodename) - 1] = '\0';
 485
 486         strncpy(sut.release, osrelease, sizeof(sut.release));
 487         sut.release[sizeof(sut.release) - 1] = '\0';
 488
 489         strncpy(sut.version, version, sizeof(sut.version));
 490         sut.version[sizeof(sut.version) - 1] = '\0';
 491
 492         strncpy(sut.machine, machine, sizeof(sut.machine));
 493         sut.machine[sizeof(sut.machine) - 1] = '\0';
 494
 495         return copyout((caddr_t) &sut, (caddr_t) SCARG(uap, name),
 496                        sizeof(struct svr4_utsname));
 497 }
 498
 499 int
 500 svr4_sys_systeminfo(p, uap)
 501         struct proc *p;
 502         struct svr4_sys_systeminfo_args *uap;
 503 {
 504         char            *str = NULL;
 505         int             error = 0;
 506         register_t      *retval = p->p_retval;
 507         size_t          len = 0;
 508         char            buf[1];   /* XXX NetBSD uses 256, but that seems
 509                                      like awfully excessive kstack usage
 510                                      for an empty string... */
 511         u_int           rlen = SCARG(uap, len);
 512
 513         switch (SCARG(uap, what)) {
 514         case SVR4_SI_SYSNAME:
 515                 str = ostype;
 516                 break;
 517
 518         case SVR4_SI_HOSTNAME:
 519                 str = hostname;
 520                 break;
 521
 522         case SVR4_SI_RELEASE:
 523                 str = osrelease;
 524                 break;
 525
 526         case SVR4_SI_VERSION:
 527                 str = version;
 528                 break;
 529
 530         case SVR4_SI_MACHINE:
 531                 str = machine;
 532                 break;
 533
 534         case SVR4_SI_ARCHITECTURE:
 535                 str = machine;
 536                 break;
 537
 538         case SVR4_SI_HW_SERIAL:
 539                 str = "0";
 540                 break;
 541
 542         case SVR4_SI_HW_PROVIDER:
 543                 str = ostype;
 544                 break;
 545
 546         case SVR4_SI_SRPC_DOMAIN:
 547                 str = domainname;
 548                 break;
 549
 550         case SVR4_SI_PLATFORM:
 551 #ifdef __i386__
 552                 str = "i86pc";
 553 #else
 554                 str = "unknown";
 555 #endif
 556                 break;
 557
 558         case SVR4_SI_KERB_REALM:
 559                 str = "unsupported";
 560                 break;
 561 #if defined(WHY_DOES_AN_EMULATOR_WANT_TO_SET_HOSTNAMES)
 562         case SVR4_SI_SET_HOSTNAME:
 563                 if ((error = suser(p)) != 0)
 564                         return error;
 565                 name = KERN_HOSTNAME;
 566                 return kern_sysctl(&name, 1, 0, 0, SCARG(uap, buf), rlen, p);
 567
 568         case SVR4_SI_SET_SRPC_DOMAIN:
 569                 if ((error = suser(p)) != 0)
 570                         return error;
 571                 name = KERN_NISDOMAINNAME;
 572                 return kern_sysctl(&name, 1, 0, 0, SCARG(uap, buf), rlen, p);
 573 #else
 574         case SVR4_SI_SET_HOSTNAME:
 575         case SVR4_SI_SET_SRPC_DOMAIN:
 576                 /* FALLTHROUGH */
 577 #endif
 578         case SVR4_SI_SET_KERB_REALM:
 579                 return 0;
 580
 581         default:
 582                 DPRINTF(("Bad systeminfo command %d\n", SCARG(uap, what)));
 583                 return ENOSYS;
 584         }
 585
 586         if (str) {
 587                 len = strlen(str) + 1;
 588                 if (len > rlen)
 589                         len = rlen;
 590
 591                 if (SCARG(uap, buf)) {
 592                         error = copyout(str, SCARG(uap, buf), len);
 593                         if (error)
 594                                 return error;
 595                         /* make sure we are NULL terminated */
 596                         buf[0] = '\0';
 597                         error = copyout(buf, &(SCARG(uap, buf)[len - 1]), 1);
 598                 }
 599                 else
 600                         error = 0;
 601         }
 602         /* XXX NetBSD has hostname setting stuff here.  Why would an emulator
 603            want to do that? */
 604
 605         *retval = len;
 606         return error;
 607 }
 608
 609 int
 610 svr4_sys_utssys(p, uap)
 611         register struct proc *p;
 612         struct svr4_sys_utssys_args *uap;
 613 {
 614         switch (SCARG(uap, sel)) {
 615         case 0:         /* uname(2)  */
 616                 {
 617                         struct svr4_sys_uname_args ua;
 618                         SCARG(&ua, name) = SCARG(uap, a1);
 619                         return svr4_sys_uname(p, &ua);
 620                 }
 621
 622         case 2:         /* ustat(2)  */
 623                 {
 624                         struct svr4_ustat_args ua;
 625                         SCARG(&ua, dev) = (svr4_dev_t) SCARG(uap, a2);
 626                         SCARG(&ua, name) = SCARG(uap, a1);
 627                         return svr4_ustat(p, &ua);
 628                 }
 629
 630         case 3:         /* fusers(2) */
 631                 return ENOSYS;
 632
 633         default:
 634                 return ENOSYS;
 635         }
 636         return ENOSYS;
 637 }
 638
 639
 640 int
 641 svr4_sys_utime(p, uap)
 642         register struct proc *p;
 643         struct svr4_sys_utime_args *uap;
 644 {
 645         struct svr4_utimbuf ub;
 646         struct timeval tbuf[2];
 647         struct utimes_args ap;
 648         int error;
 649         caddr_t sg = stackgap_init();
 650         void *ttp;
 651
 652         CHECKALTEXIST(p, &sg, SCARG(uap, path));
 653         SCARG(&ap, path) = SCARG(uap, path);
 654         if (SCARG(uap, ubuf) != NULL) {
 655                 if ((error = copyin(SCARG(uap, ubuf), &ub, sizeof(ub))) != 0)
 656                         return error;
 657                 tbuf[0].tv_sec = ub.actime;
 658                 tbuf[0].tv_usec = 0;
 659                 tbuf[1].tv_sec = ub.modtime;
 660                 tbuf[1].tv_usec = 0;
 661                 ttp = stackgap_alloc(&sg, sizeof(tbuf));
 662                 error = copyout(tbuf, ttp, sizeof(tbuf));
 663                 if (error)
 664                         return error;
 665                 SCARG(&ap, tptr) = ttp;
 666         }
 667         else
 668                 SCARG(&ap, tptr) = NULL;
 669         return utimes(p, &ap);
 670 }
 671
 672
 673 int
 674 svr4_sys_utimes(p, uap)
 675         register struct proc *p;
 676         struct svr4_sys_utimes_args *uap;
 677 {
 678         caddr_t sg = stackgap_init();
 679         CHECKALTEXIST(p, &sg, SCARG(uap, path));
 680         return utimes(p, (struct utimes_args *)uap);
 681 }
 682
 683 static int
 684 svr4_to_bsd_pathconf(name)
 685         int name;
 686 {
 687         switch (name) {
 688         case SVR4_PC_LINK_MAX:
 689                 return _PC_LINK_MAX;
 690
 691         case SVR4_PC_MAX_CANON:
 692                 return _PC_MAX_CANON;
 693
 694         case SVR4_PC_MAX_INPUT:
 695                 return _PC_MAX_INPUT;
 696
 697         case SVR4_PC_NAME_MAX:
 698                 return _PC_NAME_MAX;
 699
 700         case SVR4_PC_PATH_MAX:
 701                 return _PC_PATH_MAX;
 702
 703         case SVR4_PC_PIPE_BUF:
 704                 return _PC_PIPE_BUF;
 705
 706         case SVR4_PC_NO_TRUNC:
 707                 return _PC_NO_TRUNC;
 708
 709         case SVR4_PC_VDISABLE:
 710                 return _PC_VDISABLE;
 711
 712         case SVR4_PC_CHOWN_RESTRICTED:
 713                 return _PC_CHOWN_RESTRICTED;
 714         case SVR4_PC_SYNC_IO:
 715 #if defined(_PC_SYNC_IO)
 716                 return _PC_SYNC_IO;
 717 #else
 718                 return 0;
 719 #endif
 720         case SVR4_PC_ASYNC_IO:
 721         case SVR4_PC_PRIO_IO:
 722                 /* Not supported */
 723                 return 0;
 724
 725         default:
 726                 /* Invalid */
 727                 return -1;
 728         }
 729 }
 730
 731
 732 int
 733 svr4_sys_pathconf(p, uap)
 734         register struct proc *p;
 735         struct svr4_sys_pathconf_args *uap;
 736 {
 737         caddr_t         sg = stackgap_init();
 738         register_t      *retval = p->p_retval;
 739
 740         CHECKALTEXIST(p, &sg, SCARG(uap, path));
 741
 742         SCARG(uap, name) = svr4_to_bsd_pathconf(SCARG(uap, name));
 743
 744         switch (SCARG(uap, name)) {
 745         case -1:
 746                 *retval = -1;
 747                 return EINVAL;
 748         case 0:
 749                 *retval = 0;
 750                 return 0;
 751         default:
 752                 return pathconf(p, (struct pathconf_args *)uap);
 753         }
 754 }
 755
 756
 757 int
 758 svr4_sys_fpathconf(p, uap)
 759         register struct proc *p;
 760         struct svr4_sys_fpathconf_args *uap;
 761 {
 762         register_t      *retval = p->p_retval;
 763
 764         SCARG(uap, name) = svr4_to_bsd_pathconf(SCARG(uap, name));
 765
 766         switch (SCARG(uap, name)) {
 767         case -1:
 768                 *retval = -1;
 769                 return EINVAL;
 770         case 0:
 771                 *retval = 0;
 772                 return 0;
 773         default:
 774                 return fpathconf(p, (struct fpathconf_args *)uap);
 775         }
 776 }