Example #1
0
Window::Window(long left, long top, long right, long bottom)
	:	fShowLevel(0),
		fCanvasList(0)
{
 	int windowServerPort;
 	windowServerPort = namer_find ("window_server", 0);
 	if (windowServerPort <= 0) {
 		printf("couldn't connect to window server\n");
 		return;
 	}

	int localReplyPort = port_create(0, "client_syncport");
	fEventPort = port_create(0, "client_eventport");

 	fConnection = new Connection(windowServerPort, localReplyPort);
 	fConnection->WriteInt8(OP_CREATE_WINDOW);
 	fConnection->WriteInt32(0);			// Child of root window
 	fConnection->WriteInt32(left);
 	fConnection->WriteInt32(top);
 	fConnection->WriteInt32(right);
 	fConnection->WriteInt32(bottom);
 	fConnection->WriteInt32(fEventPort);
 	fConnection->Flush();
 	fID = fConnection->ReadInt32();

 	fLock = qsem_create(1);

	thr_create((void*) EventLoop, this, "win_thread");
}
Example #2
0
static void*
evport_init(struct event_base *base)
{
	struct evport_data *evpd;

	if (!(evpd = mm_calloc(1, sizeof(struct evport_data))))
		return (NULL);

	if ((evpd->ed_port = port_create()) == -1) {
		mm_free(evpd);
		return (NULL);
	}

	if (grow(evpd, INITIAL_EVENTS_PER_GETN) < 0) {
		close(evpd->ed_port);
		mm_free(evpd);
		return NULL;
	}
		
	evpd->ed_npending = 0;

	evsig_init_(base);

	return (evpd);
}
Example #3
0
void SelEpolKqEvPrt::initialize(SOCKET sockfd, const int& timeout)
{
	this->timeoutMilis = timeout;
	this->sockfd = sockfd;
	if(sockfd<=0)
	{
		listenerMode = false;
		sockfd = 0;
	}
	else
	{
		listenerMode = true;
	}
	curfds = 1;
	#if defined(USE_WIN_IOCP)
		initIOCP();
	#elif defined(USE_MINGW_SELECT)
		fdMax = sockfd;
		FD_ZERO(&readfds);
		FD_ZERO(&master);
	#elif defined(USE_SELECT)
		fdsetSize = MAXDESCRIPTORS/FD_SETSIZE;
		fdMax = sockfd;
		for (int var = 0; var < fdsetSize; ++var) {
			FD_ZERO(&readfds[var]);
			FD_ZERO(&master[var]);
		}
	#elif defined USE_EPOLL
		epoll_handle = epoll_create(MAXDESCRIPTORS);
		memset(&ev, 0, sizeof(ev));
	#elif defined USE_KQUEUE
		kq = kqueue();
		if (kq == -1)
		{
			perror("kqueue");
		}
	#elif defined USE_DEVPOLL
		if((dev_poll_fd = open("/dev/poll", O_RDWR)) <0)
		{
			perror("devpoll");
		}
		if (fcntl(dev_poll_fd, F_SETFD, FD_CLOEXEC) < 0)
		{
			perror("devpoll fcntl");
		}
	#elif defined USE_EVPORT
		if ((port = port_create()) < 0) {
			perror("port_create");
		}
	#elif defined USE_POLL
		nfds=1;
		polled_fds = (struct pollfd *)calloc(1, nfds*sizeof(struct pollfd));
		polled_fds->fd = descriptor;
		polled_fds->events = POLLIN | POLLPRI;
		return;
	#endif
	#if !defined(USE_WIN_IOCP)
		if(sockfd>0)registerForEvent(sockfd);
	#endif
}
RTDECL(int) RTFileAioCtxCreate(PRTFILEAIOCTX phAioCtx, uint32_t cAioReqsMax,
                               uint32_t fFlags)
{
    int rc = VINF_SUCCESS;
    PRTFILEAIOCTXINTERNAL pCtxInt;
    AssertPtrReturn(phAioCtx, VERR_INVALID_POINTER);
    AssertReturn(!(fFlags & ~RTFILEAIOCTX_FLAGS_VALID_MASK), VERR_INVALID_PARAMETER);

    pCtxInt = (PRTFILEAIOCTXINTERNAL)RTMemAllocZ(sizeof(RTFILEAIOCTXINTERNAL));
    if (RT_UNLIKELY(!pCtxInt))
        return VERR_NO_MEMORY;

    /* Init the event handle. */
    pCtxInt->iPort = port_create();
    if (RT_LIKELY(pCtxInt->iPort > 0))
    {
        pCtxInt->fFlags   = fFlags;
        pCtxInt->u32Magic = RTFILEAIOCTX_MAGIC;
        *phAioCtx = (RTFILEAIOCTX)pCtxInt;
    }
    else
    {
        RTMemFree(pCtxInt);
        rc = RTErrConvertFromErrno(errno);
    }

    return rc;
}
Example #5
0
static int init_evports_per_thread()
{
	int fd;

	evports_evlist_max = global.tune.maxpollevents;
	evports_evlist = calloc(evports_evlist_max, sizeof (port_event_t));
	if (evports_evlist == NULL) {
		goto fail_alloc;
	}

	if (MAX_THREADS > 1 && tid) {
		if ((evports_fd[tid] = port_create()) == -1) {
			goto fail_fd;
		}
	}

	/* we may have to unregister some events initially registered on the
	 * original fd when it was alone, and/or to register events on the new
	 * fd for this thread. Let's just mark them as updated, the poller will
	 * do the rest.
	 */
	for (fd = 0; fd < global.maxsock; fd++)
		updt_fd_polling(fd);

	return 1;

 fail_fd:
	free(evports_evlist);
	evports_evlist = NULL;
	evports_evlist_max = 0;
 fail_alloc:
	return 0;
}
Example #6
0
File: sunos.c Project: 0x00A/uvxx
int uv_fs_event_init(uv_loop_t* loop,
                     uv_fs_event_t* handle,
                     const char* filename,
                     uv_fs_event_cb cb,
                     int flags) {
  int portfd;

  loop->counters.fs_event_init++;

  /* We don't support any flags yet. */
  assert(!flags);

  if ((portfd = port_create()) == -1) {
    uv__set_sys_error(loop, errno);
    return -1;
  }

  uv__handle_init(loop, (uv_handle_t*)handle, UV_FS_EVENT);
  handle->filename = strdup(filename);
  handle->fd = portfd;
  handle->cb = cb;

  memset(&handle->fo, 0, sizeof handle->fo);
  handle->fo.fo_name = handle->filename;
  uv__fs_event_rearm(handle);

  ev_io_init(&handle->event_watcher, uv__fs_event_read, portfd, EV_READ);
  ev_io_start(loop->ev, &handle->event_watcher);
  ev_unref(loop->ev);

  return 0;
}
Example #7
0
int ioevent_init(IOEventPoller *ioevent, const int size,
    const int timeout_ms, const int extra_events)
{
  int bytes;

  ioevent->size = size;
  ioevent->extra_events = extra_events;
  ioevent->iterator.index = 0;
  ioevent->iterator.count = 0;

#if IOEVENT_USE_EPOLL
  ioevent->poll_fd = epoll_create(ioevent->size);
  bytes = sizeof(struct epoll_event) * size;
  ioevent->events = (struct epoll_event *)malloc(bytes);
#elif IOEVENT_USE_KQUEUE
  ioevent->poll_fd = kqueue();
  bytes = sizeof(struct kevent) * size;
  ioevent->events = (struct kevent *)malloc(bytes);
  ioevent->care_events = 0;
#elif IOEVENT_USE_PORT
  ioevent->poll_fd = port_create();
  bytes = sizeof(port_event_t) * size;
  ioevent->events = (port_event_t *)malloc(bytes);
#endif

  if (ioevent->events == NULL) {
    return errno != 0 ? errno : ENOMEM;
  }
  ioevent_set_timeout(ioevent, timeout_ms);

  return 0;
}
Example #8
0
void ph_nbio_emitter_init(struct ph_nbio_emitter *emitter)
{
  struct sigevent sev;
  port_notify_t notify;
  struct itimerspec ts;

  emitter->io_fd = port_create();
  if (emitter->io_fd == -1) {
    ph_panic("port_create: `Pe%d", errno);
  }

  memset(&sev, 0, sizeof(sev));
  memset(&notify, 0, sizeof(notify));
  memset(&ts, 0, sizeof(ts));

  ts.it_interval.tv_nsec = WHEEL_INTERVAL_MS * 1000000;
  ts.it_value.tv_nsec = ts.it_interval.tv_nsec;

  notify.portnfy_port = emitter->io_fd;
  sev.sigev_notify = SIGEV_PORT;
  sev.sigev_value.sival_ptr = &notify;

  if (timer_create(CLOCK_REALTIME, &sev, &emitter->port_timer)) {
    ph_panic("failed to create timer: `Pe%d", errno);
  }
  if (timer_settime(emitter->port_timer, 0, &ts, NULL)) {
    ph_panic("failed to set timer: `Pe%d", errno);
  }
}
Example #9
0
File: sunos.c Project: 2saki/node
int uv_fs_event_init(uv_loop_t* loop,
                     uv_fs_event_t* handle,
                     const char* filename,
                     uv_fs_event_cb cb,
                     int flags) {
  int portfd;
  int first_run = 0;

  if (loop->fs_fd == -1) {
    if ((portfd = port_create()) == -1) {
      uv__set_sys_error(loop, errno);
      return -1;
    }
    loop->fs_fd = portfd;
    first_run = 1;
  }

  uv__handle_init(loop, (uv_handle_t*)handle, UV_FS_EVENT);
  uv__handle_start(handle); /* FIXME shouldn't start automatically */
  handle->filename = strdup(filename);
  handle->fd = PORT_UNUSED;
  handle->cb = cb;

  memset(&handle->fo, 0, sizeof handle->fo);
  handle->fo.fo_name = handle->filename;
  uv__fs_event_rearm(handle);

  if (first_run) {
    uv__io_init(&loop->fs_event_watcher, uv__fs_event_read, portfd);
    uv__io_start(loop, &loop->fs_event_watcher, UV__POLLIN);
  }

  return 0;
}
Example #10
0
File: port.c Project: Ga-vin/apache
static apr_status_t impl_pollcb_create(apr_pollcb_t *pollcb,
                                       apr_uint32_t size,
                                       apr_pool_t *p,
                                       apr_uint32_t flags)
{
    pollcb->fd = port_create();

    if (pollcb->fd < 0) {
        return apr_get_netos_error();
    }

    {
        int flags;

        if ((flags = fcntl(pollcb->fd, F_GETFD)) == -1)
            return errno;

        flags |= FD_CLOEXEC;
        if (fcntl(pollcb->fd, F_SETFD, flags) == -1)
            return errno;
    }

    pollcb->pollset.port = apr_palloc(p, size * sizeof(port_event_t));
    apr_pool_cleanup_register(p, pollcb, cb_cleanup, apr_pool_cleanup_null);

    return APR_SUCCESS;
}
Example #11
0
static void*
evport_init(struct event_base *base)
{
	struct evport_data *evpd;
	int i;

	if (!(evpd = mm_calloc(1, sizeof(struct evport_data))))
		return (NULL);

	if ((evpd->ed_port = port_create()) == -1) {
		mm_free(evpd);
		return (NULL);
	}

	/*
	 * Initialize file descriptor structure
	 */
	evpd->ed_fds = mm_calloc(DEFAULT_NFDS, sizeof(struct fd_info));
	if (evpd->ed_fds == NULL) {
		close(evpd->ed_port);
		mm_free(evpd);
		return (NULL);
	}
	evpd->ed_nevents = DEFAULT_NFDS;
	for (i = 0; i < EVENTS_PER_GETN; i++)
		evpd->ed_pending[i] = -1;

	evsig_init(base);

	return (evpd);
}
Example #12
0
int uv_fs_event_start(uv_fs_event_t* handle,
                      uv_fs_event_cb cb,
                      const char* filename,
                      unsigned int flags) {
  int portfd;
  int first_run;

  if (uv__is_active(handle))
    return -EINVAL;

  first_run = 0;
  if (handle->loop->fs_fd == -1) {
    portfd = port_create();
    if (portfd == -1)
      return -errno;
    handle->loop->fs_fd = portfd;
    first_run = 1;
  }

  uv__handle_start(handle);
  handle->filename = strdup(filename);
  handle->fd = PORT_UNUSED;
  handle->cb = cb;

  memset(&handle->fo, 0, sizeof handle->fo);
  handle->fo.fo_name = handle->filename;
  uv__fs_event_rearm(handle);  /* FIXME(bnoordhuis) Check return code. */

  if (first_run) {
    uv__io_init(&handle->loop->fs_event_watcher, uv__fs_event_read, portfd);
    uv__io_start(handle->loop, &handle->loop->fs_event_watcher, UV__POLLIN);
  }

  return 0;
}
Example #13
0
/*
  Reopen the port handle when our pid changes.
 */
