root/compat/hpux/hpux_file.c

DEFINITIONS

1. hpux_sys_creat
2. hpux_sys_open
3. hpux_sys_fcntl
4. hpux_sys_fstat
5. hpux_sys_stat
6. hpux_sys_lstat
7. hpux_stat1
8. hpux_sys_fstat_6x
9. hpux_sys_stat_6x
10. bsd_to_hpux_ostat
11. bsd_to_hpux_stat
12. hpux_sys_access
13. hpux_sys_unlink
14. hpux_sys_chdir
15. hpux_sys_mknod
16. hpux_sys_chmod
17. hpux_sys_chown
18. hpux_sys_rename
19. hpux_sys_mkdir
20. hpux_sys_rmdir
21. hpux_sys_symlink
22. hpux_sys_readlink
23. hpux_sys_truncate

    1 /*      $OpenBSD: hpux_file.c,v 1.18 2007/03/15 10:22:30 art Exp $      */
    2 /*      $NetBSD: hpux_file.c,v 1.5 1997/04/27 21:40:48 thorpej Exp $    */
    4 /*
    5  * Copyright (c) 1995, 1997 Jason R. Thorpe.  All rights reserved.
    6  * Copyright (c) 1988 University of Utah.
    7  * Copyright (c) 1990, 1993
    8  *      The Regents of the University of California.  All rights reserved.
    9  *
   10  * This code is derived from software contributed to Berkeley by
   11  * the Systems Programming Group of the University of Utah Computer
   12  * Science Department.
   13  *
   14  * Redistribution and use in source and binary forms, with or without
   15  * modification, are permitted provided that the following conditions
   16  * are met:
   17  * 1. Redistributions of source code must retain the above copyright
   18  *    notice, this list of conditions and the following disclaimer.
   19  * 2. Redistributions in binary form must reproduce the above copyright
   20  *    notice, this list of conditions and the following disclaimer in the
   21  *    documentation and/or other materials provided with the distribution.
   22  * 3. Neither the name of the University nor the names of its contributors
   23  *    may be used to endorse or promote products derived from this software
   24  *    without specific prior written permission.
   25  *
   26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   36  * SUCH DAMAGE.
   37  *
   38  * from: Utah $Hdr: hpux_compat.c 1.64 93/08/05$
   39  *
   40  *      @(#)hpux_compat.c       8.4 (Berkeley) 2/13/94
   41  */
   43 /*
   44  * File-related routines for HP-UX binary compatibility.  Partially
   45  * modeled after sys/compat/linux/linux_file.c
   46  */
   48 #include <sys/param.h>
   49 #include <sys/systm.h>
   50 #include <sys/signalvar.h>
   51 #include <sys/kernel.h>
   52 #include <sys/filedesc.h>
   53 #include <sys/proc.h>
   54 #include <sys/buf.h>
   55 #include <sys/wait.h>
   56 #include <sys/file.h>
   57 #include <sys/namei.h>
   58 #include <sys/vnode.h>
   59 #include <sys/ioctl.h>
   60 #include <sys/ptrace.h>
   61 #include <sys/stat.h>
   62 #include <sys/syslog.h>
   63 #include <sys/malloc.h>
   64 #include <sys/mount.h>
   65 #include <sys/ipc.h>
   66 #include <sys/user.h>
   67 #include <sys/mman.h>
   69 #include <machine/cpu.h>
   70 #include <machine/reg.h>
   71 #include <machine/psl.h>
   72 #include <machine/vmparam.h>
   74 #include <sys/syscallargs.h>
   76 #include <compat/hpux/hpux.h>
   77 #include <compat/hpux/hpux_util.h>
   78 #include <compat/hpux/hpux_termio.h>
   79 #include <compat/hpux/hpux_syscall.h>
   80 #include <compat/hpux/hpux_syscallargs.h>
   82 #include <machine/hpux_machdep.h>
   84 int     hpux_stat1(struct proc *, void *, register_t *, int);
   85 void    bsd_to_hpux_stat(struct stat *, struct hpux_stat *);
   86 void    bsd_to_hpux_ostat(struct stat *, struct hpux_ostat *);
   88 /*
   89  * HP-UX creat(2) system call.
   90  *
   91  * Just call open(2) with the TRUNC, CREAT and WRONLY flags.
   92  */
   93 int
