uv-common.h File Reference

#include <assert.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>
#include "uv.h"
#include "uv/tree.h"
#include "queue.h"
#include "strscpy.h"

Go to the source code of this file.

Classes
struct	uv__loop_metrics_s
struct	uv__loop_internal_fields_s

Macros
#define	UV__ERR(x)   (x)
#define	ARRAY_SIZE(a)   (sizeof(a) / sizeof((a)[0]))
#define	container_of(ptr, type, member)    ((type *) ((char *) (ptr) - offsetof(type, member)))
#define	STATIC_ASSERT(expr)    void uv__static_assert(int static_assert_failed[1 - 2 * !(expr)])
#define	uv__load_relaxed(p)   (*p)
#define	uv__store_relaxed(p, v)   do *p = v; while (0)
#define	uv__has_active_reqs(loop)    ((loop)->active_reqs.count > 0)
#define	uv__req_register(loop, req)
#define	uv__req_unregister(loop, req)
#define	uv__has_active_handles(loop)    ((loop)->active_handles > 0)
#define	uv__active_handle_add(h)
#define	uv__active_handle_rm(h)
#define	uv__is_active(h)    (((h)->flags & UV_HANDLE_ACTIVE) != 0)
#define	uv__is_closing(h)    (((h)->flags & (UV_HANDLE_CLOSING | UV_HANDLE_CLOSED)) != 0)
#define	uv__handle_start(h)
#define	uv__handle_stop(h)
#define	uv__handle_ref(h)
#define	uv__handle_unref(h)
#define	uv__has_ref(h)    (((h)->flags & UV_HANDLE_REF) != 0)
#define	uv__handle_platform_init(h)   ((h)->next_closing = NULL)
#define	uv__handle_init(loop_, h, type_)
#define	UV_REQ_INIT(req, typ)
#define	uv__req_init(loop, req, typ)
#define	uv__get_internal_fields(loop)    ((uv__loop_internal_fields_t*) loop->internal_fields)
#define	uv__get_loop_metrics(loop)    (&uv__get_internal_fields(loop)->loop_metrics)

Typedefs
typedef struct uv__loop_metrics_s	uv__loop_metrics_t
typedef struct uv__loop_internal_fields_s	uv__loop_internal_fields_t

Enumerations
enum	{   UV_HANDLE_CLOSING = 0x00000001 , UV_HANDLE_CLOSED = 0x00000002 , UV_HANDLE_ACTIVE = 0x00000004 , UV_HANDLE_REF = 0x00000008 ,   UV_HANDLE_INTERNAL = 0x00000010 , UV_HANDLE_ENDGAME_QUEUED = 0x00000020 , UV_HANDLE_LISTENING = 0x00000040 , UV_HANDLE_CONNECTION = 0x00000080 ,   UV_HANDLE_SHUTTING = 0x00000100 , UV_HANDLE_SHUT = 0x00000200 , UV_HANDLE_READ_PARTIAL = 0x00000400 , UV_HANDLE_READ_EOF = 0x00000800 ,   UV_HANDLE_READING = 0x00001000 , UV_HANDLE_BOUND = 0x00002000 , UV_HANDLE_READABLE = 0x00004000 , UV_HANDLE_WRITABLE = 0x00008000 ,   UV_HANDLE_READ_PENDING = 0x00010000 , UV_HANDLE_SYNC_BYPASS_IOCP = 0x00020000 , UV_HANDLE_ZERO_READ = 0x00040000 , UV_HANDLE_EMULATE_IOCP = 0x00080000 ,   UV_HANDLE_BLOCKING_WRITES = 0x00100000 , UV_HANDLE_CANCELLATION_PENDING = 0x00200000 , UV_HANDLE_IPV6 = 0x00400000 , UV_HANDLE_TCP_NODELAY = 0x01000000 ,   UV_HANDLE_TCP_KEEPALIVE = 0x02000000 , UV_HANDLE_TCP_SINGLE_ACCEPT = 0x04000000 , UV_HANDLE_TCP_ACCEPT_STATE_CHANGING = 0x08000000 , UV_HANDLE_TCP_SOCKET_CLOSED = 0x10000000 ,   UV_HANDLE_SHARED_TCP_SOCKET = 0x20000000 , UV_HANDLE_UDP_PROCESSING = 0x01000000 , UV_HANDLE_UDP_CONNECTED = 0x02000000 , UV_HANDLE_UDP_RECVMMSG = 0x04000000 ,   UV_HANDLE_NON_OVERLAPPED_PIPE = 0x01000000 , UV_HANDLE_PIPESERVER = 0x02000000 , UV_HANDLE_TTY_READABLE = 0x01000000 , UV_HANDLE_TTY_RAW = 0x02000000 ,   UV_HANDLE_TTY_SAVED_POSITION = 0x04000000 , UV_HANDLE_TTY_SAVED_ATTRIBUTES = 0x08000000 , UV_SIGNAL_ONE_SHOT_DISPATCHED = 0x01000000 , UV_SIGNAL_ONE_SHOT = 0x02000000 ,   UV_HANDLE_POLL_SLOW = 0x01000000 }
enum	uv__work_kind { UV__WORK_CPU , UV__WORK_FAST_IO , UV__WORK_SLOW_IO }

Functions
int	uv__loop_configure (uv_loop_t *loop, uv_loop_option option, va_list ap)
void	uv__loop_close (uv_loop_t *loop)
int	uv__tcp_bind (uv_tcp_t *tcp, const struct sockaddr *addr, unsigned int addrlen, unsigned int flags)
int	uv__tcp_connect (uv_connect_t *req, uv_tcp_t *handle, const struct sockaddr *addr, unsigned int addrlen, uv_connect_cb cb)
int	uv__udp_init_ex (uv_loop_t *loop, uv_udp_t *handle, unsigned flags, int domain)
int	uv__udp_bind (uv_udp_t *handle, const struct sockaddr *addr, unsigned int addrlen, unsigned int flags)
int	uv__udp_connect (uv_udp_t *handle, const struct sockaddr *addr, unsigned int addrlen)
int	uv__udp_disconnect (uv_udp_t *handle)
int	uv__udp_is_connected (uv_udp_t *handle)
int	uv__udp_send (uv_udp_send_t *req, uv_udp_t *handle, const uv_buf_t bufs[], unsigned int nbufs, const struct sockaddr *addr, unsigned int addrlen, uv_udp_send_cb send_cb)
int	uv__udp_try_send (uv_udp_t *handle, const uv_buf_t bufs[], unsigned int nbufs, const struct sockaddr *addr, unsigned int addrlen)
int	uv__udp_recv_start (uv_udp_t *handle, uv_alloc_cb alloccb, uv_udp_recv_cb recv_cb)
int	uv__udp_recv_stop (uv_udp_t *handle)
void	uv__fs_poll_close (uv_fs_poll_t *handle)
int	uv__getaddrinfo_translate_error (int sys_err)
void	uv__work_submit (uv_loop_t *loop, struct uv__work *w, enum uv__work_kind kind, void(*work)(struct uv__work *w), void(*done)(struct uv__work *w, int status))
void	uv__work_done (uv_async_t *handle)
size_t	uv__count_bufs (const uv_buf_t bufs[], unsigned int nbufs)
int	uv__socket_sockopt (uv_handle_t *handle, int optname, int *value)
void	uv__fs_scandir_cleanup (uv_fs_t *req)
void	uv__fs_readdir_cleanup (uv_fs_t *req)
uv_dirent_type_t	uv__fs_get_dirent_type (uv__dirent_t *dent)
int	uv__next_timeout (const uv_loop_t *loop)
void	uv__run_timers (uv_loop_t *loop)
void	uv__timer_close (uv_timer_t *handle)
void	uv__process_title_cleanup (void)
void	uv__signal_cleanup (void)
void	uv__threadpool_cleanup (void)
void *	uv__calloc (size_t count, size_t size)
char *	uv__strdup (const char *s)
char *	uv__strndup (const char *s, size_t n)
void *	uv__malloc (size_t size)
void	uv__free (void *ptr)
void *	uv__realloc (void *ptr, size_t size)
void *	uv__reallocf (void *ptr, size_t size)
void	uv__metrics_update_idle_time (uv_loop_t *loop)
void	uv__metrics_set_provider_entry_time (uv_loop_t *loop)

