The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/i386/ibcs2/ibcs2_misc.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 1995 Steven Wallace
    3  * Copyright (c) 1994, 1995 Scott Bartram
    4  * Copyright (c) 1992, 1993
    5  *      The Regents of the University of California.  All rights reserved.
    6  *
    7  * This software was developed by the Computer Systems Engineering group
    8  * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
    9  * contributed to Berkeley.
   10  *
   11  * All advertising materials mentioning features or use of this software
   12  * must display the following acknowledgement:
   13  *      This product includes software developed by the University of
   14  *      California, Lawrence Berkeley Laboratory.
   15  *
   16  * Redistribution and use in source and binary forms, with or without
   17  * modification, are permitted provided that the following conditions
   18  * are met:
   19  * 1. Redistributions of source code must retain the above copyright
   20  *    notice, this list of conditions and the following disclaimer.
   21  * 2. Redistributions in binary form must reproduce the above copyright
   22  *    notice, this list of conditions and the following disclaimer in the
   23  *    documentation and/or other materials provided with the distribution.
   24  * 3. All advertising materials mentioning features or use of this software
   25  *    must display the following acknowledgement:
   26  *      This product includes software developed by the University of
   27  *      California, Berkeley and its contributors.
   28  * 4. Neither the name of the University nor the names of its contributors
   29  *    may be used to endorse or promote products derived from this software
   30  *    without specific prior written permission.
   31  *
   32  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   33  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   34  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   35  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   36  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   37  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   38  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   39  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   40  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   41  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   42  * SUCH DAMAGE.
   43  *
   44  * from: Header: sun_misc.c,v 1.16 93/04/07 02:46:27 torek Exp 
   45  *
   46  *      @(#)sun_misc.c  8.1 (Berkeley) 6/18/93
   47  */
   48 
   49 #include <sys/cdefs.h>
   50 __FBSDID("$FreeBSD: releng/11.1/sys/i386/ibcs2/ibcs2_misc.c 331987 2018-04-04 05:43:03Z gordon $");
   51 
   52 /*
   53  * IBCS2 compatibility module.
   54  *
   55  * IBCS2 system calls that are implemented differently in BSD are
   56  * handled here.
   57  */
   58 #include <sys/param.h>
   59 #include <sys/systm.h>
   60 #include <sys/capsicum.h>
   61 #include <sys/dirent.h>
   62 #include <sys/fcntl.h>
   63 #include <sys/filedesc.h>
   64 #include <sys/imgact.h>
   65 #include <sys/kernel.h>
   66 #include <sys/lock.h>
   67 #include <sys/malloc.h>
   68 #include <sys/file.h>                   /* Must come after sys/malloc.h */
   69 #include <sys/mutex.h>
   70 #include <sys/namei.h>
   71 #include <sys/priv.h>
   72 #include <sys/reboot.h>
   73 #include <sys/resourcevar.h>
   74 #include <sys/stat.h>
   75 #include <sys/sysctl.h>
   76 #include <sys/syscallsubr.h>
   77 #include <sys/sysproto.h>
   78 #include <sys/time.h>
   79 #include <sys/times.h>
   80 #include <sys/vnode.h>
   81 #include <sys/wait.h>
   82 
   83 #include <machine/cpu.h>
   84 
   85 #include <i386/ibcs2/ibcs2_dirent.h>
   86 #include <i386/ibcs2/ibcs2_signal.h>
   87 #include <i386/ibcs2/ibcs2_proto.h>
   88 #include <i386/ibcs2/ibcs2_unistd.h>
   89 #include <i386/ibcs2/ibcs2_util.h>
   90 #include <i386/ibcs2/ibcs2_utime.h>
   91 #include <i386/ibcs2/ibcs2_xenix.h>
   92 
   93 #include <security/mac/mac_framework.h>
   94 
   95 int
   96 ibcs2_ulimit(td, uap)
   97         struct thread *td;
   98         struct ibcs2_ulimit_args *uap;
   99 {
  100         struct rlimit rl;
  101         int error;
  102 #define IBCS2_GETFSIZE          1
  103 #define IBCS2_SETFSIZE          2
  104 #define IBCS2_GETPSIZE          3
  105 #define IBCS2_GETDTABLESIZE     4
  106 
  107         switch (uap->cmd) {
  108         case IBCS2_GETFSIZE:
  109                 td->td_retval[0] = lim_cur(td, RLIMIT_FSIZE);
  110                 if (td->td_retval[0] == -1)
  111                         td->td_retval[0] = 0x7fffffff;
  112                 return 0;
  113         case IBCS2_SETFSIZE:
  114                 rl.rlim_max = lim_max(td, RLIMIT_FSIZE);
  115                 rl.rlim_cur = uap->newlimit;
  116                 error = kern_setrlimit(td, RLIMIT_FSIZE, &rl);
  117                 if (!error) {
  118                         td->td_retval[0] = lim_cur(td, RLIMIT_FSIZE);
  119                 } else {
  120                         DPRINTF(("failed "));
  121                 }
  122                 return error;
  123         case IBCS2_GETPSIZE:
  124                 td->td_retval[0] = lim_cur(td, RLIMIT_RSS); /* XXX */
  125                 return 0;
  126         case IBCS2_GETDTABLESIZE:
  127                 uap->cmd = IBCS2_SC_OPEN_MAX;
  128                 return ibcs2_sysconf(td, (struct ibcs2_sysconf_args *)uap);
  129         default:
  130                 return ENOSYS;
  131         }
  132 }
  133 
  134 #define IBCS2_WSTOPPED       0177
  135 #define IBCS2_STOPCODE(sig)  ((sig) << 8 | IBCS2_WSTOPPED)
  136 int
  137 ibcs2_wait(td, uap)
  138         struct thread *td;
  139         struct ibcs2_wait_args *uap;
  140 {
  141         int error, options, status;
  142         int *statusp;
  143         pid_t pid;
  144         struct trapframe *tf = td->td_frame;
  145         
  146         if ((tf->tf_eflags & (PSL_Z|PSL_PF|PSL_N|PSL_V))
  147             == (PSL_Z|PSL_PF|PSL_N|PSL_V)) {
  148                 /* waitpid */
  149                 pid = uap->a1;
  150                 statusp = (int *)uap->a2;
  151                 options = uap->a3;
  152         } else {
  153                 /* wait */
  154                 pid = WAIT_ANY;
  155                 statusp = (int *)uap->a1;
  156                 options = 0;
  157         }
  158         error = kern_wait(td, pid, &status, options, NULL);
  159         if (error)
  160                 return error;
  161         if (statusp) {
  162                 /*
  163                  * Convert status/signal result.
  164                  */
  165                 if (WIFSTOPPED(status)) {
  166                         if (WSTOPSIG(status) <= 0 ||
  167                             WSTOPSIG(status) > IBCS2_SIGTBLSZ)
  168                                 return (EINVAL);
  169                         status =
  170                           IBCS2_STOPCODE(bsd_to_ibcs2_sig[_SIG_IDX(WSTOPSIG(status))]);
  171                 } else if (WIFSIGNALED(status)) {
  172                         if (WTERMSIG(status) <= 0 ||
  173                             WTERMSIG(status) > IBCS2_SIGTBLSZ)
  174                                 return (EINVAL);
  175                         status = bsd_to_ibcs2_sig[_SIG_IDX(WTERMSIG(status))];
  176                 }
  177                 /* else exit status -- identical */
  178 
  179                 /* record result/status */
  180                 td->td_retval[1] = status;
  181                 return copyout(&status, statusp, sizeof(status));
  182         }
  183 
  184         return 0;
  185 }
  186 
  187 int
  188 ibcs2_execv(td, uap)
  189         struct thread *td;
  190         struct ibcs2_execv_args *uap;
  191 {
  192         struct image_args eargs;
  193         struct vmspace *oldvmspace;
  194         char *path;
  195         int error;
  196 
  197         CHECKALTEXIST(td, uap->path, &path);
  198 
  199         error = pre_execve(td, &oldvmspace);
  200         if (error != 0) {
  201                 free(path, M_TEMP);
  202                 return (error);
  203         }
  204         error = exec_copyin_args(&eargs, path, UIO_SYSSPACE, uap->argp, NULL);
  205         free(path, M_TEMP);
  206         if (error == 0)
  207                 error = kern_execve(td, &eargs, NULL);
  208         post_execve(td, error, oldvmspace);
  209         return (error);
  210 }
  211 
  212 int
  213 ibcs2_execve(td, uap) 
  214         struct thread *td;
  215         struct ibcs2_execve_args *uap;
  216 {
  217         struct image_args eargs;
  218         struct vmspace *oldvmspace;
  219         char *path;
  220         int error;
  221 
  222         CHECKALTEXIST(td, uap->path, &path);
  223 
  224         error = pre_execve(td, &oldvmspace);
  225         if (error != 0) {
  226                 free(path, M_TEMP);
  227                 return (error);
  228         }
  229         error = exec_copyin_args(&eargs, path, UIO_SYSSPACE, uap->argp,
  230             uap->envp);
  231         free(path, M_TEMP);
  232         if (error == 0)
  233                 error = kern_execve(td, &eargs, NULL);
  234         post_execve(td, error, oldvmspace);
  235         return (error);
  236 }
  237 
  238 int
  239 ibcs2_umount(td, uap)
  240         struct thread *td;
  241         struct ibcs2_umount_args *uap;
  242 {
  243         struct unmount_args um;
  244 
  245         um.path = uap->name;
  246         um.flags = 0;
  247         return sys_unmount(td, &um);
  248 }
  249 
  250 int
  251 ibcs2_mount(td, uap)
  252         struct thread *td;
  253         struct ibcs2_mount_args *uap;
  254 {
  255 #ifdef notyet
  256         int oflags = uap->flags, nflags, error;
  257         char fsname[MFSNAMELEN];
  258 
  259         if (oflags & (IBCS2_MS_NOSUB | IBCS2_MS_SYS5))
  260                 return (EINVAL);
  261         if ((oflags & IBCS2_MS_NEWTYPE) == 0)
  262                 return (EINVAL);
  263         nflags = 0;
  264         if (oflags & IBCS2_MS_RDONLY)
  265                 nflags |= MNT_RDONLY;
  266         if (oflags & IBCS2_MS_NOSUID)
  267                 nflags |= MNT_NOSUID;
  268         if (oflags & IBCS2_MS_REMOUNT)
  269                 nflags |= MNT_UPDATE;
  270         uap->flags = nflags;
  271 
  272         if (error = copyinstr((caddr_t)uap->type, fsname, sizeof fsname,
  273                               (u_int *)0))
  274                 return (error);
  275 
  276         if (strcmp(fsname, "4.2") == 0) {
  277                 uap->type = (caddr_t)STACK_ALLOC();
  278                 if (error = copyout("ufs", uap->type, sizeof("ufs")))
  279                         return (error);
  280         } else if (strcmp(fsname, "nfs") == 0) {
  281                 struct ibcs2_nfs_args sna;
  282                 struct sockaddr_in sain;
  283                 struct nfs_args na;
  284                 struct sockaddr sa;
  285 
  286                 if (error = copyin(uap->data, &sna, sizeof sna))
  287                         return (error);
  288                 if (error = copyin(sna.addr, &sain, sizeof sain))
  289                         return (error);
  290                 bcopy(&sain, &sa, sizeof sa);
  291                 sa.sa_len = sizeof(sain);
  292                 uap->data = (caddr_t)STACK_ALLOC();
  293                 na.addr = (struct sockaddr *)((int)uap->data + sizeof na);
  294                 na.sotype = SOCK_DGRAM;
  295                 na.proto = IPPROTO_UDP;
  296                 na.fh = (nfsv2fh_t *)sna.fh;
  297                 na.flags = sna.flags;
  298                 na.wsize = sna.wsize;
  299                 na.rsize = sna.rsize;
  300                 na.timeo = sna.timeo;
  301                 na.retrans = sna.retrans;
  302                 na.hostname = sna.hostname;
  303 
  304                 if (error = copyout(&sa, na.addr, sizeof sa))
  305                         return (error);
  306                 if (error = copyout(&na, uap->data, sizeof na))
  307                         return (error);
  308         }
  309         return (mount(td, uap));
  310 #else
  311         return EINVAL;
  312 #endif
  313 }
  314 
  315 /*
  316  * Read iBCS2-style directory entries.  We suck them into kernel space so
  317  * that they can be massaged before being copied out to user code.  Like
  318  * SunOS, we squish out `empty' entries.
  319  *
  320  * This is quite ugly, but what do you expect from compatibility code?
  321  */
  322 
  323 int
  324 ibcs2_getdents(td, uap)
  325         struct thread *td;
  326         register struct ibcs2_getdents_args *uap;
  327 {
  328         register struct vnode *vp;
  329         register caddr_t inp, buf;      /* BSD-format */
  330         register int len, reclen;       /* BSD-format */
  331         register caddr_t outp;          /* iBCS2-format */
  332         register int resid;             /* iBCS2-format */
  333         cap_rights_t rights;
  334         struct file *fp;
  335         struct uio auio;
  336         struct iovec aiov;
  337         struct ibcs2_dirent idb;
  338         off_t off;                      /* true file offset */
  339         int buflen, error, eofflag;
  340         u_long *cookies = NULL, *cookiep;
  341         int ncookies;
  342 #define BSD_DIRENT(cp)          ((struct dirent *)(cp))
  343 #define IBCS2_RECLEN(reclen)    (reclen + sizeof(u_short))
  344 
  345         memset(&idb, 0, sizeof(idb));
  346         error = getvnode(td, uap->fd, cap_rights_init(&rights, CAP_READ), &fp);
  347         if (error != 0)
  348                 return (error);
  349         if ((fp->f_flag & FREAD) == 0) {
  350                 fdrop(fp, td);
  351                 return (EBADF);
  352         }
  353         vp = fp->f_vnode;
  354         if (vp->v_type != VDIR) {       /* XXX  vnode readdir op should do this */
  355                 fdrop(fp, td);
  356                 return (EINVAL);
  357         }
  358 
  359         off = fp->f_offset;
  360 #define DIRBLKSIZ       512             /* XXX we used to use ufs's DIRBLKSIZ */
  361         buflen = max(DIRBLKSIZ, uap->nbytes);
  362         buflen = min(buflen, MAXBSIZE);
  363         buf = malloc(buflen, M_TEMP, M_WAITOK);
  364         vn_lock(vp, LK_SHARED | LK_RETRY);
  365 again:
  366         aiov.iov_base = buf;
  367         aiov.iov_len = buflen;
  368         auio.uio_iov = &aiov;
  369         auio.uio_iovcnt = 1;
  370         auio.uio_rw = UIO_READ;
  371         auio.uio_segflg = UIO_SYSSPACE;
  372         auio.uio_td = td;
  373         auio.uio_resid = buflen;
  374         auio.uio_offset = off;
  375 
  376         if (cookies) {
  377                 free(cookies, M_TEMP);
  378                 cookies = NULL;
  379         }
  380 
  381 #ifdef MAC
  382         error = mac_vnode_check_readdir(td->td_ucred, vp);
  383         if (error)
  384                 goto out;
  385 #endif
  386 
  387         /*
  388          * First we read into the malloc'ed buffer, then
  389          * we massage it into user space, one record at a time.
  390          */
  391         if ((error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, &ncookies, &cookies)) != 0)
  392                 goto out;
  393         inp = buf;
  394         outp = uap->buf;
  395         resid = uap->nbytes;
  396         if ((len = buflen - auio.uio_resid) <= 0)
  397                 goto eof;
  398 
  399         cookiep = cookies;
  400 
  401         if (cookies) {
  402                 /*
  403                  * When using cookies, the vfs has the option of reading from
  404                  * a different offset than that supplied (UFS truncates the
  405                  * offset to a block boundary to make sure that it never reads
  406                  * partway through a directory entry, even if the directory
  407                  * has been compacted).
  408                  */
  409                 while (len > 0 && ncookies > 0 && *cookiep <= off) {
  410                         len -= BSD_DIRENT(inp)->d_reclen;
  411                         inp += BSD_DIRENT(inp)->d_reclen;
  412                         cookiep++;
  413                         ncookies--;
  414                 }
  415         }
  416 
  417         for (; len > 0; len -= reclen) {
  418                 if (cookiep && ncookies == 0)
  419                         break;
  420                 reclen = BSD_DIRENT(inp)->d_reclen;
  421                 if (reclen & 3) {
  422                         printf("ibcs2_getdents: reclen=%d\n", reclen);
  423                         error = EFAULT;
  424                         goto out;
  425                 }
  426                 if (BSD_DIRENT(inp)->d_fileno == 0) {
  427                         inp += reclen;  /* it is a hole; squish it out */
  428                         if (cookiep) {
  429                                 off = *cookiep++;
  430                                 ncookies--;
  431                         } else
  432                                 off += reclen;
  433                         continue;
  434                 }
  435                 if (reclen > len || resid < IBCS2_RECLEN(reclen)) {
  436                         /* entry too big for buffer, so just stop */
  437                         outp++;
  438                         break;
  439                 }
  440                 /*
  441                  * Massage in place to make an iBCS2-shaped dirent (otherwise
  442                  * we have to worry about touching user memory outside of
  443                  * the copyout() call).
  444                  */
  445                 idb.d_ino = (ibcs2_ino_t)BSD_DIRENT(inp)->d_fileno;
  446                 idb.d_off = (ibcs2_off_t)off;
  447                 idb.d_reclen = (u_short)IBCS2_RECLEN(reclen);
  448                 if ((error = copyout((caddr_t)&idb, outp, 10)) != 0 ||
  449                     (error = copyout(BSD_DIRENT(inp)->d_name, outp + 10,
  450                                      BSD_DIRENT(inp)->d_namlen + 1)) != 0)
  451                         goto out;
  452                 /* advance past this real entry */
  453                 if (cookiep) {
  454                         off = *cookiep++;
  455                         ncookies--;
  456                 } else
  457                         off += reclen;
  458                 inp += reclen;
  459                 /* advance output past iBCS2-shaped entry */
  460                 outp += IBCS2_RECLEN(reclen);
  461                 resid -= IBCS2_RECLEN(reclen);
  462         }
  463         /* if we squished out the whole block, try again */
  464         if (outp == uap->buf)
  465                 goto again;
  466         fp->f_offset = off;             /* update the vnode offset */
  467 eof:
  468         td->td_retval[0] = uap->nbytes - resid;
  469 out:
  470         VOP_UNLOCK(vp, 0);
  471         fdrop(fp, td);
  472         if (cookies)
  473                 free(cookies, M_TEMP);
  474         free(buf, M_TEMP);
  475         return (error);
  476 }
  477 
  478 int
  479 ibcs2_read(td, uap)
  480         struct thread *td;
  481         struct ibcs2_read_args *uap;
  482 {
  483         register struct vnode *vp;
  484         register caddr_t inp, buf;      /* BSD-format */
  485         register int len, reclen;       /* BSD-format */
  486         register caddr_t outp;          /* iBCS2-format */
  487         register int resid;             /* iBCS2-format */
  488         cap_rights_t rights;
  489         struct file *fp;
  490         struct uio auio;
  491         struct iovec aiov;
  492         struct ibcs2_direct {
  493                 ibcs2_ino_t ino;
  494                 char name[14];
  495         } idb;
  496         off_t off;                      /* true file offset */
  497         int buflen, error, eofflag, size;
  498         u_long *cookies = NULL, *cookiep;
  499         int ncookies;
  500 
  501         error = getvnode(td, uap->fd, cap_rights_init(&rights, CAP_READ), &fp);
  502         if (error != 0) {
  503                 if (error == EINVAL)
  504                         return sys_read(td, (struct read_args *)uap);
  505                 else
  506                         return error;
  507         }
  508         if ((fp->f_flag & FREAD) == 0) {
  509                 fdrop(fp, td);
  510                 return (EBADF);
  511         }
  512         vp = fp->f_vnode;
  513         if (vp->v_type != VDIR) {
  514                 fdrop(fp, td);
  515                 return sys_read(td, (struct read_args *)uap);
  516         }
  517 
  518         off = fp->f_offset;
  519 
  520         DPRINTF(("ibcs2_read: read directory\n"));
  521 
  522         buflen = max(DIRBLKSIZ, uap->nbytes);
  523         buflen = min(buflen, MAXBSIZE);
  524         buf = malloc(buflen, M_TEMP, M_WAITOK);
  525         vn_lock(vp, LK_SHARED | LK_RETRY);
  526 again:
  527         aiov.iov_base = buf;
  528         aiov.iov_len = buflen;
  529         auio.uio_iov = &aiov;
  530         auio.uio_iovcnt = 1;
  531         auio.uio_rw = UIO_READ;
  532         auio.uio_segflg = UIO_SYSSPACE;
  533         auio.uio_td = td;
  534         auio.uio_resid = buflen;
  535         auio.uio_offset = off;
  536 
  537         if (cookies) {
  538                 free(cookies, M_TEMP);
  539                 cookies = NULL;
  540         }
  541 
  542 #ifdef MAC
  543         error = mac_vnode_check_readdir(td->td_ucred, vp);
  544         if (error)
  545                 goto out;
  546 #endif
  547 
  548         /*
  549          * First we read into the malloc'ed buffer, then
  550          * we massage it into user space, one record at a time.
  551          */
  552         if ((error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, &ncookies, &cookies)) != 0) {
  553                 DPRINTF(("VOP_READDIR failed: %d\n", error));
  554                 goto out;
  555         }
  556         inp = buf;
  557         outp = uap->buf;
  558         resid = uap->nbytes;
  559         if ((len = buflen - auio.uio_resid) <= 0)
  560                 goto eof;
  561 
  562         cookiep = cookies;
  563 
  564         if (cookies) {
  565                 /*
  566                  * When using cookies, the vfs has the option of reading from
  567                  * a different offset than that supplied (UFS truncates the
  568                  * offset to a block boundary to make sure that it never reads
  569                  * partway through a directory entry, even if the directory
  570                  * has been compacted).
  571                  */
  572                 while (len > 0 && ncookies > 0 && *cookiep <= off) {
  573                         len -= BSD_DIRENT(inp)->d_reclen;
  574                         inp += BSD_DIRENT(inp)->d_reclen;
  575                         cookiep++;
  576                         ncookies--;
  577                 }
  578         }
  579 
  580         for (; len > 0 && resid > 0; len -= reclen) {
  581                 if (cookiep && ncookies == 0)
  582                         break;
  583                 reclen = BSD_DIRENT(inp)->d_reclen;
  584                 if (reclen & 3) {
  585                         printf("ibcs2_read: reclen=%d\n", reclen);
  586                         error = EFAULT;
  587                         goto out;
  588                 }
  589                 if (BSD_DIRENT(inp)->d_fileno == 0) {
  590                         inp += reclen;  /* it is a hole; squish it out */
  591                         if (cookiep) {
  592                                 off = *cookiep++;
  593                                 ncookies--;
  594                         } else
  595                                 off += reclen;
  596                         continue;
  597                 }
  598                 if (reclen > len || resid < sizeof(struct ibcs2_direct)) {
  599                         /* entry too big for buffer, so just stop */
  600                         outp++;
  601                         break;
  602                 }
  603                 /*
  604                  * Massage in place to make an iBCS2-shaped dirent (otherwise
  605                  * we have to worry about touching user memory outside of
  606                  * the copyout() call).
  607                  *
  608                  * TODO: if length(filename) > 14, then break filename into
  609                  * multiple entries and set inode = 0xffff except last
  610                  */
  611                 idb.ino = (BSD_DIRENT(inp)->d_fileno > 0xfffe) ? 0xfffe :
  612                         BSD_DIRENT(inp)->d_fileno;
  613                 (void)copystr(BSD_DIRENT(inp)->d_name, idb.name, 14, &size);
  614                 bzero(idb.name + size, 14 - size);
  615                 if ((error = copyout(&idb, outp, sizeof(struct ibcs2_direct))) != 0)
  616                         goto out;
  617                 /* advance past this real entry */
  618                 if (cookiep) {
  619                         off = *cookiep++;
  620                         ncookies--;
  621                 } else
  622                         off += reclen;
  623                 inp += reclen;
  624                 /* advance output past iBCS2-shaped entry */
  625                 outp += sizeof(struct ibcs2_direct);
  626                 resid -= sizeof(struct ibcs2_direct);
  627         }
  628         /* if we squished out the whole block, try again */
  629         if (outp == uap->buf)
  630                 goto again;
  631         fp->f_offset = off;             /* update the vnode offset */
  632 eof:
  633         td->td_retval[0] = uap->nbytes - resid;
  634 out:
  635         VOP_UNLOCK(vp, 0);
  636         fdrop(fp, td);
  637         if (cookies)
  638                 free(cookies, M_TEMP);
  639         free(buf, M_TEMP);
  640         return (error);
  641 }
  642 
  643 int
  644 ibcs2_mknod(td, uap)
  645         struct thread *td;
  646         struct ibcs2_mknod_args *uap;
  647 {
  648         char *path;
  649         int error;
  650 
  651         CHECKALTCREAT(td, uap->path, &path);
  652         if (S_ISFIFO(uap->mode)) {
  653                 error = kern_mkfifoat(td, AT_FDCWD, path,
  654                     UIO_SYSSPACE, uap->mode);
  655         } else {
  656                 error = kern_mknodat(td, AT_FDCWD, path, UIO_SYSSPACE,
  657                     uap->mode, uap->dev);
  658         }
  659         free(path, M_TEMP);
  660         return (error);
  661 }
  662 
  663 int
  664 ibcs2_getgroups(td, uap)
  665         struct thread *td;
  666         struct ibcs2_getgroups_args *uap;
  667 {
  668         struct ucred *cred;
  669         ibcs2_gid_t *iset;
  670         u_int i, ngrp;
  671         int error;
  672 
  673         cred = td->td_ucred;
  674         ngrp = cred->cr_ngroups;
  675 
  676         if (uap->gidsetsize == 0) {
  677                 error = 0;
  678                 goto out;
  679         }
  680         if (uap->gidsetsize < ngrp)
  681                 return (EINVAL);
  682 
  683         iset = malloc(ngrp * sizeof(*iset), M_TEMP, M_WAITOK);
  684         for (i = 0; i < ngrp; i++)
  685                 iset[i] = (ibcs2_gid_t)cred->cr_groups[i];
  686         error = copyout(iset, uap->gidset, ngrp * sizeof(ibcs2_gid_t));
  687         free(iset, M_TEMP);
  688 out:
  689         td->td_retval[0] = ngrp;
  690         return (error);
  691 }
  692 
  693 int
  694 ibcs2_setgroups(td, uap)
  695         struct thread *td;
  696         struct ibcs2_setgroups_args *uap;
  697 {
  698         ibcs2_gid_t *iset;
  699         gid_t *gp;
  700         int error, i;
  701 
  702         if (uap->gidsetsize < 0 || uap->gidsetsize > ngroups_max + 1)
  703                 return (EINVAL);
  704         if (uap->gidsetsize && uap->gidset == NULL)
  705                 return (EINVAL);
  706         gp = malloc(uap->gidsetsize * sizeof(*gp), M_TEMP, M_WAITOK);
  707         if (uap->gidsetsize) {
  708                 iset = malloc(uap->gidsetsize * sizeof(*iset), M_TEMP, M_WAITOK);
  709                 error = copyin(uap->gidset, iset, sizeof(ibcs2_gid_t) *
  710                     uap->gidsetsize);
  711                 if (error) {
  712                         free(iset, M_TEMP);
  713                         goto out;
  714                 }
  715                 for (i = 0; i < uap->gidsetsize; i++)
  716                         gp[i] = (gid_t)iset[i];
  717         }
  718 
  719         error = kern_setgroups(td, uap->gidsetsize, gp);
  720 out:
  721         free(gp, M_TEMP);
  722         return (error);
  723 }
  724 
  725 int
  726 ibcs2_setuid(td, uap)
  727         struct thread *td;
  728         struct ibcs2_setuid_args *uap;
  729 {
  730         struct setuid_args sa;
  731 
  732         sa.uid = (uid_t)uap->uid;
  733         return sys_setuid(td, &sa);
  734 }
  735 
  736 int
  737 ibcs2_setgid(td, uap)
  738         struct thread *td;
  739         struct ibcs2_setgid_args *uap;
  740 {
  741         struct setgid_args sa;
  742 
  743         sa.gid = (gid_t)uap->gid;
  744         return sys_setgid(td, &sa);
  745 }
  746 
  747 int
  748 ibcs2_time(td, uap)
  749         struct thread *td;
  750         struct ibcs2_time_args *uap;
  751 {
  752         struct timeval tv;
  753 
  754         microtime(&tv);
  755         td->td_retval[0] = tv.tv_sec;
  756         if (uap->tp)
  757                 return copyout((caddr_t)&tv.tv_sec, (caddr_t)uap->tp,
  758                                sizeof(ibcs2_time_t));
  759         else
  760                 return 0;
  761 }
  762 
  763 int
  764 ibcs2_pathconf(td, uap)
  765         struct thread *td;
  766         struct ibcs2_pathconf_args *uap;
  767 {
  768         char *path;
  769         int error;
  770 
  771         CHECKALTEXIST(td, uap->path, &path);
  772         uap->name++;    /* iBCS2 _PC_* defines are offset by one */
  773         error = kern_pathconf(td, path, UIO_SYSSPACE, uap->name, FOLLOW);
  774         free(path, M_TEMP);
  775         return (error);
  776 }
  777 
  778 int
  779 ibcs2_fpathconf(td, uap)
  780         struct thread *td;
  781         struct ibcs2_fpathconf_args *uap;
  782 {
  783         uap->name++;    /* iBCS2 _PC_* defines are offset by one */
  784         return sys_fpathconf(td, (struct fpathconf_args *)uap);
  785 }
  786 
  787 int
  788 ibcs2_sysconf(td, uap)
  789         struct thread *td;
  790         struct ibcs2_sysconf_args *uap;
  791 {
  792         int mib[2], value, len, error;
  793 
  794         switch(uap->name) {
  795         case IBCS2_SC_ARG_MAX:
  796                 mib[1] = KERN_ARGMAX;
  797                 break;
  798 
  799         case IBCS2_SC_CHILD_MAX:
  800                 td->td_retval[0] = lim_cur(td, RLIMIT_NPROC);
  801                 return 0;
  802 
  803         case IBCS2_SC_CLK_TCK:
  804                 td->td_retval[0] = hz;
  805                 return 0;
  806 
  807         case IBCS2_SC_NGROUPS_MAX:
  808                 mib[1] = KERN_NGROUPS;
  809                 break;
  810 
  811         case IBCS2_SC_OPEN_MAX:
  812                 td->td_retval[0] = lim_cur(td, RLIMIT_NOFILE);
  813                 return 0;
  814                 
  815         case IBCS2_SC_JOB_CONTROL:
  816                 mib[1] = KERN_JOB_CONTROL;
  817                 break;
  818                 
  819         case IBCS2_SC_SAVED_IDS:
  820                 mib[1] = KERN_SAVED_IDS;
  821                 break;
  822                 
  823         case IBCS2_SC_VERSION:
  824                 mib[1] = KERN_POSIX1;
  825                 break;
  826                 
  827         case IBCS2_SC_PASS_MAX:
  828                 td->td_retval[0] = 128;         /* XXX - should we create PASS_MAX ? */
  829                 return 0;
  830 
  831         case IBCS2_SC_XOPEN_VERSION:
  832                 td->td_retval[0] = 2;           /* XXX: What should that be? */
  833                 return 0;
  834                 
  835         default:
  836                 return EINVAL;
  837         }
  838 
  839         mib[0] = CTL_KERN;
  840         len = sizeof(value);
  841         error = kernel_sysctl(td, mib, 2, &value, &len, NULL, 0, NULL, 0);
  842         if (error)
  843                 return error;
  844         td->td_retval[0] = value;
  845         return 0;
  846 }
  847 
  848 int
  849 ibcs2_alarm(td, uap)
  850         struct thread *td;
  851         struct ibcs2_alarm_args *uap;
  852 {
  853         struct itimerval itv, oitv;
  854         int error;
  855 
  856         timevalclear(&itv.it_interval);
  857         itv.it_value.tv_sec = uap->sec;
  858         itv.it_value.tv_usec = 0;
  859         error = kern_setitimer(td, ITIMER_REAL, &itv, &oitv);
  860         if (error)
  861                 return (error);
  862         if (oitv.it_value.tv_usec != 0)
  863                 oitv.it_value.tv_sec++;
  864         td->td_retval[0] = oitv.it_value.tv_sec;
  865         return (0);
  866 }
  867 
  868 int
  869 ibcs2_times(td, uap)
  870         struct thread *td;
  871         struct ibcs2_times_args *uap;
  872 {
  873         struct rusage ru;
  874         struct timeval t;
  875         struct tms tms;
  876         int error;
  877 
  878 #define CONVTCK(r)      (r.tv_sec * hz + r.tv_usec / (1000000 / hz))
  879 
  880         error = kern_getrusage(td, RUSAGE_SELF, &ru);
  881         if (error)
  882                 return (error);
  883         tms.tms_utime = CONVTCK(ru.ru_utime);
  884         tms.tms_stime = CONVTCK(ru.ru_stime);
  885 
  886         error = kern_getrusage(td, RUSAGE_CHILDREN, &ru);
  887         if (error)
  888                 return (error);
  889         tms.tms_cutime = CONVTCK(ru.ru_utime);
  890         tms.tms_cstime = CONVTCK(ru.ru_stime);
  891 
  892         microtime(&t);
  893         td->td_retval[0] = CONVTCK(t);
  894         
  895         return (copyout(&tms, uap->tp, sizeof(struct tms)));
  896 }
  897 
  898 int
  899 ibcs2_stime(td, uap)
  900         struct thread *td;
  901         struct ibcs2_stime_args *uap;
  902 {
  903         struct timeval tv;
  904         long secs;
  905         int error;
  906 
  907         error = copyin(uap->timep, &secs, sizeof(long));
  908         if (error)
  909                 return (error);
  910         tv.tv_sec = secs;
  911         tv.tv_usec = 0;
  912         error = kern_settimeofday(td, &tv, NULL);
  913         if (error)
  914                 error = EPERM;
  915         return (error);
  916 }
  917 
  918 int
  919 ibcs2_utime(td, uap)
  920         struct thread *td;
  921         struct ibcs2_utime_args *uap;
  922 {
  923         struct ibcs2_utimbuf ubuf;
  924         struct timeval tbuf[2], *tp;
  925         char *path;
  926         int error;
  927 
  928         if (uap->buf) {
  929                 error = copyin(uap->buf, &ubuf, sizeof(ubuf));
  930                 if (error)
  931                         return (error);
  932                 tbuf[0].tv_sec = ubuf.actime;
  933                 tbuf[0].tv_usec = 0;
  934                 tbuf[1].tv_sec = ubuf.modtime;
  935                 tbuf[1].tv_usec = 0;
  936                 tp = tbuf;
  937         } else
  938                 tp = NULL;
  939 
  940         CHECKALTEXIST(td, uap->path, &path);
  941         error = kern_utimesat(td, AT_FDCWD, path, UIO_SYSSPACE,
  942             tp, UIO_SYSSPACE);
  943         free(path, M_TEMP);
  944         return (error);
  945 }
  946 
  947 int
  948 ibcs2_nice(td, uap)
  949         struct thread *td;
  950         struct ibcs2_nice_args *uap;
  951 {
  952         int error;
  953         struct setpriority_args sa;
  954 
  955         sa.which = PRIO_PROCESS;
  956         sa.who = 0;
  957         sa.prio = td->td_proc->p_nice + uap->incr;
  958         if ((error = sys_setpriority(td, &sa)) != 0)
  959                 return EPERM;
  960         td->td_retval[0] = td->td_proc->p_nice;
  961         return 0;
  962 }
  963 
  964 /*
  965  * iBCS2 getpgrp, setpgrp, setsid, and setpgid
  966  */
  967 
  968 int
  969 ibcs2_pgrpsys(td, uap)
  970         struct thread *td;
  971         struct ibcs2_pgrpsys_args *uap;
  972 {
  973         struct proc *p = td->td_proc;
  974         switch (uap->type) {
  975         case 0:                 /* getpgrp */
  976                 PROC_LOCK(p);
  977                 td->td_retval[0] = p->p_pgrp->pg_id;
  978                 PROC_UNLOCK(p);
  979                 return 0;
  980 
  981         case 1:                 /* setpgrp */
  982             {
  983                 struct setpgid_args sa;
  984 
  985                 sa.pid = 0;
  986                 sa.pgid = 0;
  987                 sys_setpgid(td, &sa);
  988                 PROC_LOCK(p);
  989                 td->td_retval[0] = p->p_pgrp->pg_id;
  990                 PROC_UNLOCK(p);
  991                 return 0;
  992             }
  993 
  994         case 2:                 /* setpgid */
  995             {
  996                 struct setpgid_args sa;
  997 
  998                 sa.pid = uap->pid;
  999                 sa.pgid = uap->pgid;
 1000                 return sys_setpgid(td, &sa);
 1001             }
 1002 
 1003         case 3:                 /* setsid */
 1004                 return sys_setsid(td, NULL);
 1005 
 1006         default:
 1007                 return EINVAL;
 1008         }
 1009 }
 1010 
 1011 /*
 1012  * XXX - need to check for nested calls
 1013  */
 1014 
 1015 int
 1016 ibcs2_plock(td, uap)
 1017         struct thread *td;
 1018         struct ibcs2_plock_args *uap;
 1019 {
 1020         int error;
 1021 #define IBCS2_UNLOCK    0
 1022 #define IBCS2_PROCLOCK  1
 1023 #define IBCS2_TEXTLOCK  2
 1024 #define IBCS2_DATALOCK  4
 1025 
 1026         
 1027         switch(uap->cmd) {
 1028         case IBCS2_UNLOCK:
 1029                 error = priv_check(td, PRIV_VM_MUNLOCK);
 1030                 if (error)
 1031                         return (error);
 1032                 /* XXX - TODO */
 1033                 return (0);
 1034 
 1035         case IBCS2_PROCLOCK:
 1036         case IBCS2_TEXTLOCK:
 1037         case IBCS2_DATALOCK:
 1038                 error = priv_check(td, PRIV_VM_MLOCK);
 1039                 if (error)
 1040                         return (error);
 1041                 /* XXX - TODO */
 1042                 return 0;
 1043         }
 1044         return EINVAL;
 1045 }
 1046 
 1047 int
 1048 ibcs2_uadmin(td, uap)
 1049         struct thread *td;
 1050         struct ibcs2_uadmin_args *uap;
 1051 {
 1052 #define SCO_A_REBOOT        1
 1053 #define SCO_A_SHUTDOWN      2
 1054 #define SCO_A_REMOUNT       4
 1055 #define SCO_A_CLOCK         8
 1056 #define SCO_A_SETCONFIG     128
 1057 #define SCO_A_GETDEV        130
 1058 
 1059 #define SCO_AD_HALT         0
 1060 #define SCO_AD_BOOT         1
 1061 #define SCO_AD_IBOOT        2
 1062 #define SCO_AD_PWRDOWN      3
 1063 #define SCO_AD_PWRNAP       4
 1064 
 1065 #define SCO_AD_PANICBOOT    1
 1066 
 1067 #define SCO_AD_GETBMAJ      0
 1068 #define SCO_AD_GETCMAJ      1
 1069 
 1070         switch(uap->cmd) {
 1071         case SCO_A_REBOOT:
 1072         case SCO_A_SHUTDOWN:
 1073                 switch(uap->func) {
 1074                         struct reboot_args r;
 1075                 case SCO_AD_HALT:
 1076                 case SCO_AD_PWRDOWN:
 1077                 case SCO_AD_PWRNAP:
 1078                         r.opt = RB_HALT;
 1079                         return (sys_reboot(td, &r));
 1080                 case SCO_AD_BOOT:
 1081                 case SCO_AD_IBOOT:
 1082                         r.opt = RB_AUTOBOOT;
 1083                         return (sys_reboot(td, &r));
 1084                 }
 1085                 return EINVAL;
 1086         case SCO_A_REMOUNT:
 1087         case SCO_A_CLOCK:
 1088         case SCO_A_SETCONFIG:
 1089                 return 0;
 1090         case SCO_A_GETDEV:
 1091                 return EINVAL;  /* XXX - TODO */
 1092         }
 1093         return EINVAL;
 1094 }
 1095 
 1096 int
 1097 ibcs2_sysfs(td, uap)
 1098         struct thread *td;
 1099         struct ibcs2_sysfs_args *uap;
 1100 {
 1101 #define IBCS2_GETFSIND        1
 1102 #define IBCS2_GETFSTYP        2
 1103 #define IBCS2_GETNFSTYP       3
 1104 
 1105         switch(uap->cmd) {
 1106         case IBCS2_GETFSIND:
 1107         case IBCS2_GETFSTYP:
 1108         case IBCS2_GETNFSTYP:
 1109                 break;
 1110         }
 1111         return EINVAL;          /* XXX - TODO */
 1112 }
 1113 
 1114 int
 1115 ibcs2_unlink(td, uap)
 1116         struct thread *td;
 1117         struct ibcs2_unlink_args *uap;
 1118 {
 1119         char *path;
 1120         int error;
 1121 
 1122         CHECKALTEXIST(td, uap->path, &path);
 1123         error = kern_unlinkat(td, AT_FDCWD, path, UIO_SYSSPACE, 0);
 1124         free(path, M_TEMP);
 1125         return (error);
 1126 }
 1127 
 1128 int
 1129 ibcs2_chdir(td, uap)
 1130         struct thread *td;
 1131         struct ibcs2_chdir_args *uap;
 1132 {
 1133         char *path;
 1134         int error;
 1135 
 1136         CHECKALTEXIST(td, uap->path, &path);
 1137         error = kern_chdir(td, path, UIO_SYSSPACE);
 1138         free(path, M_TEMP);
 1139         return (error);
 1140 }
 1141 
 1142 int
 1143 ibcs2_chmod(td, uap)
 1144         struct thread *td;
 1145         struct ibcs2_chmod_args *uap;
 1146 {
 1147         char *path;
 1148         int error;
 1149 
 1150         CHECKALTEXIST(td, uap->path, &path);
 1151         error = kern_fchmodat(td, AT_FDCWD, path, UIO_SYSSPACE, uap->mode, 0);
 1152         free(path, M_TEMP);
 1153         return (error);
 1154 }
 1155 
 1156 int
 1157 ibcs2_chown(td, uap)
 1158         struct thread *td;
 1159         struct ibcs2_chown_args *uap;
 1160 {
 1161         char *path;
 1162         int error;
 1163 
 1164         CHECKALTEXIST(td, uap->path, &path);
 1165         error = kern_fchownat(td, AT_FDCWD, path, UIO_SYSSPACE, uap->uid,
 1166             uap->gid, 0);
 1167         free(path, M_TEMP);
 1168         return (error);
 1169 }
 1170 
 1171 int
 1172 ibcs2_rmdir(td, uap)
 1173         struct thread *td;
 1174         struct ibcs2_rmdir_args *uap;
 1175 {
 1176         char *path;
 1177         int error;
 1178 
 1179         CHECKALTEXIST(td, uap->path, &path);
 1180         error = kern_rmdirat(td, AT_FDCWD, path, UIO_SYSSPACE);
 1181         free(path, M_TEMP);
 1182         return (error);
 1183 }
 1184 
 1185 int
 1186 ibcs2_mkdir(td, uap)
 1187         struct thread *td;
 1188         struct ibcs2_mkdir_args *uap;
 1189 {
 1190         char *path;
 1191         int error;
 1192 
 1193         CHECKALTEXIST(td, uap->path, &path);
 1194         error = kern_mkdirat(td, AT_FDCWD, path, UIO_SYSSPACE, uap->mode);
 1195         free(path, M_TEMP);
 1196         return (error);
 1197 }
 1198 
 1199 int
 1200 ibcs2_symlink(td, uap)
 1201         struct thread *td;
 1202         struct ibcs2_symlink_args *uap;
 1203 {
 1204         char *path, *link;
 1205         int error;
 1206 
 1207         CHECKALTEXIST(td, uap->path, &path);
 1208 
 1209         /*
 1210          * Have to expand CHECKALTCREAT() so that 'path' can be freed on
 1211          * errors.
 1212          */
 1213         error = ibcs2_emul_find(td, uap->link, UIO_USERSPACE, &link, 1);
 1214         if (link == NULL) {
 1215                 free(path, M_TEMP);
 1216                 return (error);
 1217         }
 1218         error = kern_symlinkat(td, path, AT_FDCWD, link, UIO_SYSSPACE);
 1219         free(path, M_TEMP);
 1220         free(link, M_TEMP);
 1221         return (error);
 1222 }
 1223 
 1224 int
 1225 ibcs2_rename(td, uap)
 1226         struct thread *td;
 1227         struct ibcs2_rename_args *uap;
 1228 {
 1229         char *from, *to;
 1230         int error;
 1231 
 1232         CHECKALTEXIST(td, uap->from, &from);
 1233 
 1234         /*
 1235          * Have to expand CHECKALTCREAT() so that 'from' can be freed on
 1236          * errors.
 1237          */
 1238         error = ibcs2_emul_find(td, uap->to, UIO_USERSPACE, &to, 1);
 1239         if (to == NULL) {
 1240                 free(from, M_TEMP);
 1241                 return (error);
 1242         }
 1243         error = kern_renameat(td, AT_FDCWD, from, AT_FDCWD, to, UIO_SYSSPACE);
 1244         free(from, M_TEMP);
 1245         free(to, M_TEMP);
 1246         return (error);
 1247 }
 1248 
 1249 int
 1250 ibcs2_readlink(td, uap)
 1251         struct thread *td;
 1252         struct ibcs2_readlink_args *uap;
 1253 {
 1254         char *path;
 1255         int error;
 1256 
 1257         CHECKALTEXIST(td, uap->path, &path);
 1258         error = kern_readlinkat(td, AT_FDCWD, path, UIO_SYSSPACE,
 1259             uap->buf, UIO_USERSPACE, uap->count);
 1260         free(path, M_TEMP);
 1261         return (error);
 1262 }

Cache object: a3d405ceb0f632e40945d550b9028606


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.