hpux_sys_creat(p, v, retval)
   95         struct proc *p;
   96         void *v;
register_t *retval;
   98 {
   99         struct hpux_sys_creat_args /* {
  100                 syscallarg(char *) path;
  101                 syscallarg(int) mode;
  102         } */ *uap = v;
  104         struct sys_open_args oa;
caddr_t sg;
sg = stackgap_init(p->p_emul);
HPUX_CHECK_ALT_CREAT(p, &sg, SCARG(uap, path));
SCARG(&oa, path) = SCARG(uap, path);
SCARG(&oa, flags) = O_CREAT | O_TRUNC | O_WRONLY;
SCARG(&oa, mode) = SCARG(uap, mode);
  114         return sys_open(p, &oa, retval);
  115 }
  117 /*
  118  * HP-UX open(2) system call.
  119  *
  120  * We need to remap some of the bits in the mode mask:
  121  *
  122  *      - O_CREAT, O_TRUNC, and O_EXCL must me remapped.
  123  *      - O_NONBLOCK is remapped and remembered.
  124  *      - O_FNDELAY is remembered.
  125  *      - O_SYNCIO is removed entirely.
  126  */
  127 int
hpux_sys_open(p, v, retval)
  129         struct proc *p;
  130         void *v;
register_t *retval;
  132 {
  133         struct hpux_sys_open_args /* {
  134                 syscallarg(char *) path;
  135                 syscallarg(int) flags;
  136                 syscallarg(int) mode;
  137         } */ *uap = v;
  138         struct sys_open_args oa;
  139         int flags, nflags, error;
caddr_t sg;
sg = stackgap_init(p->p_emul);
  144         /*
  145          * Deal with the mode flags first, since they will affect
  146          * how we check for the alternate path.
  147          */
flags = SCARG(uap, flags);
nflags =
flags & ~(HPUXNONBLOCK|HPUXFSYNCIO|HPUXFEXCL|HPUXFTRUNC|HPUXFCREAT);
  151         if (flags & HPUXFCREAT) {
  152                 /*
  153                  * Simulate the pre-NFS behavior that opening a
  154                  * file for READ+CREATE ignores the CREATE (unless
  155                  * EXCL is set in which case we will return the
  156                  * proper error).
  157                  */
  158                 if ((flags & HPUXFEXCL) || (FFLAGS(flags) & FWRITE))
nflags |= O_CREAT;
  160         }
  161         if (flags & HPUXFTRUNC)
nflags |= O_TRUNC;
  163         if (flags & HPUXFEXCL)
nflags |= O_EXCL;
  165         if (flags & HPUXNONBLOCK)
nflags |= O_NDELAY;
  168         /*
  169          * Do the alternate pathname check.
  170          */
  171         if (SCARG(&oa, flags) & O_CREAT)
HPUX_CHECK_ALT_CREAT(p, &sg, SCARG(uap, path));
  173         else
HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
  176         /*
  177          * Fill in the new arguments and call the NetBSD open(2).
  178          */
SCARG(&oa, path) = SCARG(uap, path);
SCARG(&oa, flags) = nflags;
SCARG(&oa, mode) =  SCARG(uap, mode);
error = sys_open(p, &oa, retval);
  185         /*
  186          * Record non-blocking mode for fcntl, read, write, etc.
  187          */
  188         if ((error == 0) && (nflags & O_NDELAY))
p->p_fd->fd_ofileflags[*retval] |=
  190                     (flags & HPUXNONBLOCK) ?
HPUX_UF_NONBLOCK_ON : HPUX_UF_FNDELAY_ON;
  193         return (error);
  194 }
  196 /*
  197  * HP-UX fcntl(2) system call.
  198  */
  199 int
hpux_sys_fcntl(p, v, retval)
  201         struct proc *p;
  202         void *v;