Macro Definition Documentation

ARRAY_SIZE

#define ARRAY_SIZE

(

a

)

(sizeof(a) / sizeof((a)[0]))

Definition at line 55 of file uv-common.h.

container_of

#define container_of	(		ptr,
			type,
			member
	)		((type *) ((char *) (ptr) - offsetof(type, member)))

Definition at line 57 of file uv-common.h.

STATIC_ASSERT

#define STATIC_ASSERT

(

expr

)

void uv__static_assert(int static_assert_failed[1 - 2 * !(expr)])

Definition at line 60 of file uv-common.h.

uv__active_handle_add

#define uv__active_handle_add

(

h

)

Value:

  do {                                                                        \
    (h)->loop->active_handles++;                                              \
  }                                                                           \
  while (0)

Definition at line 240 of file uv-common.h.

uv__active_handle_rm

#define uv__active_handle_rm

(

h

)

Value:

  do {                                                                        \
    (h)->loop->active_handles--;                                              \
  }                                                                           \
  while (0)

Definition at line 246 of file uv-common.h.

UV__ERR

#define UV__ERR

(

x

)

(x)

Definition at line 48 of file uv-common.h.

uv__get_internal_fields

#define uv__get_internal_fields

(

loop

)

((uv__loop_internal_fields_t*) loop->internal_fields)

Definition at line 336 of file uv-common.h.

uv__get_loop_metrics

#define uv__get_loop_metrics

(

loop

)

(&uv__get_internal_fields(loop)->loop_metrics)

Definition at line 339 of file uv-common.h.

uv__handle_init

#define uv__handle_init	(		loop_,
			h,
			type_
	)

Value:

  do {                                                                        \
    (h)->loop = (loop_);                                                      \
    (h)->type = (type_);                                                      \
    (h)->flags = UV_HANDLE_REF;  /* Ref the loop when active. */              \
    QUEUE_INSERT_TAIL(&(loop_)->handle_queue, &(h)->handle_queue);            \
    uv__handle_platform_init(h);                                              \
  }                                                                           \
  while (0)

Definition at line 301 of file uv-common.h.

uv__handle_platform_init

#define uv__handle_platform_init

(

h

)

((h)->next_closing = NULL)

Definition at line 298 of file uv-common.h.

uv__handle_ref

#define uv__handle_ref

(

h

)

Value:

  do {                                                                        \
    if (((h)->flags & UV_HANDLE_REF) != 0) break;                             \
    (h)->flags |= UV_HANDLE_REF;                                              \
    if (((h)->flags & UV_HANDLE_CLOSING) != 0) break;                         \
    if (((h)->flags & UV_HANDLE_ACTIVE) != 0) uv__active_handle_add(h);       \
  }                                                                           \
  while (0)

Definition at line 274 of file uv-common.h.

uv__handle_start

#define uv__handle_start

(

h

)

Value:

  do {                                                                        \
    if (((h)->flags & UV_HANDLE_ACTIVE) != 0) break;                          \
    (h)->flags |= UV_HANDLE_ACTIVE;                                           \
    if (((h)->flags & UV_HANDLE_REF) != 0) uv__active_handle_add(h);          \
  }                                                                           \
  while (0)

Definition at line 258 of file uv-common.h.

uv__handle_stop

#define uv__handle_stop

(

h

)

Value:

  do {                                                                        \
    if (((h)->flags & UV_HANDLE_ACTIVE) == 0) break;                          \
    (h)->flags &= ~UV_HANDLE_ACTIVE;                                          \
    if (((h)->flags & UV_HANDLE_REF) != 0) uv__active_handle_rm(h);           \
  }                                                                           \
  while (0)

Definition at line 266 of file uv-common.h.

uv__handle_unref

#define uv__handle_unref

(

h

)

Value:

  do {                                                                        \
    if (((h)->flags & UV_HANDLE_REF) == 0) break;                             \
    (h)->flags &= ~UV_HANDLE_REF;                                             \
    if (((h)->flags & UV_HANDLE_CLOSING) != 0) break;                         \
    if (((h)->flags & UV_HANDLE_ACTIVE) != 0) uv__active_handle_rm(h);        \
  }                                                                           \
  while (0)

Definition at line 283 of file uv-common.h.

uv__has_active_handles

#define uv__has_active_handles

(

loop

)

((loop)->active_handles > 0)

Definition at line 237 of file uv-common.h.

uv__has_active_reqs

#define uv__has_active_reqs

(

loop

)

((loop)->active_reqs.count > 0)

Definition at line 221 of file uv-common.h.

uv__has_ref

#define uv__has_ref

(

h

)

(((h)->flags & UV_HANDLE_REF) != 0)

Definition at line 292 of file uv-common.h.

uv__is_active

#define uv__is_active

(

h

)

(((h)->flags & UV_HANDLE_ACTIVE) != 0)

Definition at line 252 of file uv-common.h.

uv__is_closing

#define uv__is_closing

(

h

)

(((h)->flags & (UV_HANDLE_CLOSING | UV_HANDLE_CLOSED)) != 0)

Definition at line 255 of file uv-common.h.

uv__load_relaxed

#define uv__load_relaxed

(

p

)

(*p)

Definition at line 67 of file uv-common.h.

uv__req_init

#define uv__req_init	(		loop,
			req,
			typ
	)

Value:

  do {                                                                        \
    UV_REQ_INIT(req, typ);                                                    \
    uv__req_register(loop, req);                                              \
  }                                                                           \
  while (0)

Definition at line 329 of file uv-common.h.

uv__req_register

#define uv__req_register	(		loop,
			req
	)

Value:

  do {                                                                        \
    (loop)->active_reqs.count++;                                              \
  }                                                                           \
  while (0)

Definition at line 224 of file uv-common.h.

uv__req_unregister

#define uv__req_unregister	(		loop,
			req
	)

Value:

  do {                                                                        \
    assert(uv__has_active_reqs(loop));                                        \
    (loop)->active_reqs.count--;                                              \
  }                                                                           \
  while (0)

Definition at line 230 of file uv-common.h.

uv__store_relaxed

#define uv__store_relaxed	(		p,
			v
	)		do *p = v; while (0)

Definition at line 68 of file uv-common.h.

UV_REQ_INIT

#define UV_REQ_INIT	(		req,
			typ
	)

Value:

  do {                                                                        \
    (req)->type = (typ);                                                      \
  }                                                                           \
  while (0)

Definition at line 322 of file uv-common.h.

Typedef Documentation

uv__loop_internal_fields_t

typedef struct uv__loop_internal_fields_s uv__loop_internal_fields_t

Definition at line 349 of file uv-common.h.

uv__loop_metrics_t

typedef struct uv__loop_metrics_s uv__loop_metrics_t

Definition at line 349 of file uv-common.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
UV_HANDLE_CLOSING
UV_HANDLE_CLOSED
UV_HANDLE_ACTIVE
UV_HANDLE_REF
UV_HANDLE_INTERNAL
UV_HANDLE_ENDGAME_QUEUED
UV_HANDLE_LISTENING
UV_HANDLE_CONNECTION
UV_HANDLE_SHUTTING
UV_HANDLE_SHUT
UV_HANDLE_READ_PARTIAL
UV_HANDLE_READ_EOF
UV_HANDLE_READING
UV_HANDLE_BOUND
UV_HANDLE_READABLE
UV_HANDLE_WRITABLE
UV_HANDLE_READ_PENDING
UV_HANDLE_SYNC_BYPASS_IOCP
UV_HANDLE_ZERO_READ
UV_HANDLE_EMULATE_IOCP
UV_HANDLE_BLOCKING_WRITES
UV_HANDLE_CANCELLATION_PENDING
UV_HANDLE_IPV6
UV_HANDLE_TCP_NODELAY
UV_HANDLE_TCP_KEEPALIVE
UV_HANDLE_TCP_SINGLE_ACCEPT
UV_HANDLE_TCP_ACCEPT_STATE_CHANGING
UV_HANDLE_TCP_SOCKET_CLOSED
UV_HANDLE_SHARED_TCP_SOCKET
UV_HANDLE_UDP_PROCESSING
UV_HANDLE_UDP_CONNECTED
UV_HANDLE_UDP_RECVMMSG
UV_HANDLE_NON_OVERLAPPED_PIPE
UV_HANDLE_PIPESERVER
UV_HANDLE_TTY_READABLE
UV_HANDLE_TTY_RAW
UV_HANDLE_TTY_SAVED_POSITION
UV_HANDLE_TTY_SAVED_ATTRIBUTES
UV_SIGNAL_ONE_SHOT_DISPATCHED
UV_SIGNAL_ONE_SHOT
UV_HANDLE_POLL_SLOW

