Пример #1
0
def pthread_kill(space, tid, signum):
    "Send a signal to a thread."
    ret = c_pthread_kill(tid, signum)
    if widen(ret) < 0:
        raise exception_from_saved_errno(space, space.w_OSError)
    # the signal may have been send to the current thread
    space.getexecutioncontext().checksignals()
Пример #2
0
 def clock_getres(space, clk_id):
     with lltype.scoped_alloc(rtime.TIMESPEC) as tp:
         ret = rtime.c_clock_getres(clk_id, tp)
         if ret != 0:
             raise exception_from_saved_errno(space, space.w_IOError)
         t = float(rffi.getintfield(tp, "c_tv_sec")) + float(rffi.getintfield(tp, "c_tv_nsec")) * 0.000000001
     return space.wrap(t)
Пример #3
0
 def clock_getres(space, clk_id):
     with lltype.scoped_alloc(TIMESPEC) as timespec:
         ret = c_clock_getres(clk_id, timespec)
         if ret != 0:
             raise exception_from_saved_errno(space, space.w_OSError)
         secs = _timespec_to_seconds(timespec)
     return space.newfloat(secs)
Пример #4
0
    def descr_poll(self, space, timeout=-1.0, maxevents=-1):
        self.check_closed(space)
        if timeout < 0:
            timeout = -1.0
        else:
            timeout *= 1000.0

        if maxevents == -1:
            maxevents = FD_SETSIZE - 1
        elif maxevents < 1:
            raise oefmt(space.w_ValueError,
                        "maxevents must be greater than 0, not %d", maxevents)

        with lltype.scoped_alloc(rffi.CArray(epoll_event), maxevents) as evs:
            nfds = epoll_wait(self.epfd, evs, maxevents, int(timeout))
            if nfds < 0:
                raise exception_from_saved_errno(space, space.w_IOError)

            elist_w = [None] * nfds
            for i in xrange(nfds):
                event = evs[i]
                elist_w[i] = space.newtuple([
                    space.newint(event.c_data.c_fd),
                    space.newint(event.c_events)
                ])
            return space.newlist(elist_w)
Пример #5
0
    def descr_poll(self, space, timeout=-1.0, maxevents=-1):
        self.check_closed(space)
        if timeout < 0:
            timeout = -1.0
        else:
            timeout *= 1000.0

        if maxevents == -1:
            maxevents = FD_SETSIZE - 1
        elif maxevents < 1:
            raise oefmt(space.w_ValueError,
                        "maxevents must be greater than 0, not %d", maxevents)

        with lltype.scoped_alloc(rffi.CArray(epoll_event), maxevents) as evs:
            nfds = epoll_wait(self.epfd, evs, maxevents, int(timeout))
            if nfds < 0:
                raise exception_from_saved_errno(space, space.w_IOError)

            elist_w = [None] * nfds
            for i in xrange(nfds):
                event = evs[i]
                elist_w[i] = space.newtuple(
                    [space.wrap(event.c_data.c_fd), space.wrap(event.c_events)]
                )
            return space.newlist(elist_w)
Пример #6
0
 def epoll_ctl(self, space, ctl, w_fd, eventmask, ignore_ebadf=False):
     fd = space.c_filedescriptor_w(w_fd)
     result = pypy_epoll_ctl(self.epfd, ctl, fd,
                             rffi.cast(rffi.UINT, eventmask))
     if ignore_ebadf and get_saved_errno() == errno.EBADF:
         result = 0
     if result < 0:
         raise exception_from_saved_errno(space, space.w_IOError)
Пример #7
0
 def clock_getres(space, clk_id):
     with lltype.scoped_alloc(rtime.TIMESPEC) as tp:
         ret = rtime.c_clock_getres(clk_id, tp)
         if ret != 0:
             raise exception_from_saved_errno(space, space.w_IOError)
         t = (float(rffi.getintfield(tp, 'c_tv_sec')) +
              float(rffi.getintfield(tp, 'c_tv_nsec')) * 0.000000001)
     return space.newfloat(t)
