root/compat/osf1/osf1_cvt.c

DEFINITIONS

1. osf1_cvt_flock_from_native
2. osf1_cvt_flock_to_native
3. osf1_cvt_msghdr_xopen_to_native
4. osf1_cvt_pathconf_name_to_native
5. osf1_cvt_rusage_from_native
6. osf1_cvt_sigaction_from_native
7. osf1_cvt_sigaction_to_native
8. osf1_cvt_sigaltstack_from_native
9. osf1_cvt_sigaltstack_to_native
10. osf1_cvt_sigset_from_native
11. osf1_cvt_sigset_to_native
12. osf1_cvt_stat_from_native
13. osf1_cvt_statfs_from_native

    1 /* $OpenBSD: osf1_cvt.c,v 1.3 2006/02/16 20:32:33 miod Exp $ */
    2 /* $NetBSD: osf1_cvt.c,v 1.7 1999/06/26 01:23:23 cgd Exp $ */
    4 /*
    5  * Copyright (c) 1999 Christopher G. Demetriou.  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. All advertising materials mentioning features or use of this software
   16  *    must display the following acknowledgement:
   17  *      This product includes software developed by Christopher G. Demetriou
   18  *      for the NetBSD Project.
   19  * 4. The name of the author may not be used to endorse or promote products
   20  *    derived from this software without specific prior written permission
   21  *
   22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   24  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   25  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   27  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   31  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   32  */
   34 /*
   35  * Copyright (c) 1994, 1995 Carnegie-Mellon University.
   36  * All rights reserved.
   37  *
   38  * Author: Chris G. Demetriou
   39  * 
   40  * Permission to use, copy, modify and distribute this software and
   41  * its documentation is hereby granted, provided that both the copyright
   42  * notice and this permission notice appear in all copies of the
   43  * software, derivative works or modified versions, and any portions
   44  * thereof, and that both notices appear in supporting documentation.
   45  * 
   46  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" 
   47  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND 
   48  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
   49  * 
   50  * Carnegie Mellon requests users of this software to return to
   51  *
   52  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
   53  *  School of Computer Science
   54  *  Carnegie Mellon University
   55  *  Pittsburgh PA 15213-3890
   56  *
   57  * any improvements or extensions that they make and grant Carnegie the
   58  * rights to redistribute these changes.
   59  */
   61 #include <sys/param.h>
   62 #include <sys/systm.h>
   63 #include <sys/namei.h>
   64 #include <sys/proc.h>
   65 #include <sys/file.h>
   66 #include <sys/stat.h>
   67 #include <sys/filedesc.h>
   68 #include <sys/kernel.h>
   69 #include <sys/malloc.h>
   70 #include <sys/mman.h>
   71 #include <sys/mount.h>
   72 #include <sys/signal.h>
   73 #include <sys/signalvar.h>
   74 #include <sys/reboot.h>
   75 #include <sys/syscallargs.h>
   76 #include <sys/exec.h>
   77 #include <sys/vnode.h>
   78 #include <sys/socketvar.h>
   79 #include <sys/resource.h>
   80 #include <sys/resourcevar.h>
   81 #include <sys/wait.h>
   82 #include <uvm/uvm_extern.h>                             /* XXX see mmap emulation */
   84 #include <nfs/rpcv2.h>
   85 #include <nfs/nfsproto.h>
   86 #include <nfs/nfs.h>
   87 #include <nfs/nfsmount.h>
   89 #include <compat/osf1/osf1.h>
   90 #include <compat/osf1/osf1_util.h>
   91 #include <compat/osf1/osf1_cvt.h>
   93 const struct emul_flags_xtab osf1_access_flags_xtab[] = {
   94 #if 0 /* pseudo-flag */
   95     {   OSF1_F_OK,              OSF1_F_OK,              F_OK            },
   96 #endif
   97     {   OSF1_X_OK,              OSF1_X_OK,              X_OK            },
   98     {   OSF1_W_OK,              OSF1_W_OK,              W_OK            },
   99     {   OSF1_R_OK,              OSF1_R_OK,              R_OK            },
  100     {   0                                                               }
  101 };
  103 const struct emul_flags_xtab osf1_fcntl_getsetfd_flags_rxtab[] = {
  104     {   FD_CLOEXEC,             FD_CLOEXEC,             OSF1_FD_CLOEXEC },
  105     {   0                                                               }
  106 };
  108 const struct emul_flags_xtab osf1_fcntl_getsetfd_flags_xtab[] = {
  109     {   OSF1_FD_CLOEXEC,        OSF1_FD_CLOEXEC,        FD_CLOEXEC      },
  110     {   0                                                               }
  111 };
  113 /* flags specific to GETFL/SETFL; also uses open rxtab */
  114 const struct emul_flags_xtab osf1_fcntl_getsetfl_flags_rxtab[] = {
  115     {   FASYNC,                 FASYNC,                 OSF1_FASYNC     },
  116     {   0                                                               }
  117 };
  119 /* flags specific to GETFL/SETFL; also uses open xtab */
  120 const struct emul_flags_xtab osf1_fcntl_getsetfl_flags_xtab[] = {
  121     {   OSF1_FASYNC,            OSF1_FASYNC,            FASYNC          },
  122     {   0                                                               }
  123 };
  125 const struct emul_flags_xtab osf1_mmap_flags_xtab[] = {
  126     {   OSF1_MAP_SHARED,        OSF1_MAP_SHARED,        MAP_SHARED      },
  127     {   OSF1_MAP_PRIVATE,       OSF1_MAP_PRIVATE,       MAP_PRIVATE     },
  128     {   OSF1_MAP_TYPE,          OSF1_MAP_FILE,          MAP_FILE        },
  129     {   OSF1_MAP_TYPE,          OSF1_MAP_ANON,          MAP_ANON        },
  130     {   OSF1_MAP_FIXED,         OSF1_MAP_FIXED,         MAP_FIXED       },
  131 #if 0 /* pseudo-flag, and the default */
  132     {   OSF1_MAP_VARIABLE,      OSF1_MAP_VARIABLE,      0               },
  133 #endif
  134     {   OSF1_MAP_HASSEMAPHORE,  OSF1_MAP_HASSEMAPHORE,  MAP_HASSEMAPHORE },
  135     {   OSF1_MAP_INHERIT,       OSF1_MAP_INHERIT,       MAP_INHERIT     },
  136 #if 0 /* no equivalent +++ */
  137     {   OSF1_MAP_UNALIGNED,     OSF1_MAP_UNALIGNED,     ???             },
  138 #endif
  139     {   0                                                               }
  140 };
  142 const struct emul_flags_xtab osf1_mmap_prot_xtab[] = {
  143 #if 0 /* pseudo-flag */
  144     {   OSF1_PROT_NONE,         OSF1_PROT_NONE,         PROT_NONE       },
  145 #endif
  146     {   OSF1_PROT_READ,         OSF1_PROT_READ,         PROT_READ       },
  147     {   OSF1_PROT_WRITE,        OSF1_PROT_WRITE,        PROT_READ|PROT_WRITE },
  148     {   OSF1_PROT_EXEC,         OSF1_PROT_EXEC,         PROT_READ|PROT_EXEC },
  149     {   0                                                               }
  150 };
  152 const struct emul_flags_xtab osf1_nfs_mount_flags_xtab[] = {
  153     {   OSF1_NFSMNT_SOFT,       OSF1_NFSMNT_SOFT,       NFSMNT_SOFT,    },
  154     {   OSF1_NFSMNT_WSIZE,      OSF1_NFSMNT_WSIZE,      NFSMNT_WSIZE,   },
  155     {   OSF1_NFSMNT_RSIZE,      OSF1_NFSMNT_RSIZE,      NFSMNT_RSIZE,   },
  156     {   OSF1_NFSMNT_TIMEO,      OSF1_NFSMNT_TIMEO,      NFSMNT_TIMEO,   },
  157     {   OSF1_NFSMNT_RETRANS,    OSF1_NFSMNT_RETRANS,    NFSMNT_RETRANS, },
  158 #if 0 /* no equivalent; needs special handling, see below */
  159     {   OSF1_NFSMNT_HOSTNAME,   OSF1_NFSMNT_HOSTNAME,   ???,            },
  160 #endif
  161     {   OSF1_NFSMNT_INT,        OSF1_NFSMNT_INT,        NFSMNT_INT,     },
  162     {   OSF1_NFSMNT_NOCONN,     OSF1_NFSMNT_NOCONN,     NFSMNT_NOCONN,  },
  163 #if 0 /* no equivalents */
  164     {   OSF1_NFSMNT_NOAC,       OSF1_NFSMNT_NOAC,       ???,            },
  165     {   OSF1_NFSMNT_ACREGMIN,   OSF1_NFSMNT_ACREGMIN,   ???,            },
  166     {   OSF1_NFSMNT_ACREGMAX,   OSF1_NFSMNT_ACREGMAX,   ???,            },
  167     {   OSF1_NFSMNT_ACDIRMIN,   OSF1_NFSMNT_ACDIRMIN,   ???,            },
  168     {   OSF1_NFSMNT_ACDIRMAX,   OSF1_NFSMNT_ACDIRMAX,   ???,            },
  169     {   OSF1_NFSMNT_NOCTO,      OSF1_NFSMNT_NOCTO,      ???,            },
  170     {   OSF1_NFSMNT_POSIX,      OSF1_NFSMNT_POSIX,      ???,            },
  171     {   OSF1_NFSMNT_AUTO,       OSF1_NFSMNT_AUTO,       ???,            },
  172     {   OSF1_NFSMNT_SEC,        OSF1_NFSMNT_SEC,        ???,            },
  173     {   OSF1_NFSMNT_TCP,        OSF1_NFSMNT_TCP,        ???,            },
  174     {   OSF1_NFSMNT_PROPLIST,   OSF1_NFSMNT_PROPLIST,   ???,            },
  175 #endif
  176     {   0                                                               }
  177 };
  179 const struct emul_flags_xtab osf1_open_flags_rxtab[] = {
  180     {   O_ACCMODE,              O_RDONLY,               OSF1_O_RDONLY   },
  181     {   O_ACCMODE,              O_WRONLY,               OSF1_O_WRONLY   },
  182     {   O_ACCMODE,              O_RDWR,                 OSF1_O_RDWR     },
  183     {   O_NONBLOCK,             O_NONBLOCK,             OSF1_O_NONBLOCK },
  184     {   O_APPEND,               O_APPEND,               OSF1_O_APPEND   },
  185 #if 0 /* no equivalent +++ */
  186     {   ???,                    ???,                    O_DEFER         },
  187 #endif
  188     {   O_CREAT,                O_CREAT,                OSF1_O_CREAT    },
  189     {   O_TRUNC,                O_TRUNC,                OSF1_O_TRUNC    },
  190     {   O_EXCL,                 O_EXCL,                 OSF1_O_EXCL     },
  191     {   O_NOCTTY,               O_NOCTTY,               OSF1_O_NOCTTY   },
  192     {   O_SYNC,                 O_SYNC,                 OSF1_O_SYNC     },
  193     {   O_NDELAY,               O_NDELAY,               OSF1_O_NDELAY   },
  194 #if 0 /* no equivalent, also same value as O_NDELAY! */
  195     {   ???,                    ???,                    O_DRD           },
  196 #endif
  197     {   O_DSYNC,                O_DSYNC,                OSF1_O_DSYNC    },
  198     {   O_RSYNC,                O_RSYNC,                OSF1_O_RSYNC    },
  199     {   0                                                               }
  200 };
  202 const struct emul_flags_xtab osf1_open_flags_xtab[] = {
  203     {   OSF1_O_ACCMODE,         OSF1_O_RDONLY,          O_RDONLY        },
  204     {   OSF1_O_ACCMODE,         OSF1_O_WRONLY,          O_WRONLY        },
  205     {   OSF1_O_ACCMODE,         OSF1_O_RDWR,            O_RDWR          },
  206     {   OSF1_O_NONBLOCK,        OSF1_O_NONBLOCK,        O_NONBLOCK      },
  207     {   OSF1_O_APPEND,          OSF1_O_APPEND,          O_APPEND        },
  208 #if 0 /* no equivalent +++ */
  209     {   OSF1_O_DEFER,           OSF1_O_DEFER,           ???             },
  210 #endif
  211     {   OSF1_O_CREAT,           OSF1_O_CREAT,           O_CREAT         },
  212     {   OSF1_O_TRUNC,           OSF1_O_TRUNC,           O_TRUNC         },
  213     {   OSF1_O_EXCL,            OSF1_O_EXCL,            O_EXCL          },
  214     {   OSF1_O_NOCTTY,          OSF1_O_NOCTTY,          O_NOCTTY        },
  215     {   OSF1_O_SYNC,            OSF1_O_SYNC,            O_SYNC          },
  216     {   OSF1_O_NDELAY,          OSF1_O_NDELAY,          O_NDELAY        },
  217 #if 0 /* no equivalent, also same value as O_NDELAY! */
  218     {   OSF1_O_DRD,             OSF1_O_DRD,             ???             },
  219 #endif
  220     {   OSF1_O_DSYNC,           OSF1_O_DSYNC,           O_DSYNC         },
  221     {   OSF1_O_RSYNC,           OSF1_O_RSYNC,           O_RSYNC         },
  222     {   0                                                               }
  223 };
  225 const struct emul_flags_xtab osf1_reboot_opt_xtab[] = {
  226 #if 0 /* pseudo-flag */
  227     {   OSF1_RB_AUTOBOOT,       OSF1_RB_AUTOBOOT,       RB_AUTOBOOT     },
  228 #endif
  229     {   OSF1_RB_ASKNAME,        OSF1_RB_ASKNAME,        RB_ASKNAME      },
  230     {   OSF1_RB_SINGLE,         OSF1_RB_SINGLE,         RB_SINGLE       },
  231     {   OSF1_RB_NOSYNC,         OSF1_RB_NOSYNC,         RB_NOSYNC       },
  232 #if 0 /* same value as O_NDELAY, only used at boot time? */
  233     {   OSF1_RB_KDB,            OSF1_RB_KDB,            RB_KDB          },
  234 #endif
  235     {   OSF1_RB_HALT,           OSF1_RB_HALT,           RB_HALT         },
  236     {   OSF1_RB_INITNAME,       OSF1_RB_INITNAME,       RB_INITNAME     },
  237     {   OSF1_RB_DFLTROOT,       OSF1_RB_DFLTROOT,       RB_DFLTROOT     },
  238 #if 0 /* no equivalents +++ */
  239     {   OSF1_RB_ALTBOOT,        OSF1_RB_ALTBOOT,        ???             },
  240     {   OSF1_RB_UNIPROC,        OSF1_RB_UNIPROC,        ???             },
  241     {   OSF1_RB_PARAM,          OSF1_RB_PARAM,          ???             },
  242 #endif
  243     {   OSF1_RB_DUMP,           OSF1_RB_DUMP,           RB_DUMP         },
  244     {   0                                                               }
  245 };
  247 const struct emul_flags_xtab osf1_sendrecv_msg_flags_xtab[] = {
  248     {   OSF1_MSG_OOB,           OSF1_MSG_OOB,           MSG_OOB         },
  249     {   OSF1_MSG_PEEK,          OSF1_MSG_PEEK,          MSG_PEEK        },
  250     {   OSF1_MSG_DONTROUTE,     OSF1_MSG_DONTROUTE,     MSG_DONTROUTE   },
  251     {   OSF1_MSG_EOR,           OSF1_MSG_EOR,           MSG_EOR         },
  252     {   OSF1_MSG_TRUNC,         OSF1_MSG_TRUNC,         MSG_TRUNC       },
  253     {   OSF1_MSG_CTRUNC,        OSF1_MSG_CTRUNC,        MSG_CTRUNC      },
  254     {   OSF1_MSG_WAITALL,       OSF1_MSG_WAITALL,       MSG_WAITALL     },
  255     {   0                                                               }
  256 };
  258 const struct emul_flags_xtab osf1_sigaction_flags_rxtab[] = {
  259     {   SA_ONSTACK,             SA_ONSTACK,             OSF1_SA_ONSTACK },
  260     {   SA_RESTART,             SA_RESTART,             OSF1_SA_RESTART },
  261     {   SA_NOCLDSTOP,           SA_NOCLDSTOP,           OSF1_SA_NOCLDSTOP },
  262     {   SA_NODEFER,             SA_NODEFER,             OSF1_SA_NODEFER },
  263     {   SA_RESETHAND,           SA_RESETHAND,           OSF1_SA_RESETHAND },
  264     {   SA_NOCLDWAIT,           SA_NOCLDWAIT,           OSF1_SA_NOCLDWAIT },
  265 #if 0 /* XXX not yet */
  266     {   SA_SIGINFO,             SA_SIGINFO,             OSF1_SA_SIGINFO },
  267 #endif
  268     {   0                                                               },
  269 };
  271 const struct emul_flags_xtab osf1_sigaction_flags_xtab[] = {
  272     {   OSF1_SA_ONSTACK,        OSF1_SA_ONSTACK,        SA_ONSTACK      },
  273     {   OSF1_SA_RESTART,        OSF1_SA_RESTART,        SA_RESTART      },
  274     {   OSF1_SA_NOCLDSTOP,      OSF1_SA_NOCLDSTOP,      SA_NOCLDSTOP    },
  275     {   OSF1_SA_NODEFER,        OSF1_SA_NODEFER,        SA_NODEFER      },
  276     {   OSF1_SA_RESETHAND,      OSF1_SA_RESETHAND,      SA_RESETHAND    },
  277     {   OSF1_SA_NOCLDWAIT,      OSF1_SA_NOCLDWAIT,      SA_NOCLDWAIT    },
  278 #if 0 /* XXX not yet */
  279     {   OSF1_SA_SIGINFO,        OSF1_SA_SIGINFO,        SA_SIGINFO      },
  280 #endif
  281     {   0                                                               },
  282 };
  284 const struct emul_flags_xtab osf1_sigaltstack_flags_rxtab[] = {
  285     {   SS_ONSTACK,             SS_ONSTACK,             OSF1_SS_ONSTACK },
  286     {   SS_DISABLE,             SS_DISABLE,             OSF1_SS_DISABLE },
  287 #if 0 /* XXX no equivalents */
  288     {   ???,                    ???,                    OSF1_SS_NOMASK  },
  289     {   ???,                    ???,                    OSF1_SS_UCONTEXT },
  290 #endif
  291     {   0                                                               },
  292 };
  294 const struct emul_flags_xtab osf1_sigaltstack_flags_xtab[] = {
  295     {   OSF1_SS_ONSTACK,        OSF1_SS_ONSTACK,        SS_ONSTACK      },
  296     {   OSF1_SS_DISABLE,        OSF1_SS_DISABLE,        SS_DISABLE      },
  297 #if 0 /* XXX no equivalents */
  298     {   OSF1_SS_NOMASK,         OSF1_SS_NOMASK,         ???             },
  299     {   OSF1_SS_UCONTEXT,       OSF1_SS_UCONTEXT,       ???             },
  300 #endif
  301     {   0                                                               },
  302 };
  304 const struct emul_flags_xtab osf1_wait_options_xtab[] = {
  305     {   OSF1_WNOHANG,           OSF1_WNOHANG,           WNOHANG         },
  306     {   OSF1_WUNTRACED,         OSF1_WUNTRACED,         WUNTRACED       },
  307     {   0                                                               }
  308 };
  310 void