Definition at line 72 of file uv-common.h.

     {
  /* Used by all handles. */
  UV_HANDLE_CLOSING                     = 0x00000001,
  UV_HANDLE_CLOSED                      = 0x00000002,
  UV_HANDLE_ACTIVE                      = 0x00000004,
  UV_HANDLE_REF                         = 0x00000008,
  UV_HANDLE_INTERNAL                    = 0x00000010,
  UV_HANDLE_ENDGAME_QUEUED              = 0x00000020,
 
  /* Used by streams. */
  UV_HANDLE_LISTENING                   = 0x00000040,
  UV_HANDLE_CONNECTION                  = 0x00000080,
  UV_HANDLE_SHUTTING                    = 0x00000100,
  UV_HANDLE_SHUT                        = 0x00000200,
  UV_HANDLE_READ_PARTIAL                = 0x00000400,
  UV_HANDLE_READ_EOF                    = 0x00000800,
 
  /* Used by streams and UDP handles. */
  UV_HANDLE_READING                     = 0x00001000,
  UV_HANDLE_BOUND                       = 0x00002000,
  UV_HANDLE_READABLE                    = 0x00004000,
  UV_HANDLE_WRITABLE                    = 0x00008000,
  UV_HANDLE_READ_PENDING                = 0x00010000,
  UV_HANDLE_SYNC_BYPASS_IOCP            = 0x00020000,
  UV_HANDLE_ZERO_READ                   = 0x00040000,
  UV_HANDLE_EMULATE_IOCP                = 0x00080000,
  UV_HANDLE_BLOCKING_WRITES             = 0x00100000,
  UV_HANDLE_CANCELLATION_PENDING        = 0x00200000,
 
  /* Used by uv_tcp_t and uv_udp_t handles */
  UV_HANDLE_IPV6                        = 0x00400000,
 
  /* Only used by uv_tcp_t handles. */
  UV_HANDLE_TCP_NODELAY                 = 0x01000000,
  UV_HANDLE_TCP_KEEPALIVE               = 0x02000000,
  UV_HANDLE_TCP_SINGLE_ACCEPT           = 0x04000000,
  UV_HANDLE_TCP_ACCEPT_STATE_CHANGING   = 0x08000000,
  UV_HANDLE_TCP_SOCKET_CLOSED           = 0x10000000,
  UV_HANDLE_SHARED_TCP_SOCKET           = 0x20000000,
 
  /* Only used by uv_udp_t handles. */
  UV_HANDLE_UDP_PROCESSING              = 0x01000000,
  UV_HANDLE_UDP_CONNECTED               = 0x02000000,
  UV_HANDLE_UDP_RECVMMSG                = 0x04000000,
 
  /* Only used by uv_pipe_t handles. */
  UV_HANDLE_NON_OVERLAPPED_PIPE         = 0x01000000,
  UV_HANDLE_PIPESERVER                  = 0x02000000,
 
  /* Only used by uv_tty_t handles. */
  UV_HANDLE_TTY_READABLE                = 0x01000000,
  UV_HANDLE_TTY_RAW                     = 0x02000000,
  UV_HANDLE_TTY_SAVED_POSITION          = 0x04000000,
  UV_HANDLE_TTY_SAVED_ATTRIBUTES        = 0x08000000,
 
  /* Only used by uv_signal_t handles. */
  UV_SIGNAL_ONE_SHOT_DISPATCHED         = 0x01000000,
  UV_SIGNAL_ONE_SHOT                    = 0x02000000,
 
  /* Only used by uv_poll_t handles. */
  UV_HANDLE_POLL_SLOW                   = 0x01000000
};

uv__work_kind

enum uv__work_kind

Enumerator
UV__WORK_CPU
UV__WORK_FAST_IO
UV__WORK_SLOW_IO

Definition at line 191 of file uv-common.h.

                   {
  UV__WORK_CPU,
  UV__WORK_FAST_IO,
  UV__WORK_SLOW_IO
};

Function Documentation

uv__calloc()

void* uv__calloc	(	size_t	count,
		size_t	size
	)

Definition at line 92 of file uv-common.c.

                                            {
  return uv__allocator.local_calloc(count, size);
}

References count, uv__allocator_t::local_calloc, and uv__allocator.

Referenced by uv__interface_addresses_v6(), uv__pipe_write_ipc(), uv_cpu_info(), uv_fs_poll_start(), uv_interface_addresses(), uv_loop_init(), and uv_os_environ().

uv__count_bufs()

size_t uv__count_bufs	(	const uv_buf_t	bufs[],
		unsigned int	nbufs
	)

Definition at line 573 of file uv-common.c.

                                                                 {
  unsigned int i;
  size_t bytes;
 
  bytes = 0;
  for (i = 0; i < nbufs; i++)
    bytes += (size_t) bufs[i].len;
 
  return bytes;
}

References bufs, bytes, and i.

Referenced by uv__send(), uv__tty_try_write(), uv__udp_run_completed(), uv__udp_send(), uv__write_req_size(), uv_tcp_write(), uv_try_write(), and uv_write2().

uv__free()

void uv__free

(

void *

ptr

)

Definition at line 81 of file uv-common.c.

                         {
  int saved_errno;
 
  /* Libuv expects that free() does not clobber errno.  The system allocator
   * honors that assumption but custom allocators may not be so careful.
   */
  saved_errno = errno;
  uv__allocator.local_free(ptr);
  errno = saved_errno;
}

References uv__allocator_t::local_free, and uv__allocator.

Referenced by child_fork(), eof_timer_close_cb(), epoll_queue_close(), freeifaddrs(), freeResultList(), fs__closedir(), fs__create_junction(), fs__opendir(), fs__readdir(), fs__realpath_handle(), fs__scandir(), fs__sendfile(), fs__statfs(), getNetlinkResponse(), make_program_args(), make_program_env(), maybe_free_watcher_list(), os390_readlink(), scandir(), search_path_join_test(), timer_close_cb(), uv__convert_utf16_to_utf8(), uv__convert_utf8_to_utf16(), uv__custom_sem_destroy(), uv__custom_sem_init(), uv__dlerror(), uv__fd_hash_remove(), uv__fs_closedir(), uv__fs_opendir(), uv__fs_read(), uv__fs_readdir(), uv__fs_readdir_cleanup(), uv__fs_readlink(), uv__fs_realpath(), uv__fs_write_all(), uv__getaddrinfo_done(), uv__getpwuid_r(), uv__inotify_fork(), uv__io_fork(), uv__loop_close(), uv__loops_remove(), uv__pipe_close(), uv__pipe_getname(), uv__pipe_write_ipc(), uv__platform_loop_delete(), uv__process_title_cleanup(), uv__realloc(), uv__reallocf(), uv__search_path(), uv__stdio_destroy(), uv__stream_close(), uv__thread_start(), uv__threadpool_cleanup(), uv__udp_run_completed(), uv__write_callbacks(), uv__write_req_finish(), uv_accept(), uv_barrier_destroy(), uv_barrier_init(), uv_chdir(), uv_cpu_info(), uv_cwd(), uv_dlclose(), uv_exepath(), uv_free_cpu_info(), uv_free_interface_addresses(), uv_freeaddrinfo(), uv_fs_event_endgame(), uv_fs_event_start(), uv_fs_event_stop(), uv_fs_poll_start(), uv_fs_req_cleanup(), uv_getaddrinfo(), uv_interface_addresses(), uv_loop_delete(), uv_loop_init(), uv_loop_new(), uv_os_environ(), uv_os_free_environ(), uv_os_free_passwd(), uv_os_getenv(), uv_os_setenv(), uv_os_tmpdir(), uv_os_unsetenv(), uv_pipe_accept(), uv_pipe_bind(), uv_pipe_chmod(), uv_pipe_cleanup(), uv_pipe_connect(), uv_pipe_endgame(), uv_process_fs_event_req(), uv_process_pipe_write_req(), uv_set_process_title(), uv_spawn(), uv_split_path(), uv_tcp_endgame(), uv_thread_create_ex(), uv_try_write(), and uv_uptime().