register_t *retval;
  204 {
  205         struct hpux_sys_fcntl_args /* {
  206                 syscallarg(int) fd;
  207                 syscallarg(int) cmd;
  208                 syscallarg(int) arg;
  209         } */ *uap = v;
  210         int arg, mode, error, flg = F_POSIX;
  211         struct file *fp;
  212         char *pop;
  213         struct hpux_flock hfl;
  214         struct flock fl;
  215         struct vnode *vp;
  216         struct sys_fcntl_args fa;
  217         struct filedesc *fdp = p->p_fd;
  219         if ((fp = fd_getfile(fdp, SCARG(uap, fd))) == NULL)
  220                 return (EBADF);
FREF(fp);
pop = &p->p_fd->fd_ofileflags[SCARG(uap, fd)];
arg = SCARG(uap, arg);
  226         switch (SCARG(uap, cmd)) {
  227         case F_SETFL:
  228                 if (arg & HPUXNONBLOCK)
  229                         *pop |= HPUX_UF_NONBLOCK_ON;
  230                 else
  231                         *pop &= ~HPUX_UF_NONBLOCK_ON;
  233                 if (arg & HPUXNDELAY)
  234                         *pop |= HPUX_UF_FNDELAY_ON;
  235                 else
  236                         *pop &= ~HPUX_UF_FNDELAY_ON;
  238                 if (*pop & (HPUX_UF_NONBLOCK_ON|HPUX_UF_FNDELAY_ON|HPUX_UF_FIONBIO_ON))
arg |= FNONBLOCK;
  240                 else
arg &= ~FNONBLOCK;
arg &= ~(HPUXNONBLOCK|HPUXFSYNCIO|HPUXFREMOTE);
  244                 break;
  246         case F_GETFL:
  247         case F_DUPFD:
  248         case F_GETFD:
  249         case F_SETFD:
  250                 break;
  252         case HPUXF_SETLKW:
flg |= F_WAIT;
  254                 /* Fall into F_SETLK */
  256         case HPUXF_SETLK:
  257                 if (fp->f_type != DTYPE_VNODE) {
error = EBADF;
  259                         goto out;
  260                 }
vp = (struct vnode *)fp->f_data;
  264                 /* Copy in the lock structure */
error = copyin((caddr_t)SCARG(uap, arg), (caddr_t)&hfl,
  266                     sizeof (hfl));
  267                 if (error)
  268                         goto out;
fl.l_start = hfl.hl_start;
fl.l_len = hfl.hl_len;
fl.l_pid = hfl.hl_pid;
fl.l_type = hfl.hl_type;
fl.l_whence = hfl.hl_whence;
  275                 if (fl.l_whence == SEEK_CUR)
fl.l_start += fp->f_offset;
  278                 switch (fl.l_type) {
  279                 case F_RDLCK:
  280                         if ((fp->f_flag & FREAD) == 0) {
error = EBADF;
  282                                 goto out;
  283                         }
atomic_setbits_int(&p->p_flag, P_ADVLOCK);
error = VOP_ADVLOCK(vp, (caddr_t)p, F_SETLK, &fl, flg);
  287                         goto out;
  289                 case F_WRLCK:
  290                         if ((fp->f_flag & FWRITE) == 0) {
error = EBADF;
  292                                 goto out;
  293                         }
atomic_setbits_int(&p->p_flag, P_ADVLOCK);
error = VOP_ADVLOCK(vp, (caddr_t)p, F_SETLK, &fl, flg);
  296                         goto out;
  298                 case F_UNLCK:
error = VOP_ADVLOCK(vp, (caddr_t)p, F_UNLCK, &fl,
F_POSIX);
  301                         goto out;
  303                 default:
error = EINVAL;
  305                         goto out;
  306                 }
  307                 /* NOTREACHED */
  309         case F_GETLK:
  310                 if (fp->f_type != DTYPE_VNODE) {
error = EBADF;
  312                         goto out;
  313                 }
vp = (struct vnode *)fp->f_data;
  317                 /* Copy in the lock structure */
error = copyin((caddr_t)SCARG(uap, arg), (caddr_t)&hfl,
  319                     sizeof (hfl));
  320                 if (error)
  321                         goto out;
fl.l_start = hfl.hl_start;
fl.l_len = hfl.hl_len;
fl.l_pid = hfl.hl_pid;
fl.l_type = hfl.hl_type;
fl.l_whence = hfl.hl_whence;
  328                 if (fl.l_whence == SEEK_CUR)
fl.l_start += fp->f_offset;
  331                 if ((error =
VOP_ADVLOCK(vp, (caddr_t)p, F_GETLK, &fl, F_POSIX)))
  333                         goto out;
hfl.hl_start = fl.l_start;
hfl.hl_len = fl.l_len;
hfl.hl_pid = fl.l_pid;
hfl.hl_type = fl.l_type;
hfl.hl_whence = fl.l_whence;
error = copyout((caddr_t)&hfl, (caddr_t)SCARG(uap, arg),
  341                     sizeof (hfl));
  342                 goto out;
  344         default:
error = EINVAL;
  346                 goto out;
  347         }
  349         /*
  350          * Pass whatever's left on to the NetBSD fcntl(2).
  351          */
SCARG(&fa, fd) = SCARG(uap, fd);
SCARG(&fa, cmd) = SCARG(uap, cmd);
SCARG(&fa, arg) = (void *)arg;
error = sys_fcntl(p, &fa, retval);
  358         if ((error == 0) && (SCARG(&fa, cmd) == F_GETFL)) {
mode = *retval;
  360                 *retval &= ~(O_CREAT|O_TRUNC|O_EXCL);
  361                 if (mode & FNONBLOCK) {
  362                         if (*pop & HPUX_UF_NONBLOCK_ON)
  363                                 *retval |= HPUXNONBLOCK;
  365                         if ((*pop & HPUX_UF_FNDELAY_ON) == 0)
  366                                 *retval &= ~HPUXNDELAY;
  367                 }
  368                 if (mode & O_CREAT)
  369                         *retval |= HPUXFCREAT;
  371                 if (mode & O_TRUNC)
  372                         *retval |= HPUXFTRUNC;
  374                 if (mode & O_EXCL)
  375                         *retval |= HPUXFEXCL;
  376         }
out:
FRELE(fp);
  379         return (error);
  380 }
  382 /*
  383  * HP-UX fstat(2) system call.
  384  */
  385 int