osf1_cvt_flock_from_native(nf, of)
  312         const struct flock *nf;
  313         struct osf1_flock *of;
  314 {
memset(of, 0, sizeof *of);
of->l_start = nf->l_start;
of->l_len = nf->l_len;
of->l_pid = nf->l_pid;
  322         switch (nf->l_type) {
  323         case F_RDLCK:
of->l_type = OSF1_F_RDLCK;
  325                 break;
  327         case F_WRLCK:
of->l_type = OSF1_F_WRLCK;
  329                 break;
  331         case F_UNLCK:
of->l_type = OSF1_F_UNLCK;
  333                 break;
  334         }
  336         switch (nf->l_whence) {
  337         case SEEK_SET:
of->l_whence = OSF1_SEEK_SET;
  339                 break;
  341         case SEEK_CUR:
of->l_whence = OSF1_SEEK_CUR;
  343                 break;
  345         case SEEK_END:
of->l_whence = OSF1_SEEK_END;
  347                 break;
  348         }
  349 }
  351 int
osf1_cvt_flock_to_native(of, nf)
  353         const struct osf1_flock *of;
  354         struct flock *nf;
  355 {
memset(nf, 0, sizeof *nf);
nf->l_start = of->l_start;
nf->l_len = of->l_len;
nf->l_pid = of->l_pid;
  363         switch (of->l_type) {
  364         case OSF1_F_RDLCK:
nf->l_type = F_RDLCK;
  366                 break;
  368         case OSF1_F_WRLCK:
nf->l_type = F_WRLCK;
  370                 break;
  372         case OSF1_F_UNLCK:
nf->l_type = F_UNLCK;
  374                 break;
  376         default:
  377                 return (EINVAL);
  378         }
  380         switch (of->l_whence) {
  381         case OSF1_SEEK_SET:
nf->l_whence = SEEK_SET;
  383                 break;
  385         case OSF1_SEEK_CUR:
nf->l_whence = SEEK_CUR;
  387                 break;
  389         case OSF1_SEEK_END:
nf->l_whence = SEEK_END;
  391                 break;
  393         default:
  394                 return (EINVAL);
  395         }
  397         return (0);
  398 }
  400 int