uv__fs_get_dirent_type()

uv_dirent_type_t uv__fs_get_dirent_type

(

uv__dirent_t *

dent

)

Definition at line 688 of file uv-common.c.

                                                            {
  uv_dirent_type_t type;
 
#ifdef HAVE_DIRENT_TYPES
  switch (dent->d_type) {
    case UV__DT_DIR:
      type = UV_DIRENT_DIR;
      break;
    case UV__DT_FILE:
      type = UV_DIRENT_FILE;
      break;
    case UV__DT_LINK:
      type = UV_DIRENT_LINK;
      break;
    case UV__DT_FIFO:
      type = UV_DIRENT_FIFO;
      break;
    case UV__DT_SOCKET:
      type = UV_DIRENT_SOCKET;
      break;
    case UV__DT_CHAR:
      type = UV_DIRENT_CHAR;
      break;
    case UV__DT_BLOCK:
      type = UV_DIRENT_BLOCK;
      break;
    default:
      type = UV_DIRENT_UNKNOWN;
  }
#else
  type = UV_DIRENT_UNKNOWN;
#endif
 
  return type;
}

References type, UV__DT_BLOCK, UV__DT_CHAR, UV__DT_DIR, UV__DT_FIFO, UV__DT_FILE, UV__DT_LINK, UV__DT_SOCKET, UV_DIRENT_BLOCK, UV_DIRENT_CHAR, UV_DIRENT_DIR, UV_DIRENT_FIFO, UV_DIRENT_FILE, UV_DIRENT_LINK, UV_DIRENT_SOCKET, and UV_DIRENT_UNKNOWN.

Referenced by fs__readdir(), uv__fs_readdir(), and uv_fs_scandir_next().

uv__fs_poll_close()

void uv__fs_poll_close

(

uv_fs_poll_t *

handle

)

Definition at line 164 of file fs-poll.c.

                                             {
  uv_fs_poll_stop(handle);
 
  if (handle->poll_ctx == NULL)
    uv__make_close_pending((uv_handle_t*)handle);
}

References handle, NULL, uv__make_close_pending(), and uv_fs_poll_stop().

Referenced by uv_close().

uv__fs_readdir_cleanup()

void uv__fs_readdir_cleanup

(

uv_fs_t *

req

)

Definition at line 724 of file uv-common.c.

                                          {
  uv_dir_t* dir;
  uv_dirent_t* dirents;
  int i;
 
  if (req->ptr == NULL)
    return;
 
  dir = req->ptr;
  dirents = dir->dirents;
  req->ptr = NULL;
 
  if (dirents == NULL)
    return;
 
  for (i = 0; i < req->result; ++i) {
    uv__free((char*) dirents[i].name);
    dirents[i].name = NULL;
  }
}

References uv_dir_s::dirents, i, uv_dirent_s::name, NULL, req, and uv__free().

Referenced by uv_fs_req_cleanup().

uv__fs_scandir_cleanup()

void uv__fs_scandir_cleanup

(

uv_fs_t *

req

)

Definition at line 635 of file uv-common.c.

                                          {
  uv__dirent_t** dents;
 
  unsigned int* nbufs = uv__get_nbufs(req);
 
  dents = req->ptr;
  if (*nbufs > 0 && *nbufs != (unsigned int) req->result)
    (*nbufs)--;
  for (; *nbufs < (unsigned int) req->result; (*nbufs)++)
    uv__fs_scandir_free(dents[*nbufs]);
 
  uv__fs_scandir_free(req->ptr);
  req->ptr = NULL;
}

References int, NULL, req, uv__fs_scandir_free, and uv__get_nbufs().

Referenced by uv_fs_req_cleanup().

uv__getaddrinfo_translate_error()

int uv__getaddrinfo_translate_error

(

int

sys_err

)

Definition at line 42 of file getaddrinfo.c.

                                                 {
  switch (sys_err) {
  case 0: return 0;
#if defined(EAI_ADDRFAMILY)
  case EAI_ADDRFAMILY: return UV_EAI_ADDRFAMILY;
#endif
#if defined(EAI_AGAIN)
  case EAI_AGAIN: return UV_EAI_AGAIN;
#endif
#if defined(EAI_BADFLAGS)
  case EAI_BADFLAGS: return UV_EAI_BADFLAGS;
#endif
#if defined(EAI_BADHINTS)
  case EAI_BADHINTS: return UV_EAI_BADHINTS;
#endif
#if defined(EAI_CANCELED)
  case EAI_CANCELED: return UV_EAI_CANCELED;
#endif
#if defined(EAI_FAIL)
  case EAI_FAIL: return UV_EAI_FAIL;
#endif
#if defined(EAI_FAMILY)
  case EAI_FAMILY: return UV_EAI_FAMILY;
#endif
#if defined(EAI_MEMORY)
  case EAI_MEMORY: return UV_EAI_MEMORY;
#endif
#if defined(EAI_NODATA)
  case EAI_NODATA: return UV_EAI_NODATA;
#endif
#if defined(EAI_NONAME)
# if !defined(EAI_NODATA) || EAI_NODATA != EAI_NONAME
  case EAI_NONAME: return UV_EAI_NONAME;
# endif
#endif
#if defined(EAI_OVERFLOW)
  case EAI_OVERFLOW: return UV_EAI_OVERFLOW;
#endif
#if defined(EAI_PROTOCOL)
  case EAI_PROTOCOL: return UV_EAI_PROTOCOL;
#endif
#if defined(EAI_SERVICE)
  case EAI_SERVICE: return UV_EAI_SERVICE;
#endif
#if defined(EAI_SOCKTYPE)
  case EAI_SOCKTYPE: return UV_EAI_SOCKTYPE;
#endif
#if defined(EAI_SYSTEM)
  case EAI_SYSTEM: return UV__ERR(errno);
#endif
  }
  assert(!"unknown EAI_* error code");
  abort();
#ifndef __SUNPRO_C
  return 0;  /* Pacify compiler. */
#endif
}

References assert(), UV__ERR, and uv_translate_sys_error().

Referenced by uv__getaddrinfo_work(), and uv__getnameinfo_work().

uv__loop_close()

void uv__loop_close

(

uv_loop_t *

loop

)

Definition at line 165 of file loop.c.

                                     {
  uv__loop_internal_fields_t* lfields;
 
  uv__signal_loop_cleanup(loop);
  uv__platform_loop_delete(loop);
  uv__async_stop(loop);
 
  if (loop->emfile_fd != -1) {
    uv__close(loop->emfile_fd);
    loop->emfile_fd = -1;
  }
 
  if (loop->backend_fd != -1) {
    uv__close(loop->backend_fd);
    loop->backend_fd = -1;
  }
 
  uv_mutex_lock(&loop->wq_mutex);
  assert(QUEUE_EMPTY(&loop->wq) && "thread pool work queue not empty!");
  assert(!uv__has_active_reqs(loop));
  uv_mutex_unlock(&loop->wq_mutex);
  uv_mutex_destroy(&loop->wq_mutex);
 
  /*
   * Note that all thread pool stuff is finished at this point and
   * it is safe to just destroy rw lock
   */
  uv_rwlock_destroy(&loop->cloexec_lock);
 
#if 0
  assert(QUEUE_EMPTY(&loop->pending_queue));
  assert(QUEUE_EMPTY(&loop->watcher_queue));
  assert(loop->nfds == 0);
#endif
 
  uv__free(loop->watchers);
  loop->watchers = NULL;
  loop->nwatchers = 0;
 
  lfields = uv__get_internal_fields(loop);
  uv_mutex_destroy(&lfields->loop_metrics.lock);
  uv__free(lfields);
  loop->internal_fields = NULL;
}