hpux_sys_fstat(p, v, retval)
  387         struct proc *p;
  388         void *v;
register_t *retval;
  390 {
  391         struct hpux_sys_fstat_args /* {
  392                 syscallarg(int) fd;
  393                 syscallarg(struct hpux_stat *) sb;
  394         } */ *uap = v;
  395         struct sys_fstat_args fsa;
  396         struct hpux_stat tmphst;
  397         struct stat *st, tmpst;
caddr_t sg;
  399         int error;
sg = stackgap_init(p->p_emul);
st = stackgap_alloc(&sg, sizeof (struct stat));
SCARG(&fsa, fd) = SCARG(uap, fd);
SCARG(&fsa, sb) = st;
  408         if ((error = sys_fstat(p, &fsa, retval)))
  409                 return (error);
  411         if ((error = copyin(st, &tmpst, sizeof(tmpst))))
  412                 return (error);
bsd_to_hpux_stat(&tmpst, &tmphst);
  416         return (copyout(&tmphst, SCARG(uap, sb), sizeof(struct hpux_stat)));
  417 }
  419 /*
  420  * HP-UX stat(2) system call.
  421  */
  422 int
hpux_sys_stat(p, v, retval)
  424         struct proc *p; 
  425         void *v;
register_t *retval;
  427 {
  429         return (hpux_stat1(p, v, retval, 0));
  430 }
  432 /*
  433  * HP-UX lstat(2) system call.
  434  */
  435 int
hpux_sys_lstat(p, v, retval)
  437         struct proc *p;
  438         void *v;
register_t *retval;
  440 {
  442         return (hpux_stat1(p, v, retval, 1));
  443 }
  445 /*
  446  * Do the meat of stat(2) and lstat(2).
  447  */
  448 int