osf1_cvt_msghdr_xopen_to_native(omh, bmh)
  402         const struct osf1_msghdr_xopen *omh;
  403         struct msghdr *bmh;
  404 {
  405         unsigned long leftovers;
memset(bmh, 0, sizeof *bmh);
bmh->msg_name = omh->msg_name;          /* XXX sockaddr translation */
bmh->msg_namelen = omh->msg_namelen;
bmh->msg_iov = NULL;                    /* iovec xlation separate */
bmh->msg_iovlen = omh->msg_iovlen;
  413         /* XXX we don't translate control messages (yet) */
  414         if (bmh->msg_control != NULL || bmh->msg_controllen != 0)
  415 {
printf("osf1_cvt_msghdr_xopen_to_native: control\n");
  417                 return (EINVAL);
  418 }
  420         /* translate flags */
bmh->msg_flags = emul_flags_translate(osf1_sendrecv_msg_flags_xtab,
omh->msg_flags, &leftovers);
  423         if (leftovers != 0)
  424 {
printf("osf1_cvt_msghdr_xopen_to_native: leftovers 0x%lx\n", leftovers);
  426                 return (EINVAL);
  427 }
  429         return (0);
  430 }
  432 int
osf1_cvt_pathconf_name_to_native(oname, bnamep)
  434         int oname, *bnamep;
  435 {
  436         int error;
error  = 0;
  439         switch (oname) {
  440         case OSF1__PC_CHOWN_RESTRICTED:
  441                 *bnamep = _PC_CHOWN_RESTRICTED;
  442                 break;
  444         case OSF1__PC_LINK_MAX:
  445                 *bnamep = _PC_LINK_MAX;
  446                 break;
  448         case OSF1__PC_MAX_CANON:
  449                 *bnamep = _PC_MAX_CANON;
  450                 break;
  452         case OSF1__PC_MAX_INPUT:
  453                 *bnamep = _PC_MAX_INPUT;
  454                 break;
  456         case OSF1__PC_NAME_MAX:
  457                 *bnamep = _PC_NAME_MAX;
  458                 break;
  460         case OSF1__PC_NO_TRUNC:
  461                 *bnamep = _PC_NO_TRUNC;
  462                 break;
  464         case OSF1__PC_PATH_MAX:
  465                 *bnamep = _PC_PATH_MAX;
  466                 break;
  468         case OSF1__PC_PIPE_BUF:
  469                 *bnamep = _PC_PIPE_BUF;
  470                 break;
  472         case OSF1__PC_VDISABLE:
  473                 *bnamep = _PC_VDISABLE;
  474                 break;
  476         default:
error = EINVAL;
  478                 break;
  479         }
  481         return (error);
  482 }
  484 /*
  485  * Convert from as rusage structure to an osf1 rusage structure.
  486  */
  487 void