References ARRAY_SIZE, assert(), i, uv_loop_s::internal_fields, uv__loop_metrics_s::lock, loop, uv__loop_internal_fields_s::loop_metrics, NULL, QUEUE_EMPTY, uv__async_stop(), uv__close(), uv__free(), uv__get_internal_fields, uv__handle_close, uv__handle_closing, uv__has_active_reqs, uv__loops_remove(), uv__platform_loop_delete(), uv__signal_loop_cleanup(), uv_mutex_destroy(), uv_mutex_lock(), uv_mutex_unlock(), and uv_rwlock_destroy().

Referenced by uv_loop_close().

uv__loop_configure()

int uv__loop_configure	(	uv_loop_t *	loop,
		uv_loop_option	option,
		va_list	ap
	)

Definition at line 211 of file loop.c.

                                                                           {
  uv__loop_internal_fields_t* lfields;
 
  lfields = uv__get_internal_fields(loop);
  if (option == UV_METRICS_IDLE_TIME) {
    lfields->flags |= UV_METRICS_IDLE_TIME;
    return 0;
  }
 
  if (option != UV_LOOP_BLOCK_SIGNAL)
    return UV_ENOSYS;
 
  if (va_arg(ap, int) != SIGPROF)
    return UV_EINVAL;
 
  loop->flags |= UV_LOOP_BLOCK_SIGPROF;
  return 0;
}

References uv__loop_internal_fields_s::flags, loop, uv__get_internal_fields, UV_LOOP_BLOCK_SIGNAL, UV_LOOP_BLOCK_SIGPROF, and UV_METRICS_IDLE_TIME.

Referenced by uv_loop_configure().

uv__malloc()

void* uv__malloc

(

size_t

size

)

Definition at line 75 of file uv-common.c.

                              {
  if (size > 0)
    return uv__allocator.local_malloc(size);
  return NULL;
}

References uv__allocator_t::local_malloc, NULL, and uv__allocator.

Referenced by eof_timer_init(), epoll_create1(), fs__capture_path(), fs__create_junction(), fs__opendir(), fs__realpath_handle(), fs__scandir(), fs__sendfile(), fs__statfs(), fs__wide_to_utf8(), getNetlinkResponse(), init_threads(), interpretAddr(), interpretLink(), make_program_args(), make_program_env(), newListItem(), os390_readlink(), scandir(), search_path_join_test(), uv__build_coalesced_write_req(), uv__convert_utf16_to_utf8(), uv__convert_utf8_to_utf16(), uv__custom_sem_init(), uv__fd_hash_add(), uv__fs_opendir(), uv__fs_readlink(), uv__fs_realpath(), uv__fs_statfs(), uv__getaddrinfo_done(), uv__getpwuid_r(), uv__interface_addresses_v6(), uv__pipe_getname(), uv__pipe_queue_ipc_xfer_info(), uv__stdio_create(), uv__strdup(), uv__stream_queue_fd(), uv__strndup(), uv__udp_send(), uv_barrier_init(), uv_chdir(), uv_cpu_info(), uv_cwd(), uv_exepath(), uv_fs_event_start(), uv_fs_read(), uv_fs_write(), uv_getaddrinfo(), uv_interface_addresses(), uv_loop_init(), uv_loop_new(), uv_os_getenv(), uv_os_tmpdir(), uv_pipe_bind(), uv_pipe_chmod(), uv_pipe_connect(), uv_process_fs_event_req(), uv_relative_path(), uv_set_process_title(), uv_setup_args(), uv_spawn(), uv_split_path(), uv_tcp_listen(), uv_thread_create_ex(), uv_uptime(), uv_utf8_to_utf16_alloc(), and uv_write2().

uv__metrics_set_provider_entry_time()

void uv__metrics_set_provider_entry_time

(

uv_loop_t *

loop

)

Definition at line 899 of file uv-common.c.

                                                          {
  uv__loop_metrics_t* loop_metrics;
  uint64_t now;
 
  if (!(uv__get_internal_fields(loop)->flags & UV_METRICS_IDLE_TIME))
    return;
 
  now = uv_hrtime();
  loop_metrics = uv__get_loop_metrics(loop);
  uv_mutex_lock(&loop_metrics->lock);
  loop_metrics->provider_entry_time = now;
  uv_mutex_unlock(&loop_metrics->lock);
}

References flags, uv__loop_metrics_s::lock, loop, uv__loop_metrics_s::provider_entry_time, uv__get_internal_fields, uv__get_loop_metrics, uv_hrtime(), UV_METRICS_IDLE_TIME, uv_mutex_lock(), and uv_mutex_unlock().

Referenced by uv__io_poll(), uv__poll(), and uv__poll_wine().

uv__metrics_update_idle_time()

void uv__metrics_update_idle_time

(

uv_loop_t *

loop

)

Definition at line 872 of file uv-common.c.

                                                   {
  uv__loop_metrics_t* loop_metrics;
  uint64_t entry_time;
  uint64_t exit_time;
 
  if (!(uv__get_internal_fields(loop)->flags & UV_METRICS_IDLE_TIME))
    return;
 
  loop_metrics = uv__get_loop_metrics(loop);
 
  /* The thread running uv__metrics_update_idle_time() is always the same
   * thread that sets provider_entry_time. So it's unnecessary to lock before
   * retrieving this value.
   */
  if (loop_metrics->provider_entry_time == 0)
    return;
 
  exit_time = uv_hrtime();
 
  uv_mutex_lock(&loop_metrics->lock);
  entry_time = loop_metrics->provider_entry_time;
  loop_metrics->provider_entry_time = 0;
  loop_metrics->provider_idle_time += exit_time - entry_time;
  uv_mutex_unlock(&loop_metrics->lock);
}

References flags, uv__loop_metrics_s::lock, loop, uv__loop_metrics_s::provider_entry_time, uv__loop_metrics_s::provider_idle_time, uv__get_internal_fields, uv__get_loop_metrics, uv_hrtime(), UV_METRICS_IDLE_TIME, uv_mutex_lock(), and uv_mutex_unlock().

Referenced by uv__io_poll(), uv__poll(), uv__poll_wine(), and uv_run().

uv__next_timeout()

int uv__next_timeout

(

const uv_loop_t *

loop

)

Definition at line 141 of file timer.c.

                                            {
  const struct heap_node* heap_node;
  const uv_timer_t* handle;
  uint64_t diff;
 
  heap_node = heap_min(timer_heap(loop));
  if (heap_node == NULL)
    return -1; /* block indefinitely */
 
  handle = container_of(heap_node, uv_timer_t, heap_node);
  if (handle->timeout <= loop->time)
    return 0;
 
  diff = handle->timeout - loop->time;
  if (diff > INT_MAX)
    diff = INT_MAX;
 
  return (int) diff;
}

References container_of, handle, INT_MAX, loop, NULL, and timer_heap().

Referenced by uv_backend_timeout().

uv__process_title_cleanup()

void uv__process_title_cleanup

(

void

)

Definition at line 987 of file aix.c.

                                     {
  uv__free(args_mem);  /* Keep valgrind happy. */
  args_mem = NULL;
}

References args_mem, NULL, and uv__free().

Referenced by uv_library_shutdown().

uv__realloc()

void* uv__realloc	(	void *	ptr,
		size_t	size
	)

Definition at line 96 of file uv-common.c.

                                          {
  if (size > 0)
    return uv__allocator.local_realloc(ptr, size);
  uv__free(ptr);
  return NULL;
}

References uv__allocator_t::local_realloc, NULL, uv__allocator, and uv__free().

Referenced by fs__scandir(), scandir(), uv__loops_add(), uv__loops_remove(), uv__reallocf(), and uv__stream_queue_fd().

uv__reallocf()

void* uv__reallocf	(	void *	ptr,
		size_t	size
	)

Definition at line 103 of file uv-common.c.

                                           {
  void* newptr;
 
  newptr = uv__realloc(ptr, size);
  if (newptr == NULL)
    if (size > 0)
      uv__free(ptr);
 
  return newptr;
}

References NULL, uv__free(), and uv__realloc().

Referenced by fs__statfs(), maybe_resize(), uv__fs_readlink(), uv__pollfds_maybe_resize(), and uv_exepath().

uv__run_timers()

void uv__run_timers

(

uv_loop_t *

loop

)