hpux_stat1(p, v, retval, dolstat)
  450         struct proc *p;
  451         void *v;
register_t *retval;
  453         int dolstat;
  454 {
  455         struct hpux_sys_stat_args /* {
  456                 syscallarg(char *) path;
  457                 syscallarg(struct hpux_stat *) sb;
  458         } */ *uap = v;
  459         struct sys_stat_args sa;
  460         struct hpux_stat tmphst;
  461         struct stat *st, tmpst;
caddr_t sg;
  463         int error;
sg = stackgap_init(p->p_emul);
st = stackgap_alloc(&sg, sizeof (struct stat));
HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
SCARG(&sa, ub) = st;
SCARG(&sa, path) = SCARG(uap, path);
  473         if (dolstat)
error = sys_lstat(p, &sa, retval);
  475         else
error = sys_stat(p, &sa, retval);
  478         if (error)
  479                 return (error);
  481         if ((error = copyin(st, &tmpst, sizeof(tmpst))))
  482                 return (error);
bsd_to_hpux_stat(&tmpst, &tmphst);
  486         return (copyout(&tmphst, SCARG(uap, sb), sizeof(struct hpux_stat)));
  487 }
  489 #ifndef __hppa__
  490 /*
  491  * The old HP-UX fstat(2) system call.
  492  */
  493 int
hpux_sys_fstat_6x(p, v, retval)
  495         struct proc *p;
  496         void *v;
register_t *retval;
  498 {
  499         struct hpux_sys_fstat_6x_args /* {
  500                 syscallarg(int) fd;
  501                 syscallarg(struct hpux_ostat *) sb;
  502         } */ *uap = v;
  503         struct sys_fstat_args fsa;
  504         struct hpux_ostat tmphst;
  505         struct stat *st, tmpst;
caddr_t sg;
  507         int error;
sg = stackgap_init(p->p_emul);
st = stackgap_alloc(&sg, sizeof (struct stat));
SCARG(&fsa, fd) = SCARG(uap, fd);
SCARG(&fsa, sb) = st;
  516         if ((error = sys_fstat(p, &fsa, retval)))
  517                 return (error);
  519         if ((error = copyin(st, &tmpst, sizeof(tmpst))))
  520                 return (error);
bsd_to_hpux_ostat(&tmpst, &tmphst);
  524         return (copyout(&tmphst, SCARG(uap, sb), sizeof(struct hpux_ostat)));
  525 }
  527 /*
  528  * The old HP-UX stat(2) system call.
  529  */
  530 int
hpux_sys_stat_6x(p, v, retval)
  532         struct proc *p;
  533         void *v;
register_t *retval;
  535 {
  536         struct hpux_sys_stat_6x_args /* {
  537                 syscallarg(char *) path;
  538                 syscallarg(struct hpux_ostat *) sb;
  539         } */ *uap = v;
  540         struct sys_stat_args sa;
  541         struct hpux_ostat tmphst;
  542         struct stat *st, tmpst;
caddr_t sg;
  544         int error;
sg = stackgap_init(p->p_emul);
HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
st = stackgap_alloc(&sg, sizeof (struct stat));
SCARG(&sa, ub) = st;
SCARG(&sa, path) = SCARG(uap, path);
  554         if ((error = sys_stat(p, &sa, retval)))
  555                 return (error);
  557         if ((error = copyin(st, &tmpst, sizeof(tmpst))))
  558                 return (error);
bsd_to_hpux_ostat(&tmpst, &tmphst);
  562         return (copyout(&tmphst, SCARG(uap, sb), sizeof(struct hpux_ostat)));
  563 }
  565 /*
  566  * Convert a NetBSD stat structure to an old-style HP-UX stat structure.
  567  */
  568 void