osf1_cvt_rusage_from_native(ru, oru)
  489         const struct rusage *ru;
  490         struct osf1_rusage *oru;
  491 {
oru->ru_utime.tv_sec = ru->ru_utime.tv_sec;
oru->ru_utime.tv_usec = ru->ru_utime.tv_usec;
oru->ru_stime.tv_sec = ru->ru_stime.tv_sec;
oru->ru_stime.tv_usec = ru->ru_stime.tv_usec;
oru->ru_maxrss = ru->ru_maxrss;
oru->ru_ixrss = ru->ru_ixrss;
oru->ru_idrss = ru->ru_idrss;
oru->ru_isrss = ru->ru_isrss;
oru->ru_minflt = ru->ru_minflt;
oru->ru_majflt = ru->ru_majflt;
oru->ru_nswap = ru->ru_nswap;
oru->ru_inblock = ru->ru_inblock;
oru->ru_oublock = ru->ru_oublock;
oru->ru_msgsnd = ru->ru_msgsnd;
oru->ru_msgrcv = ru->ru_msgrcv;
oru->ru_nsignals = ru->ru_nsignals;
oru->ru_nvcsw = ru->ru_nvcsw;
oru->ru_nivcsw = ru->ru_nivcsw;
  513 }
  515 /*
  516  * XXX: Only a subset of the flags is currently implemented.
  517  */
  518 void