static int port_check_reopen(struct port_event_context *port_ev)
{
	struct tevent_fd *fde;

	if (port_ev->pid == getpid()) {
		return 0;
	}

	close(port_ev->port_fd);
	port_ev->port_fd = port_create();
	if (port_ev->port_fd == -1) {
		tevent_debug(port_ev->ev, TEVENT_DEBUG_FATAL,
				"port_create() failed");
		return -1;
	}

	if (!ev_set_close_on_exec(port_ev->port_fd)) {
		tevent_debug(port_ev->ev, TEVENT_DEBUG_WARNING,
			     "Failed to set close-on-exec, file descriptor may be leaked to children.\n");
	}

	port_ev->pid = getpid();
	for (fde=port_ev->ev->fd_events;fde;fde=fde->next) {
		fde->additional_flags &= PORT_ADDITIONAL_FD_FLAG_HAS_ASSOCIATION;
		if (port_update_event(port_ev, fde) != 0) {
			return -1;
		}
	}
	return 0;
}
Example #14
0
PortsEngine::PortsEngine()
{
	int max = ulimit(4, 0);
	if (max > 0)
	{
		MAX_DESCRIPTORS = max;
	}
	else
	{
		ServerInstance->Logs->Log("SOCKET", LOG_DEFAULT, "ERROR: Can't determine maximum number of open sockets!");
		std::cout << "ERROR: Can't determine maximum number of open sockets!" << std::endl;
		ServerInstance->Exit(EXIT_STATUS_SOCKETENGINE);
	}
	EngineHandle = port_create();

	if (EngineHandle == -1)
	{
		ServerInstance->Logs->Log("SOCKET", LOG_SPARSE, "ERROR: Could not initialize socket engine: %s", strerror(errno));
		ServerInstance->Logs->Log("SOCKET", LOG_SPARSE, "ERROR: This is a fatal error, exiting now.");
		std::cout << "ERROR: Could not initialize socket engine: " << strerror(errno) << std::endl;
		std::cout << "ERROR: This is a fatal error, exiting now." << std::endl;
		ServerInstance->Exit(EXIT_STATUS_SOCKETENGINE);
	}
	CurrentSetSize = 0;

	ref = new EventHandler* [GetMaxFds()];
	events = new port_event_t[GetMaxFds()];
	memset(ref, 0, GetMaxFds() * sizeof(EventHandler*));
}
Example #15
0
void
wait_init()
{
	struct rlimit fd_new;

	(void) getrlimit(RLIMIT_NOFILE, &init_fd_rlimit);
	(void) getrlimit(RLIMIT_NOFILE, &fd_new);

	fd_new.rlim_max = fd_new.rlim_cur = WAIT_FILES;

	(void) setrlimit(RLIMIT_NOFILE, &fd_new);

	if ((port_fd = port_create()) == -1)
		uu_die("wait_init couldn't port_create");

	wait_info_pool = uu_list_pool_create("wait_info", sizeof (wait_info_t),
	    offsetof(wait_info_t, wi_link), NULL, UU_LIST_POOL_DEBUG);
	if (wait_info_pool == NULL)
		uu_die("wait_init couldn't create wait_info_pool");

	wait_info_list = uu_list_create(wait_info_pool, wait_info_list, 0);
	if (wait_info_list == NULL)
		uu_die("wait_init couldn't create wait_info_list");

	(void) pthread_mutex_init(&wait_info_lock, &mutex_attrs);
}
Example #16
0
void __libc_init_vfs (void)
{
	vfs_public_port = namer_find ("vfs", 1);
	vfs_local_port = port_create (vfs_public_port,"vfs_public_port");

	filename_area = area_create (0x1000, 0, (void **) &nameptr, 0);
	__vfs_openconn (vfs_local_port, filename_area);
}
Example #17
0
ACP_EXPORT acp_rc_t acpPollCreate(acp_poll_set_t *aPollSet,
                                  acp_sint32_t    aMaxCount)
{
    acp_rc_t sRC;

    ACP_POLL_CHECK_BEFORE_CREATE(aPollSet, aMaxCount);

    /* Create port */
    aPollSet->mHandle = port_create();

    if (aPollSet->mHandle == -1)
    {
        return ACP_RC_GET_NET_ERROR();
    }
    else
    {
        /* do nothing */
    }

    sRC = acpMemCalloc((void **)&aPollSet->mObjs,
                       aMaxCount,
                       sizeof(acp_poll_obj_t));

    if (ACP_RC_NOT_SUCCESS(sRC))
    {
        (void)close(aPollSet->mHandle);
        return sRC;
    }
    else
    {
        /* do nothing */
    }

    sRC = acpMemCalloc((void **)&aPollSet->mEvents,
                       aMaxCount,
                       sizeof(port_event_t));

    if (ACP_RC_NOT_SUCCESS(sRC))
    {
        (void)close(aPollSet->mHandle);
        acpMemFree(aPollSet->mObjs);
        return sRC;
    }
    else
    {
        /* do nothing */
    }

    aPollSet->mMaxCount    = aMaxCount;
    aPollSet->mCurCount    = 0;
    aPollSet->mEventHandle = -1;
    aPollSet->mEventsNum   = 0;
    aPollSet->mCurrEvent   = 0;

    return ACP_RC_SUCCESS;
}
Example #18
0
static void *eventer_ports_spec_alloc(void) {
  struct ports_spec *spec;
  spec = calloc(1, sizeof(*spec));
  spec->port_fd = port_create();
  if(spec->port_fd < 0) {
    mtevFatal(mtev_error, "error in eveter_ports_spec_alloc... spec->port_fd < 0 (%d)\n",
            spec->port_fd);
  }
  return spec;
}
Example #19
0
int uv__platform_loop_init(uv_loop_t* loop, int default_loop) {
  loop->fs_fd = -1;
  loop->backend_fd = port_create();

  if (loop->backend_fd == -1) return -1;

  uv__cloexec(loop->backend_fd, 1);

  return 0;
}
Example #20
0
port_id user_port_create(int32 queue_length, const char *uname)
{
	dprintf("user_port_create: queue_length %d\n", queue_length);
	if(uname != NULL) {
		char name[SYS_MAX_OS_NAME_LEN];
		int rc;

		if(is_kernel_address(uname))
			return ERR_VM_BAD_USER_MEMORY;

		rc = user_strncpy(name, uname, SYS_MAX_OS_NAME_LEN-1);
		if(rc < 0)
			return rc;
		name[SYS_MAX_OS_NAME_LEN-1] = 0;

		return port_create(queue_length, name);
	} else {
		return port_create(queue_length, NULL);
	}
}
Example #21
0
File: event.c Project: sashka/uwsgi
int event_queue_init() {

        int port = port_create();

        if (port < 0) {
                uwsgi_error("port_create()");
                return -1;
        }

        return port;
}
Example #22
0
/*
 * init_netio
 *
 * This is a needed exported function which will be called to initialise
 * the network loop code.
 */