Пример #8
0
def sigwait(space, w_signals):
    with SignalMask(space, w_signals) as sigset:
        with lltype.scoped_alloc(rffi.INTP.TO, 1) as signum_ptr:
            ret = c_sigwait(sigset, signum_ptr)
            if ret != 0:
                raise exception_from_saved_errno(space, space.w_OSError)
            signum = signum_ptr[0]
    return space.newint(signum)
Пример #9
0
 def descr__new__(space, w_subtype):
     kqfd = syscall_kqueue()
     if kqfd < 0:
         raise exception_from_saved_errno(space, space.w_IOError)
     try:
         rposix.set_inheritable(kqfd, False)
     except OSError as e:
         raise wrap_oserror(space, e)
     return W_Kqueue(space, kqfd)
Пример #10
0
    def descr__new__(space, w_subtype, sizehint=0, flags=0):
        if sizehint < 0:     # 'sizehint' is otherwise ignored
            raise oefmt(space.w_ValueError,
                        "sizehint must be greater than zero, got %d", sizehint)
        epfd = epoll_create1(flags | EPOLL_CLOEXEC)
        if epfd < 0:
            raise exception_from_saved_errno(space, space.w_IOError)

        return W_Epoll(space, epfd)
Пример #11
0
 def clock_settime(space, clk_id, secs):
     with lltype.scoped_alloc(TIMESPEC) as timespec:
         integer_secs = rffi.cast(TIMESPEC.c_tv_sec, secs)
         frac = secs - widen(integer_secs)
         rffi.setintfield(timespec, 'c_tv_sec', integer_secs)
         rffi.setintfield(timespec, 'c_tv_nsec', int(frac * 1e9))
         ret = c_clock_settime(clk_id, timespec)
         if ret != 0:
             raise exception_from_saved_errno(space, space.w_OSError)
Пример #12
0
def pthread_sigmask(space, how, w_signals):
    with SignalMask(space, w_signals) as sigset:
        with lltype.scoped_alloc(c_sigset_t.TO) as previous:
            ret = c_pthread_sigmask(how, sigset, previous)
            if ret != 0:
                raise exception_from_saved_errno(space, space.w_OSError)
            # if signals was unblocked, signal handlers have been called
            space.getexecutioncontext().checksignals()
            return _sigset_to_signals(space, previous)
Пример #13
0
def siginterrupt(space, signum, flag):
    """siginterrupt(sig, flag) -> None

    change system call restart behaviour: if flag is False, system calls
    will be restarted when interrupted by signal sig, else system calls
    will be interrupted.
    """
    check_signum_in_range(space, signum)
    if rffi.cast(lltype.Signed, c_siginterrupt(signum, flag)) < 0:
        raise exception_from_saved_errno(space, space.w_OSError)
Пример #14
0
    def descr__new__(space, w_subtype, sizehint=-1):
        if sizehint == -1:
            sizehint = FD_SETSIZE - 1
        elif sizehint < 0:
            raise oefmt(space.w_ValueError, "sizehint must be greater than zero, got %d", sizehint)
        epfd = epoll_create(sizehint)
        if epfd < 0:
            raise exception_from_saved_errno(space, space.w_IOError)

        return space.wrap(W_Epoll(space, epfd))
Пример #15
0
    def epoll_ctl(self, space, ctl, w_fd, eventmask, ignore_ebadf=False):
        fd = space.c_filedescriptor_w(w_fd)
        with lltype.scoped_alloc(epoll_event) as ev:
            ev.c_events = rffi.cast(rffi.UINT, eventmask)
            rffi.setintfield(ev.c_data, "c_fd", fd)

            result = epoll_ctl(self.epfd, ctl, fd, ev)
            if ignore_ebadf and get_saved_errno() == errno.EBADF:
                result = 0
            if result < 0:
                raise exception_from_saved_errno(space, space.w_IOError)