osf1_cvt_sigaction_from_native(bsa, osa)
  520         const struct sigaction *bsa;
  521         struct osf1_sigaction *osa;
  522 {
osa->sa__handler = bsa->sa_handler;
osf1_cvt_sigset_from_native(&bsa->sa_mask, &osa->sa_mask);
osa->sa_flags = 0;
  527         /* Translate by hand */
  528         if ((bsa->sa_flags & SA_ONSTACK) != 0)
osa->sa_flags |= OSF1_SA_ONSTACK;
  530         if ((bsa->sa_flags & SA_RESTART) != 0)
osa->sa_flags |= OSF1_SA_RESTART;
  532         if ((bsa->sa_flags & SA_NOCLDSTOP) != 0)
osa->sa_flags |= OSF1_SA_NOCLDSTOP;
  534         if ((bsa->sa_flags & SA_NOCLDWAIT) != 0)
osa->sa_flags |= OSF1_SA_NOCLDWAIT;
  536         if ((bsa->sa_flags & SA_NODEFER) != 0)
osa->sa_flags |= OSF1_SA_NODEFER;
  538         if ((bsa->sa_flags & SA_RESETHAND) != 0)
osa->sa_flags |= OSF1_SA_RESETHAND;
  540         if ((bsa->sa_flags & SA_SIGINFO) != 0)
osa->sa_flags |= OSF1_SA_SIGINFO;
  542 }
  544 int