Definition at line 162 of file timer.c.

                                     {
  struct heap_node* heap_node;
  uv_timer_t* handle;
 
  for (;;) {
    heap_node = heap_min(timer_heap(loop));
    if (heap_node == NULL)
      break;
 
    handle = container_of(heap_node, uv_timer_t, heap_node);
    if (handle->timeout > loop->time)
      break;
 
    uv_timer_stop(handle);
    uv_timer_again(handle);
    handle->timer_cb(handle);
  }
}

References container_of, handle, loop, NULL, timer_heap(), uv_timer_again(), and uv_timer_stop().

Referenced by uv_run().

uv__signal_cleanup()

void uv__signal_cleanup

(

void

)

Definition at line 80 of file signal.c.

                              {
  /* We can only use signal-safe functions here.
   * That includes read/write and close, fortunately.
   * We do all of this directly here instead of resetting
   * uv__signal_global_init_guard because
   * uv__signal_global_once_init is only called from uv_loop_init
   * and this needs to function in existing loops.
   */
  if (uv__signal_lock_pipefd[0] != -1) {
    uv__close(uv__signal_lock_pipefd[0]);
    uv__signal_lock_pipefd[0] = -1;
  }
 
  if (uv__signal_lock_pipefd[1] != -1) {
    uv__close(uv__signal_lock_pipefd[1]);
    uv__signal_lock_pipefd[1] = -1;
  }
}

References uv__close(), and uv__signal_lock_pipefd.

Referenced by uv__signal_global_reinit(), and uv_library_shutdown().

uv__socket_sockopt()

int uv__socket_sockopt	(	uv_handle_t *	handle,
		int	optname,
		int *	value
	)

Definition at line 180 of file core.c.

                                                                     {
  int r;
  int fd;
  socklen_t len;
 
  if (handle == NULL || value == NULL)
    return UV_EINVAL;
 
  if (handle->type == UV_TCP || handle->type == UV_NAMED_PIPE)
    fd = uv__stream_fd((uv_stream_t*) handle);
  else if (handle->type == UV_UDP)
    fd = ((uv_udp_t *) handle)->io_watcher.fd;
  else
    return UV_ENOTSUP;
 
  len = sizeof(*value);
 
  if (*value == 0)
    r = getsockopt(fd, SOL_SOCKET, optname, value, &len);
  else
    r = setsockopt(fd, SOL_SOCKET, optname, (const void*) value, len);
 
  if (r < 0)
    return UV__ERR(errno);
 
  return 0;
}

References fd, handle, len, NULL, r, socket, SOL_SOCKET, UV__ERR, uv__stream_fd, uv_translate_sys_error(), and value.

Referenced by uv_recv_buffer_size(), and uv_send_buffer_size().

uv__strdup()

char* uv__strdup

(

const char *

s

)

Definition at line 55 of file uv-common.c.

                                {
  size_t len = strlen(s) + 1;
  char* m = uv__malloc(len);
  if (m == NULL)
    return NULL;
  return memcpy(m, s, len);
}

References len, regress::m, memcpy(), NULL, s, and uv__malloc().

Referenced by uv__dlerror(), uv__fs_readdir(), uv__inotify_fork(), uv__interface_addresses_v6(), uv__search_path(), uv__unknown_err_code(), uv_cpu_info(), uv_fs_event_start(), uv_fs_mkdtemp(), uv_fs_mkstemp(), uv_interface_addresses(), uv_os_environ(), uv_pipe_bind(), uv_set_process_title(), and uv_setup_args().

uv__strndup()

char* uv__strndup	(	const char *	s,
		size_t	n
	)

Definition at line 63 of file uv-common.c.

                                           {
  char* m;
  size_t len = strlen(s);
  if (n < len)
    len = n;
  m = uv__malloc(len + 1);
  if (m == NULL)
    return NULL;
  m[len] = '\0';
  return memcpy(m, s, len);
}

References len, regress::m, memcpy(), n, NULL, s, and uv__malloc().

Referenced by read_models().

uv__tcp_bind()

int uv__tcp_bind	(	uv_tcp_t *	tcp,
		const struct sockaddr *	addr,
		unsigned int	addrlen,
		unsigned int	flags
	)

Definition at line 148 of file tcp.c.

                                     {
  int err;
  int on;
 
  /* Cannot set IPv6-only mode on non-IPv6 socket. */
  if ((flags & UV_TCP_IPV6ONLY) && addr->sa_family != AF_INET6)
    return UV_EINVAL;
 
  err = maybe_new_socket(tcp, addr->sa_family, 0);
  if (err)
    return err;
 
  on = 1;
  if (setsockopt(tcp->io_watcher.fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)))
    return UV__ERR(errno);
 
#ifndef __OpenBSD__
#ifdef IPV6_V6ONLY
  if (addr->sa_family == AF_INET6) {
    on = (flags & UV_TCP_IPV6ONLY) != 0;
    if (setsockopt(tcp->io_watcher.fd,
                   IPPROTO_IPV6,
                   IPV6_V6ONLY,
                   &on,
                   sizeof on) == -1) {
#if defined(__MVS__)
      if (errno == EOPNOTSUPP)
        return UV_EINVAL;
#endif
      return UV__ERR(errno);
    }
  }
#endif
#endif
 
  errno = 0;
  if (bind(tcp->io_watcher.fd, addr, addrlen) && errno != EADDRINUSE) {
    if (errno == EAFNOSUPPORT)
      /* OSX, other BSDs and SunoS fail with EAFNOSUPPORT when binding a
       * socket created with AF_INET to an AF_INET6 address or vice versa. */
      return UV_EINVAL;
    return UV__ERR(errno);
  }
  tcp->delayed_error = UV__ERR(errno);
 
  tcp->flags |= UV_HANDLE_BOUND;
  if (addr->sa_family == AF_INET6)
    tcp->flags |= UV_HANDLE_IPV6;
 
  return 0;
}

References addr, addrlen, AF_INET6, bind, EADDRINUSE, EAFNOSUPPORT, EOPNOTSUPP, err, flags, handle, IPV6_V6ONLY, maybe_new_socket(), SO_REUSEADDR, SOL_SOCKET, UV__ERR, UV_HANDLE_BOUND, UV_HANDLE_IPV6, UV_TCP_IPV6ONLY, uv_tcp_try_bind(), and uv_translate_sys_error().

Referenced by uv_tcp_bind().

uv__tcp_connect()

int uv__tcp_connect	(	uv_connect_t *	req,
		uv_tcp_t *	handle,
		const struct sockaddr *	addr,
		unsigned int	addrlen,
		uv_connect_cb	cb
	)