Пример #16
0
    def descr__new__(space, w_subtype, sizehint=-1):
        if sizehint == -1:
            sizehint = FD_SETSIZE - 1
        elif sizehint < 0:
            raise oefmt(space.w_ValueError,
                        "sizehint must be greater than zero, got %d", sizehint)
        epfd = epoll_create(sizehint)
        if epfd < 0:
            raise exception_from_saved_errno(space, space.w_IOError)

        return W_Epoll(space, epfd)
Пример #17
0
    def descr__new__(space, w_subtype, sizehint=-1, flags=0):
        if sizehint == -1:
            sizehint = FD_SETSIZE - 1
        elif sizehint <= 0:     # 'sizehint' is otherwise ignored
            raise oefmt(space.w_ValueError,
                        "sizehint must be positive or -1")
        epfd = epoll_create1(flags | EPOLL_CLOEXEC)
        if epfd < 0:
            raise exception_from_saved_errno(space, space.w_IOError)

        return W_Epoll(space, epfd)
Пример #18
0
    def epoll_ctl(self, space, ctl, w_fd, eventmask, ignore_ebadf=False):
        fd = space.c_filedescriptor_w(w_fd)
        with lltype.scoped_alloc(epoll_event) as ev:
            ev.c_events = rffi.cast(rffi.UINT, eventmask)
            rffi.setintfield(ev.c_data, 'c_fd', fd)

            result = epoll_ctl(self.epfd, ctl, fd, ev)
            if ignore_ebadf and get_saved_errno() == errno.EBADF:
                result = 0
            if result < 0:
                raise exception_from_saved_errno(space, space.w_IOError)
Пример #19
0
def cloexec_pipe(space):
    """cloexec_pipe() -> (read_end, write_end)

    Create a pipe whose ends have the cloexec flag set."""

    with lltype.scoped_alloc(rffi.CArrayPtr(rffi.INT).TO, 2) as fds:
        res = c_cloexec_pipe(fds)
        if res != 0:
            raise exception_from_saved_errno(space, space.w_OSError)

        return space.newtuple([space.wrap(fds[0]),
                               space.wrap(fds[1]),
                               ])
def cloexec_pipe(space):
    """cloexec_pipe() -> (read_end, write_end)

    Create a pipe whose ends have the cloexec flag set."""

    with lltype.scoped_alloc(rffi.CArrayPtr(rffi.INT).TO, 2) as fds:
        res = c_cloexec_pipe(fds)
        if res != 0:
            raise exception_from_saved_errno(space, space.w_OSError)

        return space.newtuple([
            space.newint(fds[0]),
            space.newint(fds[1]),
        ])
Пример #21
0
def setitimer(space, which, first, interval=0):
    """setitimer(which, seconds[, interval])
    Sets given itimer (one of ITIMER_REAL, ITIMER_VIRTUAL

    or ITIMER_PROF) to fire after value seconds and after
    that every interval seconds.
    The itimer can be cleared by setting seconds to zero.

    Returns old values as a tuple: (delay, interval).
    """
    with lltype.scoped_alloc(itimervalP.TO, 1) as new:

        timeval_from_double(first, new[0].c_it_value)
        timeval_from_double(interval, new[0].c_it_interval)

        with lltype.scoped_alloc(itimervalP.TO, 1) as old:

            ret = c_setitimer(which, new, old)
            if ret != 0:
                raise exception_from_saved_errno(space, get_itimer_error(space))

            return itimer_retval(space, old[0])
