xnu-1699.32.7.tar.gz

[apple/xnu.git] / bsd / kern / sys_generic.c

diff --git a/bsd/kern/sys_generic.c b/bsd/kern/sys_generic.c
index 509468087c76eb31fcbfd922eb3c29a9e1d3c256..bacd02b79d8b19d6820b89d742e764cbb871ca7b 100644 (file)
--- a/bsd/kern/sys_generic.c
+++ b/bsd/kern/sys_generic.c
@@ -108,7 +108,7 @@
 #include <sys/syscall.h>
 #include <sys/pipe.h>
 
 #include <sys/syscall.h>
 #include <sys/pipe.h>
 

-#include <bsm/audit_kernel.h>
+#include <security/audit/audit.h>

 
 #include <net/if.h>
 #include <net/route.h>
 
 #include <net/if.h>
 #include <net/route.h>


@@ -152,6 +152,21 @@ __private_extern__ int     dofilewrite(vfs_context_t ctx, struct fileproc *fp,
 __private_extern__ int preparefileread(struct proc *p, struct fileproc **fp_ret, int fd, int check_for_vnode);
 __private_extern__ void        donefileread(struct proc *p, struct fileproc *fp_ret, int fd);
 
 __private_extern__ int preparefileread(struct proc *p, struct fileproc **fp_ret, int fd, int check_for_vnode);
 __private_extern__ void        donefileread(struct proc *p, struct fileproc *fp_ret, int fd);
 

+
+/* Conflict wait queue for when selects collide (opaque type) */
+struct wait_queue select_conflict_queue;
+
+/*
+ * Init routine called from bsd_init.c
+ */
+void select_wait_queue_init(void);
+void
+select_wait_queue_init(void)
+{
+       wait_queue_init(&select_conflict_queue, SYNC_POLICY_FIFO);
+}
+
+

 #if NETAT
 extern int appletalk_inited;
 #endif /* NETAT */
 #if NETAT
 extern int appletalk_inited;
 #endif /* NETAT */


@@ -187,11 +202,15 @@ read_nocancel(struct proc *p, struct read_nocancel_args *uap, user_ssize_t *retv
        struct fileproc *fp;
        int error;
        int fd = uap->fd;
        struct fileproc *fp;
        int error;
        int fd = uap->fd;

+       struct vfs_context context;

 
        if ( (error = preparefileread(p, &fp, fd, 0)) )
                return (error);
 
 
        if ( (error = preparefileread(p, &fp, fd, 0)) )
                return (error);
 

-       error = dofileread(vfs_context_current(), fp, uap->cbuf, uap->nbyte,
+       context = *(vfs_context_current());
+       context.vc_ucred = fp->f_fglob->fg_cred;
+
+       error = dofileread(&context, fp, uap->cbuf, uap->nbyte,

                           (off_t)-1, 0, retval);
 
        donefileread(p, fp, fd);
                           (off_t)-1, 0, retval);
 
        donefileread(p, fp, fd);


@@ -222,17 +241,20 @@ pread_nocancel(struct proc *p, struct pread_nocancel_args *uap, user_ssize_t *re
        struct fileproc *fp = NULL;     /* fp set by preparefileread() */
        int fd = uap->fd;
        int error;
        struct fileproc *fp = NULL;     /* fp set by preparefileread() */
        int fd = uap->fd;
        int error;

+       struct vfs_context context;

 
        if ( (error = preparefileread(p, &fp, fd, 1)) )
                goto out;
 
 
        if ( (error = preparefileread(p, &fp, fd, 1)) )
                goto out;
 

-       error = dofileread(vfs_context_current(), fp, uap->buf, uap->nbyte,
+       context = *(vfs_context_current());
+       context.vc_ucred = fp->f_fglob->fg_cred;
+
+       error = dofileread(&context, fp, uap->buf, uap->nbyte,

                        uap->offset, FOF_OFFSET, retval);
        
        donefileread(p, fp, fd);
 
                        uap->offset, FOF_OFFSET, retval);
        
        donefileread(p, fp, fd);
 

-       if (!error)
-           KERNEL_DEBUG_CONSTANT((BSDDBG_CODE(DBG_BSD_SC_EXTENDED_INFO, SYS_pread) | DBG_FUNC_NONE),
+       KERNEL_DEBUG_CONSTANT((BSDDBG_CODE(DBG_BSD_SC_EXTENDED_INFO, SYS_pread) | DBG_FUNC_NONE),

              uap->fd, uap->nbyte, (unsigned int)((uap->offset >> 32)), (unsigned int)(uap->offset), 0);
 
 out:
              uap->fd, uap->nbyte, (unsigned int)((uap->offset >> 32)), (unsigned int)(uap->offset), 0);
 
 out:


@@ -269,6 +291,8 @@ preparefileread(struct proc *p, struct fileproc **fp_ret, int fd, int check_for_
        int     error;
        struct fileproc *fp;
 
        int     error;
        struct fileproc *fp;
 

+       AUDIT_ARG(fd, fd);
+

        proc_fdlock_spin(p);
 
        error = fp_lookup(p, fd, &fp, 1);
        proc_fdlock_spin(p);
 
        error = fp_lookup(p, fd, &fp, 1);


@@ -327,7 +351,6 @@ dofileread(vfs_context_t ctx, struct fileproc *fp,
        long error = 0;
        char uio_buf[ UIO_SIZEOF(1) ];
 
        long error = 0;
        char uio_buf[ UIO_SIZEOF(1) ];
 

-       // LP64todo - do we want to raise this?

        if (nbyte > INT_MAX)
                return (EINVAL);
 
        if (nbyte > INT_MAX)
                return (EINVAL);
 


@@ -375,7 +398,6 @@ readv_nocancel(struct proc *p, struct readv_nocancel_args *uap, user_ssize_t *re
 {
        uio_t auio = NULL;
        int error;
 {
        uio_t auio = NULL;
        int error;

-       int size_of_iovec;

        struct user_iovec *iovp;
 
        /* Verify range bedfore calling uio_create() */
        struct user_iovec *iovp;
 
        /* Verify range bedfore calling uio_create() */


@@ -395,8 +417,9 @@ readv_nocancel(struct proc *p, struct readv_nocancel_args *uap, user_ssize_t *re
                error = ENOMEM;
                goto ExitThisRoutine;
        }
                error = ENOMEM;
                goto ExitThisRoutine;
        }

-       size_of_iovec = (IS_64BIT_PROCESS(p) ? sizeof(struct user_iovec) : sizeof(struct iovec));
-       error = copyin(uap->iovp, (caddr_t)iovp, (uap->iovcnt * size_of_iovec));
+       error = copyin_user_iovec_array(uap->iovp,
+               IS_64BIT_PROCESS(p) ? UIO_USERSPACE64 : UIO_USERSPACE32,
+               uap->iovcnt, iovp);

        if (error) {
                goto ExitThisRoutine;
        }
        if (error) {
                goto ExitThisRoutine;
        }


@@ -436,6 +459,8 @@ write_nocancel(struct proc *p, struct write_nocancel_args *uap, user_ssize_t *re
        int error;      
        int fd = uap->fd;
 
        int error;      
        int fd = uap->fd;
 

+       AUDIT_ARG(fd, fd);
+

        error = fp_lookup(p,fd,&fp,0);
        if (error)
                return(error);
        error = fp_lookup(p,fd,&fp,0);
        if (error)
                return(error);


@@ -481,6 +506,8 @@ pwrite_nocancel(struct proc *p, struct pwrite_nocancel_args *uap, user_ssize_t *
        int fd = uap->fd;
        vnode_t vp  = (vnode_t)0;
 
        int fd = uap->fd;
        vnode_t vp  = (vnode_t)0;
 

+       AUDIT_ARG(fd, fd);
+

        error = fp_lookup(p,fd,&fp,0);
        if (error)
                return(error);
        error = fp_lookup(p,fd,&fp,0);
        if (error)
                return(error);


@@ -518,8 +545,7 @@ errout:
        else
                fp_drop(p, fd, fp, 0);
 
        else
                fp_drop(p, fd, fp, 0);
 

-       if (!error)
-           KERNEL_DEBUG_CONSTANT((BSDDBG_CODE(DBG_BSD_SC_EXTENDED_INFO, SYS_pwrite) | DBG_FUNC_NONE),
+       KERNEL_DEBUG_CONSTANT((BSDDBG_CODE(DBG_BSD_SC_EXTENDED_INFO, SYS_pwrite) | DBG_FUNC_NONE),

              uap->fd, uap->nbyte, (unsigned int)((uap->offset >> 32)), (unsigned int)(uap->offset), 0);
        
         return(error);
              uap->fd, uap->nbyte, (unsigned int)((uap->offset >> 32)), (unsigned int)(uap->offset), 0);
        
         return(error);


@@ -541,7 +567,6 @@ dofilewrite(vfs_context_t ctx, struct fileproc *fp,
        user_ssize_t bytecnt;
        char uio_buf[ UIO_SIZEOF(1) ];
 
        user_ssize_t bytecnt;
        char uio_buf[ UIO_SIZEOF(1) ];
 

-       // LP64todo - do we want to raise this?

        if (nbyte > INT_MAX)   
                return (EINVAL);
 
        if (nbyte > INT_MAX)   
                return (EINVAL);
 


@@ -560,7 +585,8 @@ dofilewrite(vfs_context_t ctx, struct fileproc *fp,
                        error == EINTR || error == EWOULDBLOCK))
                        error = 0;
                /* The socket layer handles SIGPIPE */
                        error == EINTR || error == EWOULDBLOCK))
                        error = 0;
                /* The socket layer handles SIGPIPE */

-               if (error == EPIPE && fp->f_type != DTYPE_SOCKET) {
+               if (error == EPIPE && fp->f_type != DTYPE_SOCKET &&
+                   (fp->f_fglob->fg_lflags & FG_NOSIGPIPE) == 0) {

                        /* XXX Raise the signal on the thread? */
                        psignal(vfs_context_proc(ctx), SIGPIPE);
                }
                        /* XXX Raise the signal on the thread? */
                        psignal(vfs_context_proc(ctx), SIGPIPE);
                }


@@ -586,9 +612,10 @@ writev_nocancel(struct proc *p, struct writev_nocancel_args *uap, user_ssize_t *
 {
        uio_t auio = NULL;
        int error;
 {
        uio_t auio = NULL;
        int error;

-       int size_of_iovec;

        struct user_iovec *iovp;
 
        struct user_iovec *iovp;
 

+       AUDIT_ARG(fd, uap->fd);
+

        /* Verify range bedfore calling uio_create() */
        if (uap->iovcnt <= 0 || uap->iovcnt > UIO_MAXIOV)
                return (EINVAL);
        /* Verify range bedfore calling uio_create() */
        if (uap->iovcnt <= 0 || uap->iovcnt > UIO_MAXIOV)
                return (EINVAL);


@@ -606,8 +633,9 @@ writev_nocancel(struct proc *p, struct writev_nocancel_args *uap, user_ssize_t *
                error = ENOMEM;
                goto ExitThisRoutine;
        }
                error = ENOMEM;
                goto ExitThisRoutine;
        }

-       size_of_iovec = (IS_64BIT_PROCESS(p) ? sizeof(struct user_iovec) : sizeof(struct iovec));
-       error = copyin(uap->iovp, (caddr_t)iovp, (uap->iovcnt * size_of_iovec));
+       error = copyin_user_iovec_array(uap->iovp,
+               IS_64BIT_PROCESS(p) ? UIO_USERSPACE64 : UIO_USERSPACE32,
+               uap->iovcnt, iovp);

        if (error) {
                goto ExitThisRoutine;
        }
        if (error) {
                goto ExitThisRoutine;
        }


@@ -650,13 +678,14 @@ wr_uio(struct proc *p, int fdes, uio_t uio, user_ssize_t *retval)
                                                error == EINTR || error == EWOULDBLOCK))
                        error = 0;
                /* The socket layer handles SIGPIPE */
                                                error == EINTR || error == EWOULDBLOCK))
                        error = 0;
                /* The socket layer handles SIGPIPE */

-               if (error == EPIPE && fp->f_type != DTYPE_SOCKET)
+               if (error == EPIPE && fp->f_type != DTYPE_SOCKET &&
+                   (fp->f_fglob->fg_lflags & FG_NOSIGPIPE) == 0)

                        psignal(p, SIGPIPE);
        }
        *retval = count - uio_resid(uio);
 
 out:
                        psignal(p, SIGPIPE);
        }
        *retval = count - uio_resid(uio);
 
 out:

-       if ( (error == 0) )
+       if (error == 0)

                fp_drop_written(p, fdes, fp);
        else
                fp_drop(p, fdes, fp, 0);
                fp_drop_written(p, fdes, fp);
        else
                fp_drop(p, fdes, fp, 0);


@@ -707,7 +736,7 @@ rd_uio(struct proc *p, int fdes, uio_t uio, user_ssize_t *retval)
  *     fo_ioctl:???
  */
 int
  *     fo_ioctl:???
  */
 int

-ioctl(struct proc *p, struct ioctl_args *uap, __unused register_t *retval)
+ioctl(struct proc *p, struct ioctl_args *uap, __unused int32_t *retval)

 {
        struct fileproc *fp;
        u_long com;
 {
        struct fileproc *fp;
        u_long com;


@@ -722,10 +751,15 @@ ioctl(struct proc *p, struct ioctl_args *uap, __unused register_t *retval)
        struct vfs_context context = *vfs_context_current();
 
        AUDIT_ARG(fd, uap->fd);
        struct vfs_context context = *vfs_context_current();
 
        AUDIT_ARG(fd, uap->fd);

-       AUDIT_ARG(cmd, CAST_DOWN(int, uap->com)); /* LP64todo: uap->com is a user-land long */

        AUDIT_ARG(addr, uap->data);
 
        is64bit = proc_is64bit(p);
        AUDIT_ARG(addr, uap->data);
 
        is64bit = proc_is64bit(p);

+#if CONFIG_AUDIT
+       if (is64bit)
+               AUDIT_ARG(value64, uap->com);
+       else
+               AUDIT_ARG(cmd, CAST_DOWN_EXPLICIT(int, uap->com));
+#endif /* CONFIG_AUDIT */

 
        proc_fdlock(p);
        error = fp_lookup(p,fd,&fp,1);
 
        proc_fdlock(p);
        error = fp_lookup(p,fd,&fp,1);


@@ -919,11 +953,10 @@ int       selwait, nselcoll;
 extern int selcontinue(int error);
 extern int selprocess(int error, int sel_pass);
 static int selscan(struct proc *p, struct _select * sel,
 extern int selcontinue(int error);
 extern int selprocess(int error, int sel_pass);
 static int selscan(struct proc *p, struct _select * sel,

-                       int nfd, register_t *retval, int sel_pass, wait_queue_sub_t wqsub);
-static int selcount(struct proc *p, u_int32_t *ibits, u_int32_t *obits,
-                       int nfd, int * count, int *kfcount);
+                       int nfd, int32_t *retval, int sel_pass, wait_queue_sub_t wqsub);
+static int selcount(struct proc *p, u_int32_t *ibits, int nfd, int *count);
+static int seldrop_locked(struct proc *p, u_int32_t *ibits, int nfd, int lim, int *need_wakeup, int fromselcount);

 static int seldrop(struct proc *p, u_int32_t *ibits, int nfd);
 static int seldrop(struct proc *p, u_int32_t *ibits, int nfd);

-extern uint64_t        tvtoabstime(struct timeval      *tvp);

 
 /*
  * Select system call.
 
 /*
  * Select system call.


@@ -934,14 +967,14 @@ extern uint64_t   tvtoabstime(struct timeval      *tvp);
  *     selprocess:???
  */
 int
  *     selprocess:???
  */
 int

-select(struct proc *p, struct select_args *uap, register_t *retval)
+select(struct proc *p, struct select_args *uap, int32_t *retval)

 {
        __pthread_testcancel(1);
        return(select_nocancel(p, (struct select_nocancel_args *)uap, retval));
 }
 
 int
 {
        __pthread_testcancel(1);
        return(select_nocancel(p, (struct select_nocancel_args *)uap, retval));
 }
 
 int

-select_nocancel(struct proc *p, struct select_nocancel_args *uap, register_t *retval)
+select_nocancel(struct proc *p, struct select_nocancel_args *uap, int32_t *retval)

 {
        int error = 0;
        u_int ni, nw, size;
 {
        int error = 0;
        u_int ni, nw, size;


@@ -950,7 +983,6 @@ select_nocancel(struct proc *p, struct select_nocancel_args *uap, register_t *re
        struct _select *sel;
        int needzerofill = 1;
        int count = 0;
        struct _select *sel;
        int needzerofill = 1;
        int count = 0;

-       int kfcount = 0;

 
        th_act = current_thread();
        uth = get_bsdthread_info(th_act);
 
        th_act = current_thread();
        uth = get_bsdthread_info(th_act);


@@ -1030,13 +1062,16 @@ select_nocancel(struct proc *p, struct select_nocancel_args *uap, register_t *re
        if (uap->tv) {
                struct timeval atv;
                if (IS_64BIT_PROCESS(p)) {
        if (uap->tv) {
                struct timeval atv;
                if (IS_64BIT_PROCESS(p)) {

-                       struct user_timeval atv64;
+                       struct user64_timeval atv64;

                        error = copyin(uap->tv, (caddr_t)&atv64, sizeof(atv64));
                        /* Loses resolution - assume timeout < 68 years */
                        atv.tv_sec = atv64.tv_sec;
                        atv.tv_usec = atv64.tv_usec;
                } else {
                        error = copyin(uap->tv, (caddr_t)&atv64, sizeof(atv64));
                        /* Loses resolution - assume timeout < 68 years */
                        atv.tv_sec = atv64.tv_sec;
                        atv.tv_usec = atv64.tv_usec;
                } else {

-                       error = copyin(uap->tv, (caddr_t)&atv, sizeof(atv));
+                       struct user32_timeval atv32;
+                       error = copyin(uap->tv, (caddr_t)&atv32, sizeof(atv32));
+                       atv.tv_sec = atv32.tv_sec;
+                       atv.tv_usec = atv32.tv_usec;

                }
                if (error)
                        goto continuation;
                }
                if (error)
                        goto continuation;


@@ -1051,12 +1086,11 @@ select_nocancel(struct proc *p, struct select_nocancel_args *uap, register_t *re
        else
                sel->abstime = 0;
 
        else
                sel->abstime = 0;
 

-       sel->kfcount = 0;
-       if ( (error = selcount(p, sel->ibits, sel->obits, uap->nd, &count, &kfcount)) ) {
+       if ( (error = selcount(p, sel->ibits, uap->nd, &count)) ) {

                        goto continuation;
        }
                        goto continuation;
        }

+

        sel->count = count;
        sel->count = count;

-       sel->kfcount = kfcount;

        size = SIZEOF_WAITQUEUE_SET + (count * SIZEOF_WAITQUEUE_LINK);
        if (uth->uu_allocsize) {
                if (uth->uu_wqset == 0)
        size = SIZEOF_WAITQUEUE_SET + (count * SIZEOF_WAITQUEUE_LINK);
        if (uth->uu_allocsize) {
                if (uth->uu_wqset == 0)


@@ -1070,7 +1104,6 @@ select_nocancel(struct proc *p, struct select_nocancel_args *uap, register_t *re
                                panic("failed to allocate memory for waitqueue\n");
                }
        } else {
                                panic("failed to allocate memory for waitqueue\n");
                }
        } else {

-               sel->count = count;

                uth->uu_allocsize = size;
                uth->uu_wqset = (wait_queue_set_t)kalloc(uth->uu_allocsize);
                if (uth->uu_wqset == (wait_queue_set_t)NULL)
                uth->uu_allocsize = size;
                uth->uu_wqset = (wait_queue_set_t)kalloc(uth->uu_allocsize);
                if (uth->uu_wqset == (wait_queue_set_t)NULL)


@@ -1081,7 +1114,18 @@ select_nocancel(struct proc *p, struct select_nocancel_args *uap, register_t *re
        wait_queue_set_init(uth->uu_wqset, (SYNC_POLICY_FIFO | SYNC_POLICY_PREPOST));
 
 continuation:
        wait_queue_set_init(uth->uu_wqset, (SYNC_POLICY_FIFO | SYNC_POLICY_PREPOST));
 
 continuation:

-       return selprocess(error, SEL_FIRSTPASS);
+
+       if (error) {
+               /*
+                * We have already cleaned up any state we established,
+                * either locally or as a result of selcount().  We don't
+                * need to wait_subqueue_unlink_all(), since we haven't set
+                * anything at this point.
+                */
+               return (error);
+       }
+
+       return selprocess(0, SEL_FIRSTPASS);

 }
 
 int
 }
 
 int


@@ -1090,6 +1134,13 @@ selcontinue(int error)
        return selprocess(error, SEL_SECONDPASS);
 }
 
        return selprocess(error, SEL_SECONDPASS);
 }
 

+
+/*
+ * selprocess
+ *
+ * Parameters: error                   The error code from our caller
+ *             sel_pass                The pass we are on
+ */

 int
 selprocess(int error, int sel_pass)
 {
 int
 selprocess(int error, int sel_pass)
 {


@@ -1114,20 +1165,24 @@ selprocess(int error, int sel_pass)
        uth = get_bsdthread_info(th_act);
        sel = &uth->uu_select;
 
        uth = get_bsdthread_info(th_act);
        sel = &uth->uu_select;
 

-       /* if it is first pass wait queue is not setup yet */

        if ((error != 0) && (sel_pass == SEL_FIRSTPASS))
                        unwind = 0;
        if (sel->count == 0)
                        unwind = 0;
 retry:
        if (error != 0) {
        if ((error != 0) && (sel_pass == SEL_FIRSTPASS))
                        unwind = 0;
        if (sel->count == 0)
                        unwind = 0;
 retry:
        if (error != 0) {

-         goto done;
+               sel_pass = SEL_FIRSTPASS;       /* Reset for seldrop */
+               goto done;

        }
 
        ncoll = nselcoll;
        }
 
        ncoll = nselcoll;

-       OSBitOrAtomic(P_SELECT, (UInt32 *)&p->p_flag);
+       OSBitOrAtomic(P_SELECT, &p->p_flag);

        /* skip scans if the select is just for timeouts */
        if (sel->count) {
        /* skip scans if the select is just for timeouts */
        if (sel->count) {

+               /*
+                * Clear out any dangling refs from prior calls; technically
+                * there should not be any.
+                */

                if (sel_pass == SEL_FIRSTPASS)
                        wait_queue_sub_clearrefs(uth->uu_wqset);
 
                if (sel_pass == SEL_FIRSTPASS)
                        wait_queue_sub_clearrefs(uth->uu_wqset);
 


@@ -1177,7 +1232,7 @@ retry:
                goto retry;
        }
 
                goto retry;
        }
 

-       OSBitAndAtomic(~((uint32_t)P_SELECT), (UInt32 *)&p->p_flag);
+       OSBitAndAtomic(~((uint32_t)P_SELECT), &p->p_flag);

 
        /* if the select is just for timeout skip check */
        if (sel->count &&(sel_pass == SEL_SECONDPASS))
 
        /* if the select is just for timeout skip check */
        if (sel->count &&(sel_pass == SEL_SECONDPASS))


@@ -1185,7 +1240,7 @@ retry:
 
        /* Wait Queue Subordinate has waitqueue as first element */
        wait_result = wait_queue_assert_wait((wait_queue_t)uth->uu_wqset,
 
        /* Wait Queue Subordinate has waitqueue as first element */
        wait_result = wait_queue_assert_wait((wait_queue_t)uth->uu_wqset,

-                                            &selwait, THREAD_ABORTSAFE, sel->abstime);
+                                            NULL, THREAD_ABORTSAFE, sel->abstime);

        if (wait_result != THREAD_AWAKENED) {
                /* there are no preposted events */
                error = tsleep1(NULL, PSOCK | PCATCH,
        if (wait_result != THREAD_AWAKENED) {
                /* there are no preposted events */
                error = tsleep1(NULL, PSOCK | PCATCH,


@@ -1195,10 +1250,10 @@ retry:
                error = 0;
        }
 
                error = 0;
        }
 

-       sel_pass = SEL_SECONDPASS;

        if (error == 0) {
        if (error == 0) {

+               sel_pass = SEL_SECONDPASS;

                if (!prepost)
                if (!prepost)

-                       somewakeup =1;
+                       somewakeup = 1;

                goto retry;
        }
 done:
                goto retry;
        }
 done:


@@ -1206,7 +1261,7 @@ done:
                wait_subqueue_unlink_all(uth->uu_wqset);
                seldrop(p, sel->ibits, uap->nd);
        }
                wait_subqueue_unlink_all(uth->uu_wqset);
                seldrop(p, sel->ibits, uap->nd);
        }

-       OSBitAndAtomic(~((uint32_t)P_SELECT), (UInt32 *)&p->p_flag);
+       OSBitAndAtomic(~((uint32_t)P_SELECT), &p->p_flag);

        /* select is not restarted after signals... */
        if (error == ERESTART)
                error = EINTR;
        /* select is not restarted after signals... */
        if (error == ERESTART)
                error = EINTR;


@@ -1233,25 +1288,40 @@ done:
        return(error);
 }
 
        return(error);
 }
 

+
+/*
+ * selscan
+ *
+ * Parameters: p                       Process performing the select
+ *             sel                     The per-thread select context structure
+ *             nfd                     The number of file descriptors to scan
+ *             retval                  The per thread system call return area
+ *             sel_pass                Which pass this is; allowed values are
+ *                                             SEL_FIRSTPASS and SEL_SECONDPASS
+ *             wqsub                   The per thread wait queue set
+ *
+ * Returns:    0                       Success
+ *             EIO                     Invalid p->p_fd field XXX Obsolete?
+ *             EBADF                   One of the files in the bit vector is
+ *                                             invalid.
+ */

 static int
 static int

-selscan(struct proc *p, struct _select *sel, int nfd, register_t *retval,
+selscan(struct proc *p, struct _select *sel, int nfd, int32_t *retval,

        int sel_pass, wait_queue_sub_t wqsub)
 {
        struct filedesc *fdp = p->p_fd;
        int msk, i, j, fd;
        u_int32_t bits;
        struct fileproc *fp;
        int sel_pass, wait_queue_sub_t wqsub)
 {
        struct filedesc *fdp = p->p_fd;
        int msk, i, j, fd;
        u_int32_t bits;
        struct fileproc *fp;

-       int n = 0;
-       int nc = 0;
+       int n = 0;              /* count of bits */
+       int nc = 0;             /* bit vector offset (nc'th bit) */

        static int flag[3] = { FREAD, FWRITE, 0 };
        u_int32_t *iptr, *optr;
        u_int nw;
        u_int32_t *ibits, *obits;
        char * wql;
        char * wql_ptr;
        static int flag[3] = { FREAD, FWRITE, 0 };
        u_int32_t *iptr, *optr;
        u_int nw;
        u_int32_t *ibits, *obits;
        char * wql;
        char * wql_ptr;

-       int count, kfcount;
-       boolean_t funnel_state;
-       vnode_t vp;
+       int count;

        struct vfs_context context = *vfs_context_current();
 
        /*
        struct vfs_context context = *vfs_context_current();
 
        /*


@@ -1269,61 +1339,9 @@ selscan(struct proc *p, struct _select *sel, int nfd, register_t *retval,
        nw = howmany(nfd, NFDBITS);
 
        count = sel->count;
        nw = howmany(nfd, NFDBITS);
 
        count = sel->count;

-       kfcount = sel->kfcount;
-
-       if (kfcount > count)
-               panic("selscan: count < kfcount");
-
-       if (kfcount != 0) {
-               funnel_state = thread_funnel_set(kernel_flock, TRUE);
-
-               proc_fdlock(p);
-               for (msk = 0; msk < 3; msk++) {
-                       iptr = (u_int32_t *)&ibits[msk * nw];
-                       optr = (u_int32_t *)&obits[msk * nw];
-
-                       for (i = 0; i < nfd; i += NFDBITS) {
-                               bits = iptr[i/NFDBITS];
-
-                               while ((j = ffs(bits)) && (fd = i + --j) < nfd) {
-                                       bits &= ~(1 << j);
-                                       fp = fdp->fd_ofiles[fd];
-
-                                       if (fp == NULL ||
-                                               (fdp->fd_ofileflags[fd] & UF_RESERVED)) {
-                                               proc_fdunlock(p);
-                                               thread_funnel_set(kernel_flock, funnel_state);
-                                               return(EBADF);
-                                       }
-                                       if (sel_pass == SEL_SECONDPASS) {
-                                               wql_ptr = (char *)0;
-                                               fp->f_flags &= ~FP_INSELECT;
-                                               fp->f_waddr = (void *)0;
-                                       } else {
-                                               wql_ptr = (wql + nc * SIZEOF_WAITQUEUE_LINK);
-                                               fp->f_flags |= FP_INSELECT;
-                                               fp->f_waddr = (void *)wqsub;
-                                       }
-
-                                       context.vc_ucred = fp->f_cred;
-
-                                       if (fp->f_ops && (fp->f_type == DTYPE_VNODE)
-                                                       && ((vp = (struct vnode *)fp->f_data)  != NULLVP)
-                                                       && (vp->v_type == VCHR)
-                                               && fo_select(fp, flag[msk], wql_ptr, &context)) {
-                                               optr[fd/NFDBITS] |= (1 << (fd % NFDBITS));
-                                               n++;
-                                       }
-                                       nc++;
-                               }
-                       }
-               }
-               proc_fdunlock(p);
-               thread_funnel_set(kernel_flock, funnel_state);
-       }

 
        nc = 0;
 
        nc = 0;

-       if (kfcount != count) {
+       if (count) {

                proc_fdlock(p);
                for (msk = 0; msk < 3; msk++) {
                        iptr = (u_int32_t *)&ibits[msk * nw];
                proc_fdlock(p);
                for (msk = 0; msk < 3; msk++) {
                        iptr = (u_int32_t *)&ibits[msk * nw];


@@ -1336,29 +1354,37 @@ selscan(struct proc *p, struct _select *sel, int nfd, register_t *retval,
                                        bits &= ~(1 << j);
                                        fp = fdp->fd_ofiles[fd];
 
                                        bits &= ~(1 << j);
                                        fp = fdp->fd_ofiles[fd];
 

-                                       if (fp == NULL ||
-                                               (fdp->fd_ofileflags[fd] & UF_RESERVED)) {
+                                       if (fp == NULL || (fdp->fd_ofileflags[fd] & UF_RESERVED)) {
+                                               /*
+                                                * If we abort because of a bad
+                                                * fd, let the caller unwind...
+                                                */

                                                proc_fdunlock(p);
                                                return(EBADF);
                                        }
                                        if (sel_pass == SEL_SECONDPASS) {
                                                wql_ptr = (char *)0;
                                                proc_fdunlock(p);
                                                return(EBADF);
                                        }
                                        if (sel_pass == SEL_SECONDPASS) {
                                                wql_ptr = (char *)0;

-                                               fp->f_flags &= ~FP_INSELECT;
-                                               fp->f_waddr = (void *)0;
+                                               if ((fp->f_flags & FP_INSELECT) && (fp->f_waddr == (void *)wqsub)) {
+                                                       fp->f_flags &= ~FP_INSELECT;
+                                                       fp->f_waddr = (void *)0;
+                                               }

                                        } else {
                                                wql_ptr = (wql + nc * SIZEOF_WAITQUEUE_LINK);
                                        } else {
                                                wql_ptr = (wql + nc * SIZEOF_WAITQUEUE_LINK);

-                                               fp->f_flags |= FP_INSELECT;
-                                               fp->f_waddr = (void *)wqsub;
+                                               if (fp->f_flags & FP_INSELECT) {
+                                                       /* someone is already in select on this fp */
+                                                       fp->f_flags |= FP_SELCONFLICT;
+                                                       wait_queue_link(&select_conflict_queue, (wait_queue_set_t)wqsub);
+                                               } else {
+                                                       fp->f_flags |= FP_INSELECT;
+                                                       fp->f_waddr = (void *)wqsub;
+                                               }

                                        }
 
                                        context.vc_ucred = fp->f_cred;
 
                                        }
 
                                        context.vc_ucred = fp->f_cred;
 

-                                       if ((fp->f_ops && 
-                                               ((fp->f_type != DTYPE_VNODE)
-                                               || (((vp = (struct vnode *)fp->f_data)  != NULLVP)
-                                                       && (vp->v_type != VCHR))
-                                               )
-                                               && fo_select(fp, flag[msk], wql_ptr, &context))) {
+                                       /* The select; set the bit, if true */
+                                       if (fp->f_ops
+                                               && fo_select(fp, flag[msk], wql_ptr, &context)) {

                                                optr[fd/NFDBITS] |= (1 << (fd % NFDBITS));
                                                n++;
                                        }
                                                optr[fd/NFDBITS] |= (1 << (fd % NFDBITS));
                                                n++;
                                        }


@@ -1372,7 +1398,7 @@ selscan(struct proc *p, struct _select *sel, int nfd, register_t *retval,
        return (0);
 }
 
        return (0);
 }
 

-int poll_callback(struct kqueue *, struct kevent *, void *);
+int poll_callback(struct kqueue *, struct kevent64_s *, void *);

 
 struct poll_continue_args {
        user_addr_t pca_fds;
 
 struct poll_continue_args {
        user_addr_t pca_fds;


@@ -1381,7 +1407,7 @@ struct poll_continue_args {
 };
 
 int
 };
 
 int

-poll(struct proc *p, struct poll_args *uap, register_t *retval)
+poll(struct proc *p, struct poll_args *uap, int32_t *retval)

 {
        __pthread_testcancel(1);
        return(poll_nocancel(p, (struct poll_nocancel_args *)uap, retval));
 {
        __pthread_testcancel(1);
        return(poll_nocancel(p, (struct poll_nocancel_args *)uap, retval));


@@ -1389,7 +1415,7 @@ poll(struct proc *p, struct poll_args *uap, register_t *retval)
 
 
 int
 
 
 int

-poll_nocancel(struct proc *p, struct poll_nocancel_args *uap, register_t *retval)
+poll_nocancel(struct proc *p, struct poll_nocancel_args *uap, int32_t *retval)

 {
        struct poll_continue_args *cont;
        struct pollfd *fds;
 {
        struct poll_continue_args *cont;
        struct pollfd *fds;


@@ -1446,10 +1472,10 @@ poll_nocancel(struct proc *p, struct poll_nocancel_args *uap, register_t *retval
 
        /* JMM - all this P_SELECT stuff is bogus */
        ncoll = nselcoll;
 
        /* JMM - all this P_SELECT stuff is bogus */
        ncoll = nselcoll;

-       OSBitOrAtomic(P_SELECT, (UInt32 *)&p->p_flag);
+       OSBitOrAtomic(P_SELECT, &p->p_flag);

        for (i = 0; i < nfds; i++) {
                short events = fds[i].events;
        for (i = 0; i < nfds; i++) {
                short events = fds[i].events;

-               struct kevent kev;
+               struct kevent64_s kev;

                int kerror = 0;
 
                /* per spec, ignore fd values below zero */
                int kerror = 0;
 
                /* per spec, ignore fd values below zero */


@@ -1461,9 +1487,11 @@ poll_nocancel(struct proc *p, struct poll_nocancel_args *uap, register_t *retval
                /* convert the poll event into a kqueue kevent */
                kev.ident = fds[i].fd;
                kev.flags = EV_ADD | EV_ONESHOT | EV_POLL;
                /* convert the poll event into a kqueue kevent */
                kev.ident = fds[i].fd;
                kev.flags = EV_ADD | EV_ONESHOT | EV_POLL;

-               kev.fflags = NOTE_LOWAT;
-               kev.data = 1; /* efficiency be damned: any data should trigger */

                kev.udata = CAST_USER_ADDR_T(&fds[i]);
                kev.udata = CAST_USER_ADDR_T(&fds[i]);

+               kev.fflags = 0;
+               kev.data = 0;
+               kev.ext[0] = 0;
+               kev.ext[1] = 0;

 
                /* Handle input events */
                if (events & ( POLLIN | POLLRDNORM | POLLPRI | POLLRDBAND | POLLHUP )) {
 
                /* Handle input events */
                if (events & ( POLLIN | POLLRDNORM | POLLPRI | POLLRDBAND | POLLHUP )) {


@@ -1511,11 +1539,11 @@ poll_nocancel(struct proc *p, struct poll_nocancel_args *uap, register_t *retval
        cont->pca_fds = uap->fds;
        cont->pca_nfds = nfds;
        cont->pca_rfds = rfds;
        cont->pca_fds = uap->fds;
        cont->pca_nfds = nfds;
        cont->pca_rfds = rfds;

-       error = kevent_scan(kq, poll_callback, NULL, cont, &atv, p);
+       error = kqueue_scan(kq, poll_callback, NULL, cont, &atv, p);

        rfds = cont->pca_rfds;
 
  done:
        rfds = cont->pca_rfds;
 
  done:

-       OSBitAndAtomic(~((uint32_t)P_SELECT), (UInt32 *)&p->p_flag);
+       OSBitAndAtomic(~((uint32_t)P_SELECT), &p->p_flag);

        /* poll is not restarted after signals... */
        if (error == ERESTART)
                error = EINTR;
        /* poll is not restarted after signals... */
        if (error == ERESTART)
                error = EINTR;


@@ -1535,7 +1563,7 @@ poll_nocancel(struct proc *p, struct poll_nocancel_args *uap, register_t *retval
 }
 
 int
 }
 
 int

-poll_callback(__unused struct kqueue *kq, struct kevent *kevp, void *data)
+poll_callback(__unused struct kqueue *kq, struct kevent64_s *kevp, void *data)

 {
        struct poll_continue_args *cont = (struct poll_continue_args *)data;
        struct pollfd *fds = CAST_DOWN(struct pollfd *, kevp->udata);
 {
        struct poll_continue_args *cont = (struct poll_continue_args *)data;
        struct pollfd *fds = CAST_DOWN(struct pollfd *, kevp->udata);


@@ -1591,9 +1619,32 @@ seltrue(__unused dev_t dev, __unused int flag, __unused struct proc *p)
        return (1);
 }
 
        return (1);
 }
 

+/*
+ * selcount
+ *
+ * Count the number of bits set in the input bit vector, and establish an
+ * outstanding fp->f_iocount for each of the descriptors which will be in
+ * use in the select operation.
+ *
+ * Parameters: p                       The process doing the select
+ *             ibits                   The input bit vector
+ *             nfd                     The number of fd's in the vector
+ *             countp                  Pointer to where to store the bit count
+ *
+ * Returns:    0                       Success
+ *             EIO                     Bad per process open file table
+ *             EBADF                   One of the bits in the input bit vector
+ *                                             references an invalid fd
+ *
+ * Implicit:   *countp (modified)      Count of fd's
+ *
+ * Notes:      This function is the first pass under the proc_fdlock() that
+ *             permits us to recognize invalid descriptors in the bit vector;
+ *             the may, however, not remain valid through the drop and
+ *             later reacquisition of the proc_fdlock().
+ */

 static int
 static int

-selcount(struct proc *p, u_int32_t *ibits, __unused u_int32_t *obits, 
-                int nfd, int *countp, int * kfcountp)
+selcount(struct proc *p, u_int32_t *ibits, int nfd, int *countp)

 {
        struct filedesc *fdp = p->p_fd;
        int msk, i, j, fd;
 {
        struct filedesc *fdp = p->p_fd;
        int msk, i, j, fd;


@@ -1603,9 +1654,8 @@ selcount(struct proc *p, u_int32_t *ibits, __unused u_int32_t *obits,
        u_int32_t *iptr;
        u_int nw;
        int error=0; 
        u_int32_t *iptr;
        u_int nw;
        int error=0; 

-       int kfc = 0;

        int dropcount;
        int dropcount;

-       vnode_t vp;
+       int need_wakeup = 0;

 
        /*
         * Problems when reboot; due to MacOSX signal probs
 
        /*
         * Problems when reboot; due to MacOSX signal probs


@@ -1613,7 +1663,6 @@ selcount(struct proc *p, u_int32_t *ibits, __unused u_int32_t *obits,
         */
        if (fdp == NULL) {
                *countp = 0;
         */
        if (fdp == NULL) {
                *countp = 0;

-               *kfcountp = 0;

                return(EIO);
        }
        nw = howmany(nfd, NFDBITS);
                return(EIO);
        }
        nw = howmany(nfd, NFDBITS);


@@ -1629,16 +1678,10 @@ selcount(struct proc *p, u_int32_t *ibits, __unused u_int32_t *obits,
                                if (fp == NULL ||
                                        (fdp->fd_ofileflags[fd] & UF_RESERVED)) {
                                                *countp = 0;
                                if (fp == NULL ||
                                        (fdp->fd_ofileflags[fd] & UF_RESERVED)) {
                                                *countp = 0;

-                                               *kfcountp = 0;

                                                error = EBADF;
                                                goto bad;
                                }
                                fp->f_iocount++;
                                                error = EBADF;
                                                goto bad;
                                }
                                fp->f_iocount++;

-                               if ((fp->f_type == DTYPE_VNODE)
-                                               && ((vp = (struct vnode *)fp->f_data)  != NULLVP)
-                                               && (vp->v_type == VCHR) )
-                                       kfc++;
-

                                n++;
                        }
                }
                                n++;
                        }
                }


@@ -1646,48 +1689,64 @@ selcount(struct proc *p, u_int32_t *ibits, __unused u_int32_t *obits,
        proc_fdunlock(p);
 
        *countp = n;
        proc_fdunlock(p);
 
        *countp = n;

-       *kfcountp = kfc;

        return (0);
        return (0);

+

 bad:
        dropcount = 0;
        
        if (n== 0)
                goto out;
 bad:
        dropcount = 0;
        
        if (n== 0)
                goto out;

-       /* undo the iocounts */
-       for (msk = 0; msk < 3; msk++) {
-               iptr = (u_int32_t *)&ibits[msk * nw];
-               for (i = 0; i < nfd; i += NFDBITS) {
-                       bits = iptr[i/NFDBITS];
-                       while ((j = ffs(bits)) && (fd = i + --j) < nfd) {
-                               bits &= ~(1 << j);
-                               fp = fdp->fd_ofiles[fd];
-                               if (dropcount >= n)
-                                       goto out;
-                               fp->f_iocount--;
+       /* Ignore error return; it's already EBADF */
+       (void)seldrop_locked(p, ibits, nfd, n, &need_wakeup, 1);

 
 

-                               if (p->p_fpdrainwait && fp->f_iocount == 0) {
-                                       p->p_fpdrainwait = 0;
-                                       wakeup(&p->p_fpdrainwait);
-                               }
-                               dropcount++;
-                       }
-               }
-       }

 out:
        proc_fdunlock(p);
 out:
        proc_fdunlock(p);

+       if (need_wakeup) {
+               wakeup(&p->p_fpdrainwait);
+       }

        return(error);
 }
 
        return(error);
 }
 

+
+/*
+ * seldrop_locked
+ *
+ * Drop outstanding wait queue references set up during selscan(); drop the
+ * outstanding per fileproc f_iocount() picked up during the selcount().
+ *
+ * Parameters: p                       Process performing the select
+ *             ibits                   Input pit bector of fd's
+ *             nfd                     Number of fd's
+ *             lim                     Limit to number of vector entries to
+ *                                             consider, or -1 for "all"
+ *             inselect                True if
+ *             need_wakeup             Pointer to flag to set to do a wakeup
+ *                                     if f_iocont on any descriptor goes to 0
+ *
+ * Returns:    0                       Success
+ *             EBADF                   One or more fds in the bit vector
+ *                                             were invalid, but the rest
+ *                                             were successfully dropped
+ *
+ * Notes:      An fd make become bad while the proc_fdlock() is not held,
+ *             if a multithreaded application closes the fd out from under
+ *             the in progress select.  In this case, we still have to
+ *             clean up after the set up on the remaining fds.
+ */

 static int
 static int

-seldrop(struct proc *p, u_int32_t *ibits, int nfd)
+seldrop_locked(struct proc *p, u_int32_t *ibits, int nfd, int lim, int *need_wakeup, int fromselcount)

 {
        struct filedesc *fdp = p->p_fd;
        int msk, i, j, fd;
        u_int32_t bits;
        struct fileproc *fp;
 {
        struct filedesc *fdp = p->p_fd;
        int msk, i, j, fd;
        u_int32_t bits;
        struct fileproc *fp;

-       int n = 0;

        u_int32_t *iptr;
        u_int nw;
        u_int32_t *iptr;
        u_int nw;

+       int error = 0;
+       int dropcount = 0;
+       uthread_t uth = get_bsdthread_info(current_thread());
+
+       *need_wakeup = 0;

 
        /*
         * Problems when reboot; due to MacOSX signal probs
 
        /*
         * Problems when reboot; due to MacOSX signal probs


@@ -1699,8 +1758,6 @@ seldrop(struct proc *p, u_int32_t *ibits, int nfd)
 
        nw = howmany(nfd, NFDBITS);
 
 
        nw = howmany(nfd, NFDBITS);
 

-
-       proc_fdlock(p);

        for (msk = 0; msk < 3; msk++) {
                iptr = (u_int32_t *)&ibits[msk * nw];
                for (i = 0; i < nfd; i += NFDBITS) {
        for (msk = 0; msk < 3; msk++) {
                iptr = (u_int32_t *)&ibits[msk * nw];
                for (i = 0; i < nfd; i += NFDBITS) {


@@ -1708,28 +1765,67 @@ seldrop(struct proc *p, u_int32_t *ibits, int nfd)
                        while ((j = ffs(bits)) && (fd = i + --j) < nfd) {
                                bits &= ~(1 << j);
                                fp = fdp->fd_ofiles[fd];
                        while ((j = ffs(bits)) && (fd = i + --j) < nfd) {
                                bits &= ~(1 << j);
                                fp = fdp->fd_ofiles[fd];

-                               if (fp == NULL 
-#if 0
-                       /* if you are here then it is being closed */
-                                       || (fdp->fd_ofileflags[fd] & UF_RESERVED)
-#endif
-                                       ) {
-                                               proc_fdunlock(p);
-                                               return(EBADF);
+                               /*
+                                * If we've already dropped as many as were
+                                * counted/scanned, then we are done.  
+                                */
+                               if ((fromselcount != 0) && (++dropcount > lim))
+                                       goto done;
+
+                               if (fp == NULL) {
+                                       /* skip (now) bad fds */
+                                       error = EBADF;
+                                       continue;
+                               }
+                               /*
+                                * Only clear the flag if we set it.  We'll
+                                * only find that we set it if we had made
+                                * at least one [partial] pass through selscan().
+                                */
+                               if ((fp->f_flags & FP_INSELECT) && (fp->f_waddr == (void *)uth->uu_wqset)) {
+                                       fp->f_flags &= ~FP_INSELECT;
+                                       fp->f_waddr = (void *)0;

                                }
                                }

-                               n++;
-                               fp->f_iocount--;
-                               fp->f_flags &= ~FP_INSELECT;

 
 

-                               if (p->p_fpdrainwait && fp->f_iocount == 0) {
-                                       p->p_fpdrainwait = 0;
-                                       wakeup(&p->p_fpdrainwait);
+                               fp->f_iocount--;
+                               if (fp->f_iocount < 0)
+                                       panic("f_iocount overdecrement!");
+
+                               if (fp->f_iocount == 0) {
+                                       /*
+                                        * The last iocount is responsible for clearing
+                                        * selconfict flag - even if we didn't set it -
+                                        * and is also responsible for waking up anyone
+                                        * waiting on iocounts to drain.
+                                        */
+                                       if (fp->f_flags & FP_SELCONFLICT)
+                                               fp->f_flags &= ~FP_SELCONFLICT;
+                                       if (p->p_fpdrainwait) {
+                                               p->p_fpdrainwait = 0;
+                                               *need_wakeup = 1;
+                                       }

                                }
                        }
                }
        }
                                }
                        }
                }
        }

+done:
+       return (error);
+}
+
+
+static int
+seldrop(struct proc *p, u_int32_t *ibits, int nfd)
+{
+       int error;
+       int need_wakeup = 0;
+
+       proc_fdlock(p);
+       error =  seldrop_locked(p, ibits, nfd, nfd, &need_wakeup, 0);

        proc_fdunlock(p);
        proc_fdunlock(p);

-       return (0);
+       if (need_wakeup) {
+               wakeup(&p->p_fpdrainwait);
+       }
+       return (error);

 }
 
 /*
 }
 
 /*


@@ -1743,12 +1839,8 @@ selrecord(__unused struct proc *selector, struct selinfo *sip, void * p_wql)
 
        /* need to look at collisions */
 
 
        /* need to look at collisions */
 

-       if ((p_wql == (void *)0) && ((sip->si_flags & SI_INITED) == 0)) {
-               return;
-       }
-

        /*do not record if this is second pass of select */
        /*do not record if this is second pass of select */

-       if((p_wql == (void *)0)) {
+       if(p_wql == (void *)0) {

                return;
        }
 
                return;
        }
 


@@ -1789,7 +1881,7 @@ selwakeup(struct selinfo *sip)
        }
 
        if (sip->si_flags & SI_RECORDED) {
        }
 
        if (sip->si_flags & SI_RECORDED) {

-               wait_queue_wakeup_all(&sip->si_wait_queue, &selwait, THREAD_AWAKENED);
+               wait_queue_wakeup_all(&sip->si_wait_queue, NULL, THREAD_AWAKENED);

                sip->si_flags &= ~SI_RECORDED;
        }
 
                sip->si_flags &= ~SI_RECORDED;
        }
 


@@ -1807,7 +1899,7 @@ selthreadclear(struct selinfo *sip)
                        sip->si_flags &= ~(SI_RECORDED | SI_COLL);
        }
        sip->si_flags |= SI_CLEAR;
                        sip->si_flags &= ~(SI_RECORDED | SI_COLL);
        }
        sip->si_flags |= SI_CLEAR;

-       wait_queue_unlinkall_nofree(&sip->si_wait_queue);
+       wait_queue_unlink_all(&sip->si_wait_queue);

 }
 
 
 }
 
 


@@ -2350,7 +2442,18 @@ waitevent(proc_t p, struct waitevent_args *uap, int *retval)
                        proc_lock(p);
                        goto retry;
                }
                        proc_lock(p);
                        goto retry;
                }

-               error = copyin(uap->tv, (caddr_t)&atv, sizeof (atv));
+               if (IS_64BIT_PROCESS(p)) {
+                       struct user64_timeval atv64;
+                       error = copyin(uap->tv, (caddr_t)&atv64, sizeof(atv64));
+                       /* Loses resolution - assume timeout < 68 years */
+                       atv.tv_sec = atv64.tv_sec;
+                       atv.tv_usec = atv64.tv_usec;
+               } else {
+                       struct user32_timeval atv32;
+                       error = copyin(uap->tv, (caddr_t)&atv32, sizeof(atv32));
+                       atv.tv_sec = atv32.tv_sec;
+                       atv.tv_usec = atv32.tv_usec;
+               }

 
                if (error)
                        return(error);
 
                if (error)
                        return(error);


@@ -2676,7 +2779,7 @@ waitevent_close(struct proc *p, struct fileproc *fp)
  *             have a system UUID in hand, then why ask for one?
  */
 int
  *             have a system UUID in hand, then why ask for one?
  */
 int

-gethostuuid(struct proc *p, struct gethostuuid_args *uap, __unused register_t *retval)
+gethostuuid(struct proc *p, struct gethostuuid_args *uap, __unused int32_t *retval)

 {
        kern_return_t kret;
        int error;
 {
        kern_return_t kret;
        int error;


@@ -2685,14 +2788,14 @@ gethostuuid(struct proc *p, struct gethostuuid_args *uap, __unused register_t *r
 
        /* Convert the 32/64 bit timespec into a mach_timespec_t */
        if ( proc_is64bit(p) ) {
 
        /* Convert the 32/64 bit timespec into a mach_timespec_t */
        if ( proc_is64bit(p) ) {

-               struct user_timespec ts;
+               struct user64_timespec ts;

                error = copyin(uap->timeoutp, &ts, sizeof(ts));
                if (error)
                        return (error);
                mach_ts.tv_sec = ts.tv_sec;
                mach_ts.tv_nsec = ts.tv_nsec;
        } else {
                error = copyin(uap->timeoutp, &ts, sizeof(ts));
                if (error)
                        return (error);
                mach_ts.tv_sec = ts.tv_sec;
                mach_ts.tv_nsec = ts.tv_nsec;
        } else {

-               struct timespec ts;
+               struct user32_timespec ts;

                error = copyin(uap->timeoutp, &ts, sizeof(ts) );
                if (error)
                        return (error);
                error = copyin(uap->timeoutp, &ts, sizeof(ts) );
                if (error)
                        return (error);