Definition at line 204 of file tcp.c.

                                      {
  int err;
  int r;
 
  assert(handle->type == UV_TCP);
 
  if (handle->connect_req != NULL)
    return UV_EALREADY;  /* FIXME(bnoordhuis) UV_EINVAL or maybe UV_EBUSY. */
 
  err = maybe_new_socket(handle,
                         addr->sa_family,
                         UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
  if (err)
    return err;
 
  handle->delayed_error = 0;
 
  do {
    errno = 0;
    r = connect(uv__stream_fd(handle), addr, addrlen);
  } while (r == -1 && errno == EINTR);
 
  /* We not only check the return value, but also check the errno != 0.
   * Because in rare cases connect() will return -1 but the errno
   * is 0 (for example, on Android 4.3, OnePlus phone A0001_12_150227)
   * and actually the tcp three-way handshake is completed.
   */
  if (r == -1 && errno != 0) {
    if (errno == EINPROGRESS)
      ; /* not an error */
    else if (errno == ECONNREFUSED
#if defined(__OpenBSD__)
      || errno == EINVAL
#endif
      )
    /* If we get ECONNREFUSED (Solaris) or EINVAL (OpenBSD) wait until the
     * next tick to report the error. Solaris and OpenBSD wants to report
     * immediately -- other unixes want to wait.
     */
      handle->delayed_error = UV__ERR(ECONNREFUSED);
    else
      return UV__ERR(errno);
  }
 
  uv__req_init(handle->loop, req, UV_CONNECT);
  req->cb = cb;
  req->handle = (uv_stream_t*) handle;
  QUEUE_INIT(&req->queue);
  handle->connect_req = req;
 
  uv__io_start(handle->loop, &handle->io_watcher, POLLOUT);
 
  if (handle->delayed_error)
    uv__io_feed(handle->loop, &handle->io_watcher);
 
  return 0;
}

References addr, addrlen, assert(), cb, ECONNREFUSED, EINPROGRESS, EINTR, EINVAL, err, handle, maybe_new_socket(), NULL, QUEUE_INIT, r, req, UV__ERR, uv__io_feed(), uv__io_start(), uv__req_init, uv__stream_fd, UV_HANDLE_READABLE, UV_HANDLE_WRITABLE, uv_tcp_try_connect(), and uv_translate_sys_error().

Referenced by uv_tcp_connect().

uv__threadpool_cleanup()

void uv__threadpool_cleanup

(

void

)

Definition at line 163 of file threadpool.c.

                                  {
#ifndef _WIN32
  unsigned int i;
 
  if (nthreads == 0)
    return;
 
  post(&exit_message, UV__WORK_CPU);
 
  for (i = 0; i < nthreads; i++)
    if (uv_thread_join(threads + i))
      abort();
 
  if (threads != default_threads)
    uv__free(threads);
 
  uv_mutex_destroy(&mutex);
  uv_cond_destroy(&cond);
 
  threads = NULL;
  nthreads = 0;
#endif
}

References cond, default_threads, exit_message, i, mutex, nthreads, NULL, post(), threads, uv__free(), UV__WORK_CPU, uv_cond_destroy(), uv_mutex_destroy(), and uv_thread_join().

Referenced by uv_library_shutdown().

uv__timer_close()

void uv__timer_close

(

uv_timer_t *

handle

)

Definition at line 182 of file timer.c.

                                         {
  uv_timer_stop(handle);
}

References handle, and uv_timer_stop().

Referenced by uv_close(), and uv_process_endgames().

uv__udp_bind()

int uv__udp_bind	(	uv_udp_t *	handle,
		const struct sockaddr *	addr,
		unsigned int	addrlen,
		unsigned int	flags
	)

Definition at line 508 of file udp.c.

                                     {
  int err;
  int yes;
  int fd;
 
  /* Check for bad flags. */
  if (flags & ~(UV_UDP_IPV6ONLY | UV_UDP_REUSEADDR))
    return UV_EINVAL;
 
  /* Cannot set IPv6-only mode on non-IPv6 socket. */
  if ((flags & UV_UDP_IPV6ONLY) && addr->sa_family != AF_INET6)
    return UV_EINVAL;
 
  fd = handle->io_watcher.fd;
  if (fd == -1) {
    err = uv__socket(addr->sa_family, SOCK_DGRAM, 0);
    if (err < 0)
      return err;
    fd = err;
    handle->io_watcher.fd = fd;
  }
 
  if (flags & UV_UDP_REUSEADDR) {
    err = uv__set_reuse(fd);
    if (err)
      return err;
  }
 
  if (flags & UV_UDP_IPV6ONLY) {
#ifdef IPV6_V6ONLY
    yes = 1;
    if (setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &yes, sizeof yes) == -1) {
      err = UV__ERR(errno);
      return err;
    }
#else
    err = UV_ENOTSUP;
    return err;
#endif
  }
 
  if (bind(fd, addr, addrlen)) {
    err = UV__ERR(errno);
    if (errno == EAFNOSUPPORT)
      /* OSX, other BSDs and SunoS fail with EAFNOSUPPORT when binding a
       * socket created with AF_INET to an AF_INET6 address or vice versa. */
      err = UV_EINVAL;
    return err;
  }
 
  if (addr->sa_family == AF_INET6)
    handle->flags |= UV_HANDLE_IPV6;
 
  handle->flags |= UV_HANDLE_BOUND;
  return 0;
}

References addr, addrlen, AF_INET6, bind, EAFNOSUPPORT, err, fd, flags, handle, IPV6_V6ONLY, SOCK_DGRAM, UV__ERR, uv__set_reuse(), uv__socket(), UV_HANDLE_BOUND, UV_HANDLE_IPV6, UV_UDP_IPV6ONLY, and UV_UDP_REUSEADDR.

Referenced by uv__udp_maybe_deferred_bind(), and uv_udp_bind().

uv__udp_connect()

int uv__udp_connect	(	uv_udp_t *	handle,
		const struct sockaddr *	addr,
		unsigned int	addrlen
	)

Definition at line 606 of file udp.c.

                                          {
  int err;
 
  err = uv__udp_maybe_deferred_bind(handle, addr->sa_family, 0);
  if (err)
    return err;
 
  do {
    errno = 0;
    err = connect(handle->io_watcher.fd, addr, addrlen);
  } while (err == -1 && errno == EINTR);
 
  if (err)
    return UV__ERR(errno);
 
  handle->flags |= UV_HANDLE_UDP_CONNECTED;
 
  return 0;
}

References addr, addrlen, EINTR, err, handle, UV__ERR, uv__udp_maybe_deferred_bind(), uv_addr_ip4_any_, uv_addr_ip6_any_, UV_HANDLE_BOUND, UV_HANDLE_UDP_CONNECTED, uv_translate_sys_error(), and uv_udp_maybe_bind().

Referenced by uv_udp_connect().

uv__udp_disconnect()

int uv__udp_disconnect

(

uv_udp_t *

handle

)

Definition at line 629 of file udp.c.

                                         {
    int r;
    struct sockaddr addr;
 
    memset(&addr, 0, sizeof(addr));
 
    addr.sa_family = AF_UNSPEC;
 
    do {
      errno = 0;
      r = connect(handle->io_watcher.fd, &addr, sizeof(addr));
    } while (r == -1 && errno == EINTR);
 
    if (r == -1 && errno != EAFNOSUPPORT)
      return UV__ERR(errno);
 
    handle->flags &= ~UV_HANDLE_UDP_CONNECTED;
    return 0;
}

References addr, AF_UNSPEC, EAFNOSUPPORT, EINTR, err, handle, memset(), r, UV__ERR, UV_HANDLE_UDP_CONNECTED, and uv_translate_sys_error().

Referenced by uv_udp_connect().

uv__udp_init_ex()

int uv__udp_init_ex	(	uv_loop_t *	loop,
		uv_udp_t *	handle,
		unsigned	flags,
		int	domain
	)

Definition at line 954 of file udp.c.

                                {
  int fd;
 
  fd = -1;
  if (domain != AF_UNSPEC) {
    fd = uv__socket(domain, SOCK_DGRAM, 0);
    if (fd < 0)
      return fd;
  }
 
  uv__handle_init(loop, (uv_handle_t*)handle, UV_UDP);
  handle->alloc_cb = NULL;
  handle->recv_cb = NULL;
  handle->send_queue_size = 0;
  handle->send_queue_count = 0;
  uv__io_init(&handle->io_watcher, uv__udp_io, fd);
  QUEUE_INIT(&handle->write_queue);
  QUEUE_INIT(&handle->write_completed_queue);
 
  return 0;
}

References AF_UNSPEC, domain, DWORD, err, fd, handle, loop, NULL, QUEUE_INIT, QUEUE_REMOVE, SOCK_DGRAM, socket, uv__handle_init, uv__io_init(), uv__socket(), uv__udp_io(), UV_REQ_INIT, uv_translate_sys_error(), and uv_udp_set_socket().

Referenced by uv_udp_init_ex().

uv__udp_is_connected()

int uv__udp_is_connected

(

uv_udp_t *

handle

)

Definition at line 393 of file uv-common.c.

                                           {
  struct sockaddr_storage addr;
  int addrlen;
  if (handle->type != UV_UDP)
    return 0;
 
  addrlen = sizeof(addr);
  if (uv_udp_getpeername(handle, (struct sockaddr*) &addr, &addrlen) != 0)
    return 0;
 
  return addrlen > 0;
}

References addr, addrlen, handle, and uv_udp_getpeername().

Referenced by uv_udp_open().

uv__udp_recv_start()

int uv__udp_recv_start	(	uv_udp_t *	handle,
		uv_alloc_cb	alloccb,
		uv_udp_recv_cb	recv_cb
	)