Пример #22
0
def setitimer(space, which, first, interval=0):
    """setitimer(which, seconds[, interval])
    Sets given itimer (one of ITIMER_REAL, ITIMER_VIRTUAL

    or ITIMER_PROF) to fire after value seconds and after
    that every interval seconds.
    The itimer can be cleared by setting seconds to zero.

    Returns old values as a tuple: (delay, interval).
    """
    with lltype.scoped_alloc(itimervalP.TO, 1) as new:

        timeval_from_double(first, new[0].c_it_value)
        timeval_from_double(interval, new[0].c_it_interval)

        with lltype.scoped_alloc(itimervalP.TO, 1) as old:

            ret = c_setitimer(which, new, old)
            if ret != 0:
                raise exception_from_saved_errno(space,
                                                 get_itimer_error(space))

            return itimer_retval(space, old[0])
Пример #23
0
def sleep(space, w_secs):
    ns = timestamp_w(space, w_secs)
    if not (ns >= 0):
        raise oefmt(space.w_ValueError, "sleep length must be non-negative")
    end_time = _monotonic(space) + float(ns) / SECS_TO_NS
    while True:
        if _WIN:
            # as decreed by Guido, only the main thread can be
            # interrupted.
            main_thread = space.fromcache(State).main_thread
            interruptible = (main_thread == thread.get_ident())
            millisecs = ns // MS_TO_NS
            if millisecs == 0 or not interruptible:
                rtime.sleep(float(ns) / SECS_TO_NS)
                break
            interrupt_event = space.fromcache(State).get_interrupt_event()
            rwin32.ResetEvent(interrupt_event)
            rc = rwin32.WaitForSingleObject(interrupt_event, millisecs)
            if rc != rwin32.WAIT_OBJECT_0:
                break
        else:
            void = lltype.nullptr(rffi.VOIDP.TO)
            with lltype.scoped_alloc(TIMEVAL) as t:
                seconds = ns // SECS_TO_NS
                us = (ns % SECS_TO_NS) // US_TO_NS
                rffi.setintfield(t, 'c_tv_sec', int(seconds))
                rffi.setintfield(t, 'c_tv_usec', int(us))

                res = rffi.cast(rffi.LONG, c_select(0, void, void, void, t))
            if res == 0:
                break  # normal path
            if rposix.get_saved_errno() != EINTR:
                raise exception_from_saved_errno(space, space.w_OSError)
        space.getexecutioncontext().checksignals()
        secs = end_time - _monotonic(space)  # retry
        if secs <= 0:
            break
Пример #24
0
    def descr_poll(self, space, timeout=-1.0, maxevents=-1):
        self.check_closed(space)
        if timeout < 0:
            end_time = 0.0
            itimeout = -1
        else:
            end_time = timeutils.monotonic(space) + timeout
            itimeout = int(timeout * 1000.0 + 0.999)

        if maxevents == -1:
            maxevents = FD_SETSIZE - 1
        elif maxevents < 1:
            raise oefmt(space.w_ValueError,
                        "maxevents must be greater than 0, not %d", maxevents)

        with lltype.scoped_alloc(rffi.CArray(epoll_event), maxevents) as evs:
            while True:
                nfds = epoll_wait(self.epfd, evs, maxevents, itimeout)
                if nfds < 0:
                    if get_saved_errno() == errno.EINTR:
                        space.getexecutioncontext().checksignals()
                        if itimeout >= 0:
                            timeout = end_time - timeutils.monotonic(space)
                            timeout = max(timeout, 0.0)
                            itimeout = int(timeout * 1000.0 + 0.999)
                        continue
                    raise exception_from_saved_errno(space, space.w_IOError)
                break

            elist_w = [None] * nfds
            for i in xrange(nfds):
                event = evs[i]
                elist_w[i] = space.newtuple(
                    [space.newint(event.c_data.c_fd), space.newint(event.c_events)]
                )
            return space.newlist(elist_w)