osf1_cvt_sigaction_to_native(osa, bsa)
  546         const struct osf1_sigaction *osa;
  547         struct sigaction *bsa;
  548 {
bsa->sa_handler = osa->sa__handler;
osf1_cvt_sigset_to_native(&osa->sa_mask, &bsa->sa_mask);
bsa->sa_flags = 0;
  553         /* Translate by hand */
  554         if ((osa->sa_flags & OSF1_SA_ONSTACK) != 0)
bsa->sa_flags |= SA_ONSTACK;
  556         if ((osa->sa_flags & OSF1_SA_RESTART) != 0)
bsa->sa_flags |= SA_RESTART;
  558         if ((osa->sa_flags & OSF1_SA_RESETHAND) != 0)
bsa->sa_flags |= SA_RESETHAND;
  560         if ((osa->sa_flags & OSF1_SA_NOCLDSTOP) != 0)
bsa->sa_flags |= SA_NOCLDSTOP;
  562         if ((osa->sa_flags & OSF1_SA_NOCLDWAIT) != 0)
bsa->sa_flags |= SA_NOCLDWAIT;
  564         if ((osa->sa_flags & OSF1_SA_NODEFER) != 0)
bsa->sa_flags |= SA_NODEFER;
  566         if ((osa->sa_flags & OSF1_SA_SIGINFO) != 0)
bsa->sa_flags |= SA_SIGINFO;
  569         return(0);
  570 }
  572 void