bsd_to_hpux_ostat(sb, hsb)
  570         struct stat *sb;
  571         struct hpux_ostat *hsb;
  572 {
bzero(hsb, sizeof(struct hpux_ostat));
hsb->hst_dev = (u_short)sb->st_dev;
hsb->hst_ino = (u_short)sb->st_ino;
hsb->hst_mode = (u_short)sb->st_mode;
hsb->hst_nlink = (u_short)sb->st_nlink;
hsb->hst_uid = (u_short)sb->st_uid;
hsb->hst_gid = (u_short)sb->st_gid;
hsb->hst_rdev = (u_short)sb->st_rdev;
  582         if (sb->st_size < (off_t)(((off_t)1) << 32))
hsb->hst_size = (int)sb->st_size;
  584         else
hsb->hst_size = -2;
hsb->hst_atime = (int)sb->st_atime;
hsb->hst_mtime = (int)sb->st_mtime;
hsb->hst_ctime = (int)sb->st_ctime;
  589 }
  590 #endif
  592 /*
  593  * Convert a NetBSD stat structure to an HP-UX stat structure.
  594  */
  595 void
bsd_to_hpux_stat(sb, hsb)
  597         struct stat *sb;
  598         struct hpux_stat *hsb;
  599 {
bzero((caddr_t)hsb, sizeof(struct hpux_stat));
hsb->hst_dev = (long)sb->st_dev;
hsb->hst_ino = (u_long)sb->st_ino;
hsb->hst_mode = (u_short)sb->st_mode;
hsb->hst_nlink = (u_short)sb->st_nlink;
hsb->hst_uid = (u_long)sb->st_uid;
hsb->hst_gid = (u_long)sb->st_gid;
hsb->hst_rdev = (long)bsdtohpuxdev(sb->st_rdev);
  609         /*
  610          * XXX Let's just hope that the old binary doesn't lose.
  611          */
hsb->hst_old_uid = (u_short)sb->st_uid;
hsb->hst_old_gid = (u_short)sb->st_gid;
  615         if (sb->st_size < (off_t)(((off_t)1) << 32))
hsb->hst_size = (long)sb->st_size;
  617         else
hsb->hst_size = -2;
hsb->hst_atime = (long)sb->st_atime;
hsb->hst_mtime = (long)sb->st_mtime;
hsb->hst_ctime = (long)sb->st_ctime;
hsb->hst_blksize = (long)sb->st_blksize;
hsb->hst_blocks = (long)sb->st_blocks;
  624 }
  626 /*
  627  * HP-UX access(2) system call.
  628  */
  629 int
hpux_sys_access(p, v, retval)
  631         struct proc *p;
  632         void *v;
register_t *retval;
  634 {
  635         struct hpux_sys_access_args /* {
  636                 syscallarg(char *) path;
  637                 syscallarg(int) flags;
  638         } */ *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
  643         return (sys_access(p, uap, retval));
  644 }
  646 /*
  647  * HP-UX unlink(2) system call.
  648  */
  649 int
hpux_sys_unlink(p, v, retval)
  651         struct proc *p;
  652         void *v;
register_t *retval;
  654 {
  655         struct hpux_sys_unlink_args /* {
  656                 syscallarg(char *) path;
  657         } */ *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
  662         return (sys_unlink(p, uap, retval));
  663 }
  665 /*
  666  * HP-UX chdir(2) system call.
  667  */
  668 int
hpux_sys_chdir(p, v, retval)
  670         struct proc *p;
  671         void *v;
register_t *retval;
  673 {
  674         struct hpux_sys_chdir_args /* {
  675                 syscallarg(char *) path;
  676         } */ *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
  681         return (sys_chdir(p, uap, retval));
  682 }
  684 /*
  685  * HP-UX mknod(2) system call.
  686  */
  687 int
hpux_sys_mknod(p, v, retval)
  689         struct proc *p;
  690         void *v;
register_t *retval;
  692 {
  693         struct hpux_sys_mknod_args /* {
  694                 syscallarg(char *) path;
  695                 syscallarg(int) mode;
  696                 syscallarf(int) dev;
  697         } */ *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
  699         struct sys_mkfifo_args bma;
HPUX_CHECK_ALT_CREAT(p, &sg, SCARG(uap, path));
  703         /*
  704          * BSD handles FIFOs separately.
  705          */
  706         if (S_ISFIFO(SCARG(uap, mode))) {
SCARG(&bma, path) = SCARG(uap, path);
SCARG(&bma, mode) = SCARG(uap, mode);
  709                 return (sys_mkfifo(p, uap, retval));
  710         } else
  711                 return (sys_mknod(p, uap, retval));
  712 }
  714 /*
  715  * HP-UX chmod(2) system call.
  716  */
  717 int
