Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files. =================================================================== RCS file: /ftp/cvs/cvsroot/src/sys/kern/kern_event.c,v rcsdiff: /ftp/cvs/cvsroot/src/sys/kern/kern_event.c,v: warning: Unknown phrases like `commitid ...;' are present. retrieving revision 1.23 retrieving revision 1.23.2.6 diff -u -p -r1.23 -r1.23.2.6 --- src/sys/kern/kern_event.c 2005/05/29 22:24:15 1.23 +++ src/sys/kern/kern_event.c 2007/12/07 17:32:39 1.23.2.6 @@ -1,4 +1,5 @@ -/* $NetBSD: kern_event.c,v 1.23 2005/05/29 22:24:15 christos Exp $ */ +/* $NetBSD: kern_event.c,v 1.23.2.6 2007/12/07 17:32:39 yamt Exp $ */ + /*- * Copyright (c) 1999,2000,2001 Jonathan Lemon * All rights reserved. @@ -28,7 +29,7 @@ */ #include -__KERNEL_RCSID(0, "$NetBSD: kern_event.c,v 1.23 2005/05/29 22:24:15 christos Exp $"); +__KERNEL_RCSID(0, "$NetBSD: kern_event.c,v 1.23.2.6 2007/12/07 17:32:39 yamt Exp $"); #include #include @@ -51,26 +52,27 @@ __KERNEL_RCSID(0, "$NetBSD: kern_event.c #include #include #include -#include #include +#include +#include -static int kqueue_scan(struct file *fp, size_t maxevents, - struct kevent *ulistp, const struct timespec *timeout, - struct proc *p, register_t *retval); static void kqueue_wakeup(struct kqueue *kq); +static int kqueue_scan(struct file *, size_t, struct kevent *, + const struct timespec *, struct lwp *, register_t *, + const struct kevent_ops *); static int kqueue_read(struct file *fp, off_t *offset, struct uio *uio, - struct ucred *cred, int flags); + kauth_cred_t cred, int flags); static int kqueue_write(struct file *fp, off_t *offset, struct uio *uio, - struct ucred *cred, int flags); + kauth_cred_t cred, int flags); static int kqueue_ioctl(struct file *fp, u_long com, void *data, - struct proc *p); + struct lwp *l); static int kqueue_fcntl(struct file *fp, u_int com, void *data, - struct proc *p); -static int kqueue_poll(struct file *fp, int events, struct proc *p); + struct lwp *l); +static int kqueue_poll(struct file *fp, int events, struct lwp *l); static int kqueue_kqfilter(struct file *fp, struct knote *kn); -static int kqueue_stat(struct file *fp, struct stat *sp, struct proc *p); -static int kqueue_close(struct file *fp, struct proc *p); +static int kqueue_stat(struct file *fp, struct stat *sp, struct lwp *l); +static int kqueue_close(struct file *fp, struct lwp *l); static const struct fileops kqueueops = { kqueue_read, kqueue_write, kqueue_ioctl, kqueue_fcntl, kqueue_poll, @@ -78,7 +80,7 @@ static const struct fileops kqueueops = }; static void knote_attach(struct knote *kn, struct filedesc *fdp); -static void knote_drop(struct knote *kn, struct proc *p, +static void knote_drop(struct knote *kn, struct lwp *l, struct filedesc *fdp); static void knote_enqueue(struct knote *kn); static void knote_dequeue(struct knote *kn); @@ -100,11 +102,13 @@ static const struct filterops proc_filto { 0, filt_procattach, filt_procdetach, filt_proc }; static const struct filterops file_filtops = { 1, filt_fileattach, NULL, NULL }; -static struct filterops timer_filtops = +static const struct filterops timer_filtops = { 0, filt_timerattach, filt_timerdetach, filt_timer }; -POOL_INIT(kqueue_pool, sizeof(struct kqueue), 0, 0, 0, "kqueuepl", NULL); -POOL_INIT(knote_pool, sizeof(struct knote), 0, 0, 0, "knotepl", NULL); +static POOL_INIT(kqueue_pool, sizeof(struct kqueue), 0, 0, 0, "kqueuepl", NULL, + IPL_VM); +static POOL_INIT(knote_pool, sizeof(struct knote), 0, 0, 0, "knotepl", NULL, + IPL_VM); static int kq_ncallouts = 0; static int kq_calloutmax = (4 * 1024); @@ -171,12 +175,9 @@ kfilter_byname_user(const char *name) { int i; - /* user_kfilters[] could be NULL if no filters were registered */ - if (!user_kfilters) - return (NULL); - - for (i = 0; user_kfilters[i].name != NULL; i++) { - if (user_kfilters[i].name != '\0' && + /* user filter slots have a NULL name if previously deregistered */ + for (i = 0; i < user_kfilterc ; i++) { + if (user_kfilters[i].name != NULL && strcmp(name, user_kfilters[i].name) == 0) return (&user_kfilters[i]); } @@ -227,6 +228,7 @@ kfilter_register(const char *name, const struct kfilter *kfilter; void *space; int len; + int i; if (name == NULL || name[0] == '\0' || filtops == NULL) return (EINVAL); /* invalid args */ @@ -235,6 +237,14 @@ kfilter_register(const char *name, const if (user_kfilterc > 0xffffffff - EVFILT_SYSCOUNT) return (EINVAL); /* too many */ + for (i = 0; i < user_kfilterc; i++) { + kfilter = &user_kfilters[i]; + if (kfilter->name == NULL) { + /* Previously deregistered slot. Reuse. */ + goto reuse; + } + } + /* check if need to grow user_kfilters */ if (user_kfilterc + 1 > user_kfiltermaxc) { /* @@ -247,10 +257,10 @@ kfilter_register(const char *name, const /* copy existing user_kfilters */ if (user_kfilters != NULL) - memcpy((caddr_t)kfilter, (caddr_t)user_kfilters, + memcpy((void *)kfilter, (void *)user_kfilters, user_kfilterc * sizeof(struct kfilter *)); /* zero new sections */ - memset((caddr_t)kfilter + + memset((char *)kfilter + user_kfilterc * sizeof(struct kfilter *), 0, (user_kfiltermaxc - user_kfilterc) * sizeof(struct kfilter *)); @@ -259,21 +269,23 @@ kfilter_register(const char *name, const free(user_kfilters, M_KEVENT); user_kfilters = kfilter; } + /* Adding new slot */ + kfilter = &user_kfilters[user_kfilterc++]; +reuse: len = strlen(name) + 1; /* copy name */ space = malloc(len, M_KEVENT, M_WAITOK); memcpy(space, name, len); - user_kfilters[user_kfilterc].name = space; + kfilter->name = space; - user_kfilters[user_kfilterc].filter = user_kfilterc + EVFILT_SYSCOUNT; + kfilter->filter = (kfilter - user_kfilters) + EVFILT_SYSCOUNT; len = sizeof(struct filterops); /* copy filtops */ space = malloc(len, M_KEVENT, M_WAITOK); memcpy(space, filtops, len); - user_kfilters[user_kfilterc].filtops = space; + kfilter->filtops = space; if (retfilter != NULL) - *retfilter = user_kfilters[user_kfilterc].filter; - user_kfilterc++; /* finally, increment count */ + *retfilter = kfilter->filter; return (0); } @@ -298,11 +310,10 @@ kfilter_unregister(const char *name) if (kfilter == NULL) /* not found */ return (ENOENT); - if (kfilter->name[0] != '\0') { - /* XXXUNCONST Cast away const (but we know it's safe. */ - free(__UNCONST(kfilter->name), M_KEVENT); - kfilter->name = ""; /* mark as `not implemented' */ - } + /* XXXUNCONST Cast away const (but we know it's safe. */ + free(__UNCONST(kfilter->name), M_KEVENT); + kfilter->name = NULL; /* mark as `not implemented' */ + if (kfilter->filtops != NULL) { /* XXXUNCONST Cast away const (but we know it's safe. */ free(__UNCONST(kfilter->filtops), M_KEVENT); @@ -357,7 +368,11 @@ filt_kqueue(struct knote *kn, long hint) static int filt_procattach(struct knote *kn) { - struct proc *p; + struct proc *p, *curp; + struct lwp *curl; + + curl = curlwp; + curp = curl->l_proc; p = pfind(kn->kn_id); if (p == NULL) @@ -367,9 +382,9 @@ filt_procattach(struct knote *kn) * Fail if it's not owned by you, or the last exec gave us * setuid/setgid privs (unless you're root). */ - if ((p->p_cred->p_ruid != curproc->p_cred->p_ruid || - (p->p_flag & P_SUGID)) - && suser(curproc->p_ucred, &curproc->p_acflag) != 0) + if ((kauth_cred_getuid(p->p_cred) != kauth_cred_getuid(curl->l_cred) || + (p->p_flag & PK_SUGID)) && kauth_authorize_generic(curl->l_cred, + KAUTH_GENERIC_ISSUSER, NULL) != 0) return (EACCES); kn->kn_ptr.p_proc = p; @@ -409,7 +424,6 @@ filt_procdetach(struct knote *kn) return; p = kn->kn_ptr.p_proc; - KASSERT(p->p_stat == SZOMB || pfind(kn->kn_id) == p); /* XXXSMP lock the process? */ SLIST_REMOVE(&p->p_klist, kn, knote, kn_selnext); @@ -492,7 +506,7 @@ filt_timerexpire(void *knx) if ((kn->kn_flags & EV_ONESHOT) == 0) { tticks = mstohz(kn->kn_sdata); - callout_schedule((struct callout *)kn->kn_hook, tticks); + callout_schedule((callout_t *)kn->kn_hook, tticks); } } @@ -502,7 +516,7 @@ filt_timerexpire(void *knx) static int filt_timerattach(struct knote *kn) { - struct callout *calloutp; + callout_t *calloutp; int tticks; if (kq_ncallouts >= kq_calloutmax) @@ -519,9 +533,9 @@ filt_timerattach(struct knote *kn) } kn->kn_flags |= EV_CLEAR; /* automatically set */ - MALLOC(calloutp, struct callout *, sizeof(*calloutp), + MALLOC(calloutp, callout_t *, sizeof(*calloutp), M_KEVENT, 0); - callout_init(calloutp); + callout_init(calloutp, 0); callout_reset(calloutp, tticks, filt_timerexpire, kn); kn->kn_hook = calloutp; @@ -531,10 +545,11 @@ filt_timerattach(struct knote *kn) static void filt_timerdetach(struct knote *kn) { - struct callout *calloutp; + callout_t *calloutp; - calloutp = (struct callout *)kn->kn_hook; + calloutp = (callout_t *)kn->kn_hook; callout_stop(calloutp); + callout_destroy(calloutp); FREE(calloutp, M_KEVENT); kq_ncallouts--; } @@ -573,7 +588,7 @@ filt_seltruedetach(struct knote *kn) /* Nothing to do */ } -static const struct filterops seltrue_filtops = +const struct filterops seltrue_filtops = { 1, NULL, filt_seltruedetach, filt_seltrue }; int @@ -585,7 +600,7 @@ seltrue_kqfilter(dev_t dev, struct knote kn->kn_fop = &seltrue_filtops; break; default: - return (1); + return (EINVAL); } /* Nothing more to do */ @@ -601,12 +616,10 @@ sys_kqueue(struct lwp *l, void *v, regis struct filedesc *fdp; struct kqueue *kq; struct file *fp; - struct proc *p; int fd, error; - p = l->l_proc; - fdp = p->p_fd; - error = falloc(p, &fp, &fd); /* setup a new file descriptor */ + fdp = l->l_proc->p_fd; + error = falloc(l, &fp, &fd); /* setup a new file descriptor */ if (error) return (error); fp->f_flag = FREAD | FWRITE; @@ -616,19 +629,40 @@ sys_kqueue(struct lwp *l, void *v, regis memset((char *)kq, 0, sizeof(struct kqueue)); simple_lock_init(&kq->kq_lock); TAILQ_INIT(&kq->kq_head); - fp->f_data = (caddr_t)kq; /* store the kqueue with the fp */ + fp->f_data = (void *)kq; /* store the kqueue with the fp */ *retval = fd; if (fdp->fd_knlistsize < 0) fdp->fd_knlistsize = 0; /* this process has a kq */ kq->kq_fdp = fdp; FILE_SET_MATURE(fp); - FILE_UNUSE(fp, p); /* falloc() does FILE_USE() */ + FILE_UNUSE(fp, l); /* falloc() does FILE_USE() */ return (error); } /* * kevent(2) system call. */ +static int +kevent_fetch_changes(void *private, const struct kevent *changelist, + struct kevent *changes, size_t index, int n) +{ + return copyin(changelist + index, changes, n * sizeof(*changes)); +} + +static int +kevent_put_events(void *private, struct kevent *events, + struct kevent *eventlist, size_t index, int n) +{ + return copyout(events, eventlist + index, n * sizeof(*events)); +} + +static const struct kevent_ops kevent_native_ops = { + keo_private: NULL, + keo_fetch_timeout: copyin, + keo_fetch_changes: kevent_fetch_changes, + keo_put_events: kevent_put_events, +}; + int sys_kevent(struct lwp *l, void *v, register_t *retval) { @@ -640,69 +674,81 @@ sys_kevent(struct lwp *l, void *v, regis syscallarg(size_t) nevents; syscallarg(const struct timespec *) timeout; } */ *uap = v; + + return kevent1(l, retval, SCARG(uap, fd), SCARG(uap, changelist), + SCARG(uap, nchanges), SCARG(uap, eventlist), SCARG(uap, nevents), + SCARG(uap, timeout), &kevent_native_ops); +} + +int +kevent1(struct lwp *l, register_t *retval, int fd, + const struct kevent *changelist, size_t nchanges, struct kevent *eventlist, + size_t nevents, const struct timespec *timeout, + const struct kevent_ops *keops) +{ struct kevent *kevp; struct kqueue *kq; struct file *fp; struct timespec ts; struct proc *p; - size_t i, n; + size_t i, n, ichange; int nerrors, error; p = l->l_proc; /* check that we're dealing with a kq */ - fp = fd_getfile(p->p_fd, SCARG(uap, fd)); + fp = fd_getfile(p->p_fd, fd); if (fp == NULL) return (EBADF); if (fp->f_type != DTYPE_KQUEUE) { - simple_unlock(&fp->f_slock); + mutex_exit(&fp->f_lock); return (EBADF); } FILE_USE(fp); - if (SCARG(uap, timeout) != NULL) { - error = copyin(SCARG(uap, timeout), &ts, sizeof(ts)); + if (timeout != NULL) { + error = (*keops->keo_fetch_timeout)(timeout, &ts, sizeof(ts)); if (error) goto done; - SCARG(uap, timeout) = &ts; + timeout = &ts; } kq = (struct kqueue *)fp->f_data; nerrors = 0; + ichange = 0; /* traverse list of events to register */ - while (SCARG(uap, nchanges) > 0) { + while (nchanges > 0) { /* copyin a maximum of KQ_EVENTS at each pass */ - n = MIN(SCARG(uap, nchanges), KQ_NEVENTS); - error = copyin(SCARG(uap, changelist), kq->kq_kev, - n * sizeof(struct kevent)); + n = MIN(nchanges, KQ_NEVENTS); + error = (*keops->keo_fetch_changes)(keops->keo_private, + changelist, kq->kq_kev, ichange, n); if (error) goto done; for (i = 0; i < n; i++) { kevp = &kq->kq_kev[i]; kevp->flags &= ~EV_SYSFLAGS; /* register each knote */ - error = kqueue_register(kq, kevp, p); + error = kqueue_register(kq, kevp, l); if (error) { - if (SCARG(uap, nevents) != 0) { + if (nevents != 0) { kevp->flags = EV_ERROR; kevp->data = error; - error = copyout((caddr_t)kevp, - (caddr_t)SCARG(uap, eventlist), - sizeof(*kevp)); + error = (*keops->keo_put_events) + (keops->keo_private, kevp, + eventlist, nerrors, 1); if (error) goto done; - SCARG(uap, eventlist)++; - SCARG(uap, nevents)--; + nevents--; nerrors++; } else { goto done; } } } - SCARG(uap, nchanges) -= n; /* update the results */ - SCARG(uap, changelist) += n; + nchanges -= n; /* update the results */ + ichange += n; } if (nerrors) { *retval = nerrors; @@ -711,10 +757,9 @@ sys_kevent(struct lwp *l, void *v, regis } /* actually scan through the events */ - error = kqueue_scan(fp, SCARG(uap, nevents), SCARG(uap, eventlist), - SCARG(uap, timeout), p, retval); + error = kqueue_scan(fp, nevents, eventlist, timeout, l, retval, keops); done: - FILE_UNUSE(fp, p); + FILE_UNUSE(fp, l); return (error); } @@ -722,7 +767,7 @@ sys_kevent(struct lwp *l, void *v, regis * Register a given kevent kev onto the kqueue */ int -kqueue_register(struct kqueue *kq, struct kevent *kev, struct proc *p) +kqueue_register(struct kqueue *kq, struct kevent *kev, struct lwp *l) { const struct kfilter *kfilter; struct filedesc *fdp; @@ -807,7 +852,7 @@ kqueue_register(struct kqueue *kq, struc knote_attach(kn, fdp); if ((error = kfilter->filtops->f_attach(kn)) != 0) { - knote_drop(kn, p, fdp); + knote_drop(kn, l, fdp); goto done; } } else { @@ -830,7 +875,7 @@ kqueue_register(struct kqueue *kq, struc } else if (kev->flags & EV_DELETE) { /* delete knote */ kn->kn_fop->f_detach(kn); - knote_drop(kn, p, fdp); + knote_drop(kn, l, fdp); goto done; } @@ -854,7 +899,7 @@ kqueue_register(struct kqueue *kq, struc done: if (fp != NULL) - FILE_UNUSE(fp, p); + FILE_UNUSE(fp, l); return (error); } @@ -866,33 +911,32 @@ kqueue_register(struct kqueue *kq, struc */ static int kqueue_scan(struct file *fp, size_t maxevents, struct kevent *ulistp, - const struct timespec *tsp, struct proc *p, register_t *retval) + const struct timespec *tsp, struct lwp *l, register_t *retval, + const struct kevent_ops *keops) { + struct proc *p = l->l_proc; struct kqueue *kq; struct kevent *kevp; - struct timeval atv; + struct timeval atv, sleeptv; struct knote *kn, *marker=NULL; - size_t count, nkev; + size_t count, nkev, nevents; int s, timeout, error; kq = (struct kqueue *)fp->f_data; count = maxevents; - nkev = error = 0; + nkev = nevents = error = 0; if (count == 0) goto done; if (tsp) { /* timeout supplied */ TIMESPEC_TO_TIMEVAL(&atv, tsp); - if (itimerfix(&atv)) { + if (inittimeleft(&atv, &sleeptv) == -1) { error = EINVAL; goto done; } - s = splclock(); - timeradd(&atv, &time, &atv); /* calc. time to wait until */ - splx(s); - timeout = hzto(&atv); + timeout = tvtohz(&atv); if (timeout <= 0) - timeout = -1; /* do poll */ + timeout = -1; /* do poll */ } else { /* no timeout, wait forever */ timeout = 0; @@ -904,13 +948,8 @@ kqueue_scan(struct file *fp, size_t maxe goto start; retry: - if (tsp) { - /* - * We have to recalculate the timeout on every retry. - */ - timeout = hzto(&atv); - if (timeout <= 0) - goto done; + if (tsp && (timeout = gettimeleft(&atv, &sleeptv)) <= 0) { + goto done; } start: @@ -978,7 +1017,7 @@ kqueue_scan(struct file *fp, size_t maxe kn->kn_status &= ~KN_QUEUED; splx(s); kn->kn_fop->f_detach(kn); - knote_drop(kn, p, p->p_fd); + knote_drop(kn, l, p->p_fd); s = splsched(); } else if (kn->kn_flags & EV_CLEAR) { /* clear state after retrieval */ @@ -996,9 +1035,9 @@ kqueue_scan(struct file *fp, size_t maxe if (nkev == KQ_NEVENTS) { /* do copyouts in KQ_NEVENTS chunks */ splx(s); - error = copyout((caddr_t)&kq->kq_kev, (caddr_t)ulistp, - sizeof(struct kevent) * nkev); - ulistp += nkev; + error = (*keops->keo_put_events)(keops->keo_private, + &kq->kq_kev[0], ulistp, nevents, nkev); + nevents += nkev; nkev = 0; kevp = kq->kq_kev; s = splsched(); @@ -1016,11 +1055,10 @@ kqueue_scan(struct file *fp, size_t maxe if (marker) FREE(marker, M_KEVENT); - if (nkev != 0) { + if (nkev != 0) /* copyout remaining events */ - error = copyout((caddr_t)&kq->kq_kev, (caddr_t)ulistp, - sizeof(struct kevent) * nkev); - } + error = (*keops->keo_put_events)(keops->keo_private, + &kq->kq_kev[0], ulistp, nevents, nkev); *retval = maxevents - count; return (error); @@ -1033,8 +1071,8 @@ kqueue_scan(struct file *fp, size_t maxe */ /*ARGSUSED*/ static int -kqueue_read(struct file *fp, off_t *offset, struct uio *uio, - struct ucred *cred, int flags) +kqueue_read(struct file *fp, off_t *offset, struct uio *uio, kauth_cred_t cred, + int flags) { return (ENXIO); @@ -1046,8 +1084,8 @@ kqueue_read(struct file *fp, off_t *offs */ /*ARGSUSED*/ static int -kqueue_write(struct file *fp, off_t *offset, struct uio *uio, - struct ucred *cred, int flags) +kqueue_write(struct file *fp, off_t *offset, struct uio *uio, kauth_cred_t cred, + int flags) { return (ENXIO); @@ -1063,7 +1101,7 @@ kqueue_write(struct file *fp, off_t *off */ /*ARGSUSED*/ static int -kqueue_ioctl(struct file *fp, u_long com, void *data, struct proc *p) +kqueue_ioctl(struct file *fp, u_long com, void *data, struct lwp *l) { struct kfilter_mapping *km; const struct kfilter *kfilter; @@ -1111,7 +1149,7 @@ kqueue_ioctl(struct file *fp, u_long com */ /*ARGSUSED*/ static int -kqueue_fcntl(struct file *fp, u_int com, void *data, struct proc *p) +kqueue_fcntl(struct file *fp, u_int com, void *data, struct lwp *l) { return (ENOTTY); @@ -1122,7 +1160,7 @@ kqueue_fcntl(struct file *fp, u_int com, * Determine if kqueue has events pending. */ static int -kqueue_poll(struct file *fp, int events, struct proc *p) +kqueue_poll(struct file *fp, int events, struct lwp *l) { struct kqueue *kq; int revents; @@ -1133,7 +1171,7 @@ kqueue_poll(struct file *fp, int events, if (kq->kq_count) { revents |= events & (POLLIN | POLLRDNORM); } else { - selrecord(p, &kq->kq_sel); + selrecord(l, &kq->kq_sel); } } return (revents); @@ -1144,7 +1182,7 @@ kqueue_poll(struct file *fp, int events, * Returns dummy info, with st_size being number of events pending. */ static int -kqueue_stat(struct file *fp, struct stat *st, struct proc *p) +kqueue_stat(struct file *fp, struct stat *st, struct lwp *l) { struct kqueue *kq; @@ -1161,8 +1199,9 @@ kqueue_stat(struct file *fp, struct stat * Cleans up kqueue. */ static int -kqueue_close(struct file *fp, struct proc *p) +kqueue_close(struct file *fp, struct lwp *l) { + struct proc *p = l->l_proc; struct kqueue *kq; struct filedesc *fdp; struct knote **knp, *kn, *kn0; @@ -1177,7 +1216,7 @@ kqueue_close(struct file *fp, struct pro kn0 = SLIST_NEXT(kn, kn_link); if (kq == kn->kn_kq) { kn->kn_fop->f_detach(kn); - FILE_UNUSE(kn->kn_fp, p); + FILE_UNUSE(kn->kn_fp, l); pool_put(&knote_pool, kn); *knp = kn0; } else { @@ -1268,13 +1307,13 @@ knote(struct klist *list, long hint) * Remove all knotes from a specified klist */ void -knote_remove(struct proc *p, struct klist *list) +knote_remove(struct lwp *l, struct klist *list) { struct knote *kn; while ((kn = SLIST_FIRST(list)) != NULL) { kn->kn_fop->f_detach(kn); - knote_drop(kn, p, p->p_fd); + knote_drop(kn, l, l->l_proc->p_fd); } } @@ -1282,14 +1321,14 @@ knote_remove(struct proc *p, struct klis * Remove all knotes referencing a specified fd */ void -knote_fdclose(struct proc *p, int fd) +knote_fdclose(struct lwp *l, int fd) { struct filedesc *fdp; struct klist *list; - fdp = p->p_fd; + fdp = l->l_proc->p_fd; list = &fdp->fd_knlist[fd]; - knote_remove(p, list); + knote_remove(l, list); } /* @@ -1324,7 +1363,7 @@ knote_attach(struct knote *kn, struct fi list = malloc(size * sizeof(struct klist *), M_KEVENT,M_WAITOK); if (fdp->fd_knlist) { /* copy existing knlist */ - memcpy((caddr_t)list, (caddr_t)fdp->fd_knlist, + memcpy((void *)list, (void *)fdp->fd_knlist, fdp->fd_knlistsize * sizeof(struct klist *)); } /* @@ -1355,7 +1394,7 @@ knote_attach(struct knote *kn, struct fi * while calling FILE_UNUSE and free. */ static void -knote_drop(struct knote *kn, struct proc *p, struct filedesc *fdp) +knote_drop(struct knote *kn, struct lwp *l, struct filedesc *fdp) { struct klist *list; @@ -1368,7 +1407,7 @@ knote_drop(struct knote *kn, struct proc if (kn->kn_status & KN_QUEUED) knote_dequeue(kn); if (kn->kn_fop->f_isfd) - FILE_UNUSE(kn->kn_fp, p); + FILE_UNUSE(kn->kn_fp, l); pool_put(&knote_pool, kn); }