osf1_cvt_sigaltstack_from_native(bss, oss)
  574         const struct sigaltstack *bss;
  575         struct osf1_sigaltstack *oss;
  576 {
oss->ss_sp = bss->ss_sp;
oss->ss_size = bss->ss_size;
  581         /* translate flags */
oss->ss_flags = emul_flags_translate(osf1_sigaltstack_flags_rxtab,
bss->ss_flags, NULL);
  584 }
  586 int
osf1_cvt_sigaltstack_to_native(oss, bss)
  588         const struct osf1_sigaltstack *oss;
  589         struct sigaltstack *bss;
  590 {
  591         unsigned long leftovers;
bss->ss_sp = oss->ss_sp;
bss->ss_size = oss->ss_size;
  596         /* translate flags */
bss->ss_flags = emul_flags_translate(osf1_sigaltstack_flags_xtab,
oss->ss_flags, &leftovers);
  600         if (leftovers != 0) {
printf("osf1_cvt_sigaltstack_to_native: leftovers = 0x%lx\n",
leftovers);
  603                 return (EINVAL);
  604         }
  606         return (0);
  607 }
  609 void
osf1_cvt_sigset_from_native(bss, oss)
  611         const sigset_t *bss;
osf1_sigset_t *oss;
  613 {
  614         int i, newsig;
osf1_sigemptyset(oss);
  617         for (i = 1; i < NSIG; i++) {
  618                 if (sigismember(bss, i)) {
newsig = osf1_signal_rxlist[i];
  620                         if (newsig)
osf1_sigaddset(oss, newsig);
  622                 }
  623         }
  624 }
  626 int