Пример #25
0
def PyFile_AsFile(space, w_p):
    """Return the file object associated with p as a FILE*.
    
    If the caller will ever use the returned FILE* object while
    the GIL is released it must also call the PyFile_IncUseCount() and
    PyFile_DecUseCount() functions as appropriate."""
    if not PyFile_Check(space, w_p):
        raise oefmt(space.w_IOError, 'first argument must be an open file')
    assert isinstance(w_p, W_File)
    w_p.stream.flush_buffers()
    try:
        fd = space.int_w(space.call_method(w_p, 'fileno'))
        mode = w_p.mode
    except OperationError as e:
        raise oefmt(space.w_IOError, 'could not call fileno') 
    if (fd < 0 or not mode or mode[0] not in ['r', 'w', 'a', 'U'] or
        ('U' in mode and ('w' in mode or 'a' in mode))):
        raise oefmt(space.w_IOError, 'invalid fileno or mode') 
    ret = c_fdopen(fd, mode)
    if not ret:
        raise exception_from_saved_errno(space, space.w_IOError)
    # XXX fix this once use-file-star-for-file lands
    c_setvbuf(ret, lltype.nullptr(rffi.CCHARP.TO), _IONBF, 0)
    return ret
Пример #26
0
def PyFile_AsFile(space, w_p):
    """Return the file object associated with p as a FILE*.
    
    If the caller will ever use the returned FILE* object while
    the GIL is released it must also call the PyFile_IncUseCount() and
    PyFile_DecUseCount() functions as appropriate."""
    if not PyFile_Check(space, w_p):
        raise oefmt(space.w_IOError, 'first argument must be an open file')
    assert isinstance(w_p, W_File)
    w_p.stream.flush_buffers()
    try:
        fd = space.int_w(space.call_method(w_p, 'fileno'))
        mode = w_p.mode
    except OperationError as e:
        raise oefmt(space.w_IOError, 'could not call fileno') 
    if (fd < 0 or not mode or mode[0] not in ['r', 'w', 'a', 'U'] or
        ('U' in mode and ('w' in mode or 'a' in mode))):
        raise oefmt(space.w_IOError, 'invalid fileno or mode') 
    ret = c_fdopen(fd, mode)
    if not ret:
        raise exception_from_saved_errno(space, space.w_IOError)
    # XXX fix this once use-file-star-for-file lands
    c_setvbuf(ret, lltype.nullptr(rffi.CCHARP.TO), _IONBF, 0)
    return ret
Пример #27
0
    def descr_control(self, space, w_changelist, max_events, w_timeout):

        self.check_closed(space)

        if max_events < 0:
            raise oefmt(space.w_ValueError,
                        "Length of eventlist must be 0 or positive, got %d",
                        max_events)

        if space.is_w(w_changelist, space.w_None):
            changelist_len = 0
        else:
            changelist_len = space.len_w(w_changelist)

        with lltype.scoped_alloc(rffi.CArray(kevent),
                                 changelist_len) as changelist:
            with lltype.scoped_alloc(rffi.CArray(kevent),
                                     max_events) as eventlist:
                with lltype.scoped_alloc(timespec) as timeout:

                    if not space.is_w(w_timeout, space.w_None):
                        _timeout = space.float_w(w_timeout)
                        if _timeout < 0:
                            raise oefmt(
                                space.w_ValueError,
                                "Timeout must be None or >= 0, got %s",
                                str(_timeout))
                        sec = int(_timeout)
                        nsec = int(1e9 * (_timeout - sec))
                        rffi.setintfield(timeout, 'c_tv_sec', sec)
                        rffi.setintfield(timeout, 'c_tv_nsec', nsec)
                        ptimeout = timeout
                    else:
                        ptimeout = lltype.nullptr(timespec)

                    if not space.is_w(w_changelist, space.w_None):
                        i = 0
                        for w_ev in space.listview(w_changelist):
                            ev = space.interp_w(W_Kevent, w_ev)
                            changelist[i].c_ident = ev.ident
                            changelist[i].c_filter = ev.filter
                            changelist[i].c_flags = ev.flags
                            changelist[i].c_fflags = ev.fflags
                            changelist[i].c_data = ev.data
                            changelist[i].c_udata = ev.udata
                            i += 1
                        pchangelist = changelist
                    else:
                        pchangelist = lltype.nullptr(rffi.CArray(kevent))

                    nfds = syscall_kevent(self.kqfd, pchangelist,
                                          changelist_len, eventlist,
                                          max_events, ptimeout)
                    if nfds < 0:
                        raise exception_from_saved_errno(
                            space, space.w_OSError)
                    else:
                        elist_w = [None] * nfds
                        for i in xrange(nfds):

                            evt = eventlist[i]

                            w_event = W_Kevent(space)
                            w_event.ident = evt.c_ident
                            w_event.filter = evt.c_filter
                            w_event.flags = evt.c_flags
                            w_event.fflags = evt.c_fflags
                            w_event.data = evt.c_data
                            w_event.udata = evt.c_udata

                            elist_w[i] = w_event

                    return space.newlist(elist_w)