void
init_netio(void)
{
	if((pe = port_create()) < 0) {
		libcharybdis_log("init_netio: Couldn't open port fd!\n");
		exit(115);	/* Whee! */
	}
	pemax = getdtablesize();
	pelst = MyMalloc(sizeof(port_event_t) * pemax);
	zero_timespec.tv_sec = 0;
	zero_timespec.tv_nsec = 0;
}
Example #23
0
ret_t
fdpoll_port_new (cherokee_fdpoll_t **fdp, int sys_limit, int limit)
{
	cuint_t            i;
	cherokee_fdpoll_t *nfd;
	CHEROKEE_CNEW_STRUCT (1, n, fdpoll_port);

	nfd = FDPOLL(n);

	/* Init base class properties
	 */
	nfd->type          = cherokee_poll_port;
	nfd->nfiles        = limit;
	nfd->system_nfiles = sys_limit;
	nfd->npollfds      = 0;

	/* Init base class virtual methods
	 */
	nfd->free          = (fdpoll_func_free_t) _free;
	nfd->add           = (fdpoll_func_add_t) _add;
	nfd->del           = (fdpoll_func_del_t) _del;
	nfd->reset         = (fdpoll_func_reset_t) _reset;
	nfd->set_mode      = (fdpoll_func_set_mode_t) _set_mode;
	nfd->check         = (fdpoll_func_check_t) _check;
	nfd->watch         = (fdpoll_func_watch_t) _watch;

	/* Allocate data
	 */
	n->port = -1;
	n->port_readyfds = 0;
	n->port_events   = (port_event_t *) calloc(nfd->nfiles, sizeof(port_event_t));
	n->port_activefd = (int *) calloc(nfd->system_nfiles, sizeof(int));

	if ( n->port_events == NULL || n->port_activefd == NULL ) {
		_free( n );
		return ret_nomem;
	}

	for (i=0; i < nfd->system_nfiles; i++) {
		n->port_activefd[i] = -1;
	}

	if ( (n->port = port_create()) == -1 ) {
		_free( n );
		return ret_error;
	}

	/* Return the object
	 */
	*fdp = nfd;
	return ret_ok;
}
Example #24
0
File: port.c Project: Ga-vin/apache
static apr_status_t impl_pollset_create(apr_pollset_t *pollset,
                                             apr_uint32_t size,
                                             apr_pool_t *p,
                                             apr_uint32_t flags)
{
    apr_status_t rv = APR_SUCCESS;
    pollset->p = apr_palloc(p, sizeof(apr_pollset_private_t));
#if APR_HAS_THREADS
    if (flags & APR_POLLSET_THREADSAFE &&
        ((rv = apr_thread_mutex_create(&pollset->p->ring_lock,
                                       APR_THREAD_MUTEX_DEFAULT,
                                       p)) != APR_SUCCESS)) {
        pollset->p = NULL;
        return rv;
    }
#else
    if (flags & APR_POLLSET_THREADSAFE) {
        pollset->p = NULL;
        return APR_ENOTIMPL;
    }
#endif
    pollset->p->waiting = 0;

    pollset->p->port_set = apr_palloc(p, size * sizeof(port_event_t));

    pollset->p->port_fd = port_create();

    if (pollset->p->port_fd < 0) {
        pollset->p = NULL;
        return apr_get_netos_error();
    }

    {
        int flags;

        if ((flags = fcntl(pollset->p->port_fd, F_GETFD)) == -1)
            return errno;

        flags |= FD_CLOEXEC;
        if (fcntl(pollset->p->port_fd, F_SETFD, flags) == -1)
            return errno;
    }

    pollset->p->result_set = apr_palloc(p, size * sizeof(apr_pollfd_t));

    APR_RING_INIT(&pollset->p->query_ring, pfd_elem_t, link);
    APR_RING_INIT(&pollset->p->add_ring, pfd_elem_t, link);
    APR_RING_INIT(&pollset->p->free_ring, pfd_elem_t, link);
    APR_RING_INIT(&pollset->p->dead_ring, pfd_elem_t, link);

    return rv;
}
Example #25
0
int
main(int argc, char * const argv[])
{
	int c;
	boolean_t fork = B_TRUE;

	progname = basename(strdup(argv[0]));

	if ((fmri = (const char *)getenv("SMF_FMRI")) == NULL)
		fmri = DEFAULT_FMRI;

	(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)
#define	TEXT_DOMAIN "SYS_TEST"
#endif
	(void) textdomain(TEXT_DOMAIN);

	while ((c = getopt(argc, argv, "djn")) != EOF) {
		switch (c) {
		case 'd':
			dlevel = 0xffff;
			break;
		case 'j':
			json = B_TRUE;
			break;
		case 'n':
			fork = B_FALSE;
			break;
		default:
			(void) fprintf(stderr, gettext("Unknown option "
			    "\'%c\'.\n"), c);
			usage(progname);
		}
	}

	pid = getpid();

	if ((main_port = port_create()) == -1)
		err(EXIT_FAILURE, "port_create() failed");

	list_create(&links, sizeof (link_t), offsetof(link_t, node));

	VERIFY(get_sysinfo());
	lldp_read_config();
	signal_init();
	get_port_list();
	lldp_init(4);
	cdp_init(4);
	main_loop();

	return (0);
}
Example #26
0
void inline_size
port_fork (EV_P)
{
  close (backend_fd);

  while ((backend_fd = port_create ()) < 0)
    ev_syserr ("(libev) port");

  fcntl (backend_fd, F_SETFD, FD_CLOEXEC);

  /* re-register interest in fds */
  fd_rearm_all (EV_A);
}
Example #27
0
vws_init(struct waiter *w)
{
	struct vws *vws;

	CHECK_OBJ_NOTNULL(w, WAITER_MAGIC);
	vws = w->priv;
	INIT_OBJ(vws, VWS_MAGIC);
	vws->waiter = w;
	vws->dport = port_create();
	assert(vws->dport >= 0);

	AZ(pthread_create(&vws->thread, NULL, vws_thread, vws));
}
Example #28
0
int console_main(void)
{
    int err,i;    
	area_create(0x2000, 0, &screen, AREA_PHYSMAP);
    
    console_port = port_create(0,"console_listen_port");
    send_port = port_create(0,"console_send_port");
	port_option(send_port, PORT_OPT_NOWAIT, 1);
	
    err = namer_register(console_port,"console");

	init_virtscreen(&statbar, 1, 80);
    statbar.back = statbar.data;
	statbar.data = (unsigned short *) (((uint32) screen) + 80*24*2);    
    statbar.lock = sem_create(1,"statbar_lock");
    
    for(i=0;i<10;i++){
        init_virtscreen(&con[i], 24, 80);
        con[i].back = con[i].data;
        con[i].lock = sem_create(1,"vscr_lock");
        vputs(&con[i],CLEAR);
    }
    load(&con[0]);
	
    status(0);
    if(err) vprintf(active,"console: the namer hates us\n");
    else
#ifdef CONSOLE_DEBUG
	    vprintf(active,"console: " FG_GREEN "online." FG_WHITE "\n");
#else
        ;
#endif
    
	thr_create(keyboard_irq_thread, NULL, "console:kbd");
    ready = 1;
    console_thread();
    
    return 0;
}
Example #29
0
int
rb_init_netio_ports(void)
{
	if((pe = port_create()) < 0)
	{
		return errno;
	}
	pemax = getdtablesize();
	pelst = rb_malloc(sizeof(port_event_t) * pemax);
	zero_timespec.tv_sec = 0;
	zero_timespec.tv_nsec = 0;
	rb_set_time();
	return 0;
}
Example #30
0
mowgli_ioevent_handle_t *mowgli_ioevent_create(void)
{
	mowgli_ioevent_handle_t *self = mowgli_alloc(sizeof(mowgli_ioevent_handle_t));

#ifdef HAVE_EPOLL_CTL
	self->impldata = epoll_create(FD_SETSIZE);
#endif

#ifdef HAVE_PORT_CREATE
	self->impldata = port_create();
#endif

	return self;
}