hpux_sys_chmod(p, v, retval)
  719         struct proc *p;
  720         void *v;
register_t *retval;
  722 {
  723         struct hpux_sys_chmod_args /* {
  724                 syscallarg(char *) path;
  725                 syscallarg(int) mode; 
  726         } */ *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
  731         return (sys_chmod(p, uap, retval));
  732 }
  734 /*
  735  * HP-UX chown(2) system call.
  736  */
  737 int
hpux_sys_chown(p, v, retval)
  739         struct proc *p;
  740         void *v;
register_t *retval;
  742 {
  743         struct hpux_sys_chown_args /* {
  744                 syscallarg(char *) path;
  745                 syscallarg(int) uid;
  746                 syscallarg(int) gid;
  747         } */ *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
  752         /* XXX What about older HP-UX executables? */
  754         return (sys_lchown(p, uap, retval));
  755 }
  757 /*
  758  * HP-UX rename(2) system call.
  759  */
  760 int
hpux_sys_rename(p, v, retval)
  762         struct proc *p;
  763         void *v;
register_t *retval;
  765 {
  766         struct hpux_sys_rename_args /* {
  767                 syscallarg(char *) from;
  768                 syscallarg(char *) to;
  769         } */ *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, from));
HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, to));
  775         return (sys_rename(p, uap, retval));
  776 }
  778 /*
  779  * HP-UX mkdir(2) system call.
  780  */
  781 int
hpux_sys_mkdir(p, v, retval)
  783         struct proc *p;
  784         void *v;
register_t *retval;
  786 {
  787         struct hpux_sys_mkdir_args /* {
  788                 syscallarg(char *) path;
  789                 syscallarg(int) mode;
  790         } */ *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
HPUX_CHECK_ALT_CREAT(p, &sg, SCARG(uap, path));
  795         return (sys_mkdir(p, uap, retval));
  796 }
  798 /*
  799  * HP-UX rmdir(2) system call.
  800  */
  801 int
hpux_sys_rmdir(p, v, retval)
  803         struct proc *p;
  804         void *v;
register_t *retval;
  806 {
  807         struct hpux_sys_rmdir_args /* {
  808                 syscallarg(char *) path;
  809         } */ *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
  814         return (sys_rmdir(p, uap, retval));
  815 }
  817 /*
  818  * HP-UX symlink(2) system call.
  819  */
  820 int
hpux_sys_symlink(p, v, retval)
  822         struct proc *p;
  823         void *v;
register_t *retval;
  825 {
  826         struct hpux_sys_symlink_args /* {
  827                 syscallarg(char *) path;
  828                 syscallarg(char *) link;
  829         } */ *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
HPUX_CHECK_ALT_CREAT(p, &sg, SCARG(uap, link));
  835         return (sys_symlink(p, uap, retval));
  836 }
  838 /*
  839  * HP-UX readlink(2) system call.
  840  */
  841 int
hpux_sys_readlink(p, v, retval)
  843         struct proc *p;
  844         void *v;
register_t *retval;
  846 {
  847         struct hpux_sys_readlink_args /* {
  848                 syscallarg(char *) path;
  849                 syscallarg(char *) buf;
  850                 syscallarg(int) count;
  851         } */ *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
  856         return (sys_readlink(p, uap, retval));
  857 }
  859 /*
  860  * HP-UX truncate(2) system call.
  861  */
  862 int
hpux_sys_truncate(p, v, retval)
  864         struct proc *p;
  865         void *v;
register_t *retval;
  867 {
  868         struct hpux_sys_truncate_args /* {
  869                 syscallarg(char *) path;
  870                 syscallarg(long) length;
  871         } */ *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
HPUX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
  876         return (compat_43_sys_truncate(p, uap, retval));
  877 }