Пример #28
0
 def descr__new__(space, w_subtype):
     kqfd = syscall_kqueue()
     if kqfd < 0:
         raise exception_from_saved_errno(space, space.w_IOError)
     return W_Kqueue(space, kqfd)
Пример #29
0
    def descr_control(self, space, w_changelist, max_events, w_timeout):

        self.check_closed(space)

        if max_events < 0:
            raise oefmt(space.w_ValueError,
                        "Length of eventlist must be 0 or positive, got %d",
                        max_events)

        if space.is_w(w_changelist, space.w_None):
            changelist_len = 0
        else:
            changelist_len = space.len_w(w_changelist)

        with lltype.scoped_alloc(rffi.CArray(kevent), changelist_len) as changelist:
            with lltype.scoped_alloc(rffi.CArray(kevent), max_events) as eventlist:
                with lltype.scoped_alloc(timespec) as timeout:

                    if not space.is_w(w_timeout, space.w_None):
                        _timeout = space.float_w(w_timeout)
                        if _timeout < 0:
                            raise oefmt(space.w_ValueError,
                                        "Timeout must be None or >= 0, got %s",
                                        str(_timeout))
                        sec = int(_timeout)
                        nsec = int(1e9 * (_timeout - sec))
                        rffi.setintfield(timeout, 'c_tv_sec', sec)
                        rffi.setintfield(timeout, 'c_tv_nsec', nsec)
                        ptimeout = timeout
                    else:
                        ptimeout = lltype.nullptr(timespec)

                    if not space.is_w(w_changelist, space.w_None):
                        i = 0
                        for w_ev in space.listview(w_changelist):
                            ev = space.interp_w(W_Kevent, w_ev)
                            changelist[i].c_ident = ev.ident
                            changelist[i].c_filter = ev.filter
                            changelist[i].c_flags = ev.flags
                            changelist[i].c_fflags = ev.fflags
                            changelist[i].c_data = ev.data
                            changelist[i].c_udata = ev.udata
                            i += 1
                        pchangelist = changelist
                    else:
                        pchangelist = lltype.nullptr(rffi.CArray(kevent))

                    nfds = syscall_kevent(self.kqfd,
                                          pchangelist,
                                          changelist_len,
                                          eventlist,
                                          max_events,
                                          ptimeout)
                    if nfds < 0:
                        raise exception_from_saved_errno(space, space.w_OSError)
                    else:
                        elist_w = [None] * nfds
                        for i in xrange(nfds):

                            evt = eventlist[i]

                            w_event = W_Kevent(space)
                            w_event.ident = evt.c_ident
                            w_event.filter = evt.c_filter
                            w_event.flags = evt.c_flags
                            w_event.fflags = evt.c_fflags
                            w_event.data = evt.c_data
                            w_event.udata = evt.c_udata

                            elist_w[i] = w_event

                    return space.newlist(elist_w)
Пример #30
0
 def descr__new__(space, w_subtype):
     kqfd = syscall_kqueue()
     if kqfd < 0:
         raise exception_from_saved_errno(space, space.w_IOError)
     return space.wrap(W_Kqueue(space, kqfd))