osf1_cvt_sigset_to_native(oss, bss)
  628         const osf1_sigset_t *oss;
sigset_t *bss;
  630 {
  631         int i, newsig;
sigemptyset(bss);
  634         for (i = 1; i < OSF1_NSIG; i++) {
  635                 if (osf1_sigismember(oss, i)) {
newsig = osf1_signal_xlist[i];
  637                         if (newsig)
sigaddset(bss, newsig);
  639                 }
  640         }
  641         return (0);
  642 }
  644 /*
  645  * Convert from a stat structure to an osf1 stat structure.
  646  */
  647 void
osf1_cvt_stat_from_native(st, ost)
  649         const struct stat *st;
  650         struct osf1_stat *ost;
  651 {
ost->st_dev = osf1_cvt_dev_from_native(st->st_dev);
ost->st_ino = st->st_ino;
ost->st_mode = st->st_mode;
ost->st_nlink = st->st_nlink;
ost->st_uid = st->st_uid == -2 ? (u_int16_t) -2 : st->st_uid;
ost->st_gid = st->st_gid == -2 ? (u_int16_t) -2 : st->st_gid;
ost->st_rdev = osf1_cvt_dev_from_native(st->st_rdev);
ost->st_size = st->st_size;
ost->st_atime_sec = st->st_atime;
ost->st_spare1 = 0;
ost->st_mtime_sec = st->st_mtime;
ost->st_spare2 = 0;
ost->st_ctime_sec = st->st_ctime;
ost->st_spare3 = 0;
ost->st_blksize = st->st_blksize;
ost->st_blocks = st->st_blocks;
ost->st_flags = st->st_flags;
ost->st_gen = st->st_gen;
  671 }
  673 void
osf1_cvt_statfs_from_native(bsfs, osfs)
  675         const struct statfs *bsfs;
  676         struct osf1_statfs *osfs;
  677 {
memset(osfs, 0, sizeof (struct osf1_statfs));
  680         if (!strncmp(MOUNT_FFS, bsfs->f_fstypename, MFSNAMELEN))
osfs->f_type = OSF1_MOUNT_UFS;
  682         else if (!strncmp(MOUNT_NFS, bsfs->f_fstypename, MFSNAMELEN))
osfs->f_type = OSF1_MOUNT_NFS;
  684         else if (!strncmp(MOUNT_MFS, bsfs->f_fstypename, MFSNAMELEN))
osfs->f_type = OSF1_MOUNT_MFS;
  686         else
  687                 /* uh oh...  XXX = PC, CDFS, PROCFS, etc. */
osfs->f_type = OSF1_MOUNT_ADDON;
osfs->f_flags = bsfs->f_flags;          /* XXX translate */
osfs->f_fsize = bsfs->f_bsize;
osfs->f_bsize = bsfs->f_iosize;
osfs->f_blocks = bsfs->f_blocks;
osfs->f_bfree = bsfs->f_bfree;
osfs->f_bavail = bsfs->f_bavail;
osfs->f_files = bsfs->f_files;
osfs->f_ffree = bsfs->f_ffree;
memcpy(&osfs->f_fsid, &bsfs->f_fsid,
max(sizeof bsfs->f_fsid, sizeof osfs->f_fsid));
  699         /* osfs->f_spare zeroed above */
memcpy(osfs->f_mntonname, bsfs->f_mntonname,
max(sizeof bsfs->f_mntonname, sizeof osfs->f_mntonname));
memcpy(osfs->f_mntfromname, bsfs->f_mntfromname,
max(sizeof bsfs->f_mntfromname, sizeof osfs->f_mntfromname));
  704         /* XXX osfs->f_xxx should be filled in... */
  705 }