Definition at line 1297 of file udp.c.

                                               {
  int err;
 
  if (alloc_cb == NULL || recv_cb == NULL)
    return UV_EINVAL;
 
  if (uv__io_active(&handle->io_watcher, POLLIN))
    return UV_EALREADY;  /* FIXME(bnoordhuis) Should be UV_EBUSY. */
 
  err = uv__udp_maybe_deferred_bind(handle, AF_INET, 0);
  if (err)
    return err;
 
  handle->alloc_cb = alloc_cb;
  handle->recv_cb = recv_cb;
 
  uv__io_start(handle->loop, &handle->io_watcher, POLLIN);
  uv__handle_start(handle);
 
  return 0;
}

References AF_INET, err, handle, INCREASE_ACTIVE_COUNT, loop, NULL, uv__handle_start, uv__io_active(), uv__io_start(), uv__udp_maybe_deferred_bind(), uv_addr_ip4_any_, UV_HANDLE_READ_PENDING, UV_HANDLE_READING, uv_translate_sys_error(), uv_udp_maybe_bind(), and uv_udp_queue_recv().

Referenced by uv_udp_recv_start().

uv__udp_recv_stop()

int uv__udp_recv_stop

(

uv_udp_t *

handle

)

Definition at line 1322 of file udp.c.

                                        {
  uv__io_stop(handle->loop, &handle->io_watcher, POLLIN);
 
  if (!uv__io_active(&handle->io_watcher, POLLOUT))
    uv__handle_stop(handle);
 
  handle->alloc_cb = NULL;
  handle->recv_cb = NULL;
 
  return 0;
}

References DECREASE_ACTIVE_COUNT, handle, loop, and UV_HANDLE_READING.

Referenced by uv_udp_recv_stop().

uv__udp_send()

int uv__udp_send	(	uv_udp_send_t *	req,
		uv_udp_t *	handle,
		const uv_buf_t	bufs[],
		unsigned int	nbufs,
		const struct sockaddr *	addr,
		unsigned int	addrlen,
		uv_udp_send_cb	send_cb
	)

Definition at line 650 of file udp.c.

                                         {
  int err;
  int empty_queue;
 
  assert(nbufs > 0);
 
  if (addr) {
    err = uv__udp_maybe_deferred_bind(handle, addr->sa_family, 0);
    if (err)
      return err;
  }
 
  /* It's legal for send_queue_count > 0 even when the write_queue is empty;
   * it means there are error-state requests in the write_completed_queue that
   * will touch up send_queue_size/count later.
   */
  empty_queue = (handle->send_queue_count == 0);
 
  uv__req_init(handle->loop, req, UV_UDP_SEND);
  assert(addrlen <= sizeof(req->addr));
  if (addr == NULL)
    req->addr.ss_family = AF_UNSPEC;
  else
    memcpy(&req->addr, addr, addrlen);
  req->send_cb = send_cb;
  req->handle = handle;
  req->nbufs = nbufs;
 
  req->bufs = req->bufsml;
  if (nbufs > ARRAY_SIZE(req->bufsml))
    req->bufs = uv__malloc(nbufs * sizeof(bufs[0]));
 
  if (req->bufs == NULL) {
    uv__req_unregister(handle->loop, req);
    return UV_ENOMEM;
  }
 
  memcpy(req->bufs, bufs, nbufs * sizeof(bufs[0]));
  handle->send_queue_size += uv__count_bufs(req->bufs, req->nbufs);
  handle->send_queue_count++;
  QUEUE_INSERT_TAIL(&handle->write_queue, &req->queue);
  uv__handle_start(handle);
 
  if (empty_queue && !(handle->flags & UV_HANDLE_UDP_PROCESSING)) {
    uv__udp_sendmsg(handle);
 
    /* `uv__udp_sendmsg` may not be able to do non-blocking write straight
     * away. In such cases the `io_watcher` has to be queued for asynchronous
     * write.
     */
    if (!QUEUE_EMPTY(&handle->write_queue))
      uv__io_start(handle->loop, &handle->io_watcher, POLLOUT);
  } else {
    uv__io_start(handle->loop, &handle->io_watcher, POLLOUT);
  }
 
  return 0;
}

References addr, addrlen, AF_UNSPEC, ARRAY_SIZE, assert(), bufs, err, handle, memcpy(), NULL, QUEUE_EMPTY, QUEUE_INSERT_TAIL, req, uv__count_bufs(), uv__handle_start, uv__io_start(), uv__malloc(), uv__req_init, uv__req_unregister, uv__send(), uv__udp_maybe_deferred_bind(), uv__udp_sendmsg(), uv_addr_ip4_any_, uv_addr_ip6_any_, UV_HANDLE_BOUND, UV_HANDLE_UDP_PROCESSING, uv_translate_sys_error(), and uv_udp_maybe_bind().

Referenced by uv_udp_send().

uv__udp_try_send()

int uv__udp_try_send	(	uv_udp_t *	handle,
		const uv_buf_t	bufs[],
		unsigned int	nbufs,
		const struct sockaddr *	addr,
		unsigned int	addrlen
	)

Definition at line 716 of file udp.c.

                                           {
  int err;
  struct msghdr h;
  ssize_t size;
 
  assert(nbufs > 0);
 
  /* already sending a message */
  if (handle->send_queue_count != 0)
    return UV_EAGAIN;
 
  if (addr) {
    err = uv__udp_maybe_deferred_bind(handle, addr->sa_family, 0);
    if (err)
      return err;
  } else {
    assert(handle->flags & UV_HANDLE_UDP_CONNECTED);
  }
 
  memset(&h, 0, sizeof h);
  h.msg_name = (struct sockaddr*) addr;
  h.msg_namelen = addrlen;
  h.msg_iov = (struct iovec*) bufs;
  h.msg_iovlen = nbufs;
 
  do {
    size = sendmsg(handle->io_watcher.fd, &h, 0);
  } while (size == -1 && errno == EINTR);
 
  if (size == -1) {
    if (errno == EAGAIN || errno == EWOULDBLOCK || errno == ENOBUFS)
      return UV_EAGAIN;
    else
      return UV__ERR(errno);
  }
 
  return size;
}

References addr, addrlen, assert(), bufs, bytes, DWORD, EAGAIN, EINTR, ENOBUFS, err, h, handle, memset(), NULL, uv__convert_to_localhost_if_unspecified(), UV__ERR, uv__udp_maybe_deferred_bind(), uv_addr_ip4_any_, uv_addr_ip6_any_, UV_HANDLE_BOUND, UV_HANDLE_UDP_CONNECTED, uv_translate_sys_error(), and uv_udp_maybe_bind().

Referenced by uv_udp_try_send().

uv__work_done()

void uv__work_done

(

uv_async_t *

handle

)

Definition at line 295 of file threadpool.c.

                                       {
  struct uv__work* w;
  uv_loop_t* loop;
  QUEUE* q;
  QUEUE wq;
  int err;
 
  loop = container_of(handle, uv_loop_t, wq_async);
  uv_mutex_lock(&loop->wq_mutex);
  QUEUE_MOVE(&loop->wq, &wq);
  uv_mutex_unlock(&loop->wq_mutex);
 
  while (!QUEUE_EMPTY(&wq)) {
    q = QUEUE_HEAD(&wq);
    QUEUE_REMOVE(q);
 
    w = container_of(q, struct uv__work, wq);
    err = (w->work == uv__cancelled) ? UV_ECANCELED : 0;
    w->done(w, err);
  }
}

References container_of, err, handle, loop, QUEUE_EMPTY, QUEUE_HEAD, QUEUE_MOVE, QUEUE_REMOVE, uv__cancelled(), uv_mutex_lock(), uv_mutex_unlock(), w, and wq.

Referenced by uv_loop_init().

uv__work_submit()

void uv__work_submit	(	uv_loop_t *	loop,
		struct uv__work *	w,
		enum uv__work_kind	kind,
		void(*)(struct uv__work *w)	work,
		void(*)(struct uv__work *w, int status)	done
	)

Definition at line 256 of file threadpool.c.

                                                                   {
  uv_once(&once, init_once);
  w->loop = loop;
  w->work = work;
  w->done = done;
  post(&w->wq, kind);
}

References done, init_once(), loop, once, post(), uv_once(), w, and uv__work::work.

Referenced by uv_getaddrinfo(), uv_getnameinfo(), uv_queue_work(), and uv_random().