Пример #31
0
 def clock_getres(space, clk_id):
     with lltype.scoped_alloc(TIMESPEC) as tp:
         ret = c_clock_getres(clk_id, tp)
         if ret != 0:
             raise exception_from_saved_errno(space, space.w_IOError)
         return space.wrap(int(tp.c_tv_sec) + 1e-9 * int(tp.c_tv_nsec))
Пример #32
0
def sigpending(space):
    with lltype.scoped_alloc(c_sigset_t.TO) as mask:
        ret = c_sigpending(mask)
        if ret != 0:
            raise exception_from_saved_errno(space, space.w_OSError)
        return _sigset_to_signals(space, mask)
Пример #33
0
 def clock_getres(space, clk_id):
     with lltype.scoped_alloc(TIMESPEC) as tp:
         ret = c_clock_getres(clk_id, tp)
         if ret != 0:
             raise exception_from_saved_errno(space, space.w_IOError)
         return space.wrap(int(tp.c_tv_sec) + 1e-9 * int(tp.c_tv_nsec))
Пример #34
0
    def descr_control(self, space, w_changelist, max_events, w_timeout):

        self.check_closed(space)

        if max_events < 0:
            raise oefmt(space.w_ValueError,
                        "Length of eventlist must be 0 or positive, got %d",
                        max_events)

        if space.is_w(w_changelist, space.w_None):
            changelist_len = 0
        else:
            changelist_len = space.len_w(w_changelist)

        with lltype.scoped_alloc(rffi.CArray(kevent),
                                 changelist_len) as changelist:
            with lltype.scoped_alloc(rffi.CArray(kevent),
                                     max_events) as eventlist:
                with lltype.scoped_alloc(timespec) as timeout:

                    if not space.is_w(w_timeout, space.w_None):
                        _timeout = space.float_w(w_timeout)
                        if _timeout < 0:
                            raise oefmt(
                                space.w_ValueError,
                                "Timeout must be None or >= 0, got %s",
                                str(_timeout))
                        fill_timespec(_timeout, timeout)
                        timeout_at = timeutils.monotonic(space) + _timeout
                        ptimeout = timeout
                    else:
                        timeout_at = 0.0
                        ptimeout = lltype.nullptr(timespec)

                    if not space.is_w(w_changelist, space.w_None):
                        i = 0
                        for w_ev in space.listview(w_changelist):
                            ev = space.interp_w(W_Kevent, w_ev)
                            changelist[i].c_ident = ev.ident
                            changelist[i].c_filter = ev.filter
                            changelist[i].c_flags = ev.flags
                            changelist[i].c_fflags = ev.fflags
                            changelist[i].c_data = ev.data
                            changelist[i].c_udata = ev.udata
                            i += 1
                        pchangelist = changelist
                    else:
                        pchangelist = lltype.nullptr(rffi.CArray(kevent))

                    while True:
                        nfds = syscall_kevent(self.kqfd, pchangelist,
                                              changelist_len, eventlist,
                                              max_events, ptimeout)
                        if nfds >= 0:
                            break
                        if rposix.get_saved_errno() != errno.EINTR:
                            raise exception_from_saved_errno(
                                space, space.w_OSError)
                        space.getexecutioncontext().checksignals()
                        if ptimeout:
                            _timeout = (timeout_at -
                                        timeutils.monotonic(space))
                            if _timeout < 0.0:
                                _timeout = 0.0
                            fill_timespec(_timeout, ptimeout)

                    elist_w = [None] * nfds
                    for i in xrange(nfds):

                        evt = eventlist[i]

                        w_event = W_Kevent(space)
                        w_event.ident = evt.c_ident
                        w_event.filter = evt.c_filter
                        w_event.flags = evt.c_flags
                        w_event.fflags = evt.c_fflags
                        w_event.data = evt.c_data
                        w_event.udata = evt.c_udata

                        elist_w[i] = w_event

                    return space.newlist(elist_w)