linux-core.c File Reference

#include "uv.h"
#include "internal.h"
#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <net/if.h>
#include <sys/epoll.h>
#include <sys/param.h>
#include <sys/prctl.h>
#include <sys/sysinfo.h>
#include <unistd.h>
#include <fcntl.h>
#include <time.h>
#include <ifaddrs.h>
#include <sys/socket.h>
#include <net/ethernet.h>
#include <netpacket/packet.h>

Go to the source code of this file.

Macros
#define	HAVE_IFADDRS_H   1
#define	CLOCK_MONOTONIC_COARSE   6
#define	CLOCK_BOOTTIME   7

Functions
static int	read_models (unsigned int numcpus, uv_cpu_info_t *ci)
static int	read_times (FILE *statfile_fp, unsigned int numcpus, uv_cpu_info_t *ci)
static void	read_speeds (unsigned int numcpus, uv_cpu_info_t *ci)
static uint64_t	read_cpufreq (unsigned int cpunum)
int	uv__platform_loop_init (uv_loop_t *loop)
int	uv__io_fork (uv_loop_t *loop)
void	uv__platform_loop_delete (uv_loop_t *loop)
void	uv__platform_invalidate_fd (uv_loop_t *loop, int fd)
int	uv__io_check_fd (uv_loop_t *loop, int fd)
void	uv__io_poll (uv_loop_t *loop, int timeout)
uint64_t	uv__hrtime (uv_clocktype_t type)
int	uv_resident_set_memory (size_t *rss)
int	uv_uptime (double *uptime)
static int	uv__cpu_num (FILE *statfile_fp, unsigned int *numcpus)
int	uv_cpu_info (uv_cpu_info_t **cpu_infos, int *count)
static int	uv__ifaddr_exclude (struct ifaddrs *ent, int exclude_type)
int	uv_interface_addresses (uv_interface_address_t **addresses, int *count)
void	uv_free_interface_addresses (uv_interface_address_t *addresses, int count)
void	uv__set_process_title (const char *title)
static int	uv__slurp (const char *filename, char *buf, size_t len)
static uint64_t	uv__read_proc_meminfo (const char *what)
uint64_t	uv_get_free_memory (void)
uint64_t	uv_get_total_memory (void)
static uint64_t	uv__read_cgroups_uint64 (const char *cgroup, const char *param)
uint64_t	uv_get_constrained_memory (void)
void	uv_loadavg (double avg[3])

Macro Definition Documentation

CLOCK_BOOTTIME

#define CLOCK_BOOTTIME   7

Definition at line 75 of file linux-core.c.

CLOCK_MONOTONIC_COARSE

#define CLOCK_MONOTONIC_COARSE   6

Definition at line 67 of file linux-core.c.

HAVE_IFADDRS_H

#define HAVE_IFADDRS_H   1

Definition at line 46 of file linux-core.c.

Function Documentation

read_cpufreq()

static uint64_t read_cpufreq ( unsigned int  cpunum )

static

Definition at line 884 of file linux-core.c.

                                                  {
  uint64_t val;
  char buf[1024];
  FILE* fp;
 
  snprintf(buf,
           sizeof(buf),
           "/sys/devices/system/cpu/cpu%u/cpufreq/scaling_cur_freq",
           cpunum);
 
  fp = uv__open_file(buf);
  if (fp == NULL)
    return 0;
 
  if (fscanf(fp, "%" PRIu64, &val) != 1)
    val = 0;
 
  fclose(fp);
 
  return val;
}

References benchmark::FILE, NULL, PRIu64, snprintf, uv__open_file(), and val.

Referenced by read_speeds().

read_models()

static int read_models ( unsigned int  numcpus, uv_cpu_info_t *  ci  )

static

Definition at line 717 of file linux-core.c.

                                                                {
  static const char model_marker[] = "model name\t: ";
  static const char speed_marker[] = "cpu MHz\t\t: ";
  const char* inferred_model;
  unsigned int model_idx;
  unsigned int speed_idx;
  char buf[1024];
  char* model;
  FILE* fp;
 
  /* Most are unused on non-ARM, non-MIPS and non-x86 architectures. */
  (void) &model_marker;
  (void) &speed_marker;
  (void) &speed_idx;
  (void) &model;
  (void) &buf;
  (void) &fp;
 
  model_idx = 0;
  speed_idx = 0;
 
#if defined(__arm__) || \
    defined(__i386__) || \
    defined(__mips__) || \
    defined(__x86_64__)
  fp = uv__open_file("/proc/cpuinfo");
  if (fp == NULL)
    return UV__ERR(errno);
 
  while (fgets(buf, sizeof(buf), fp)) {
    if (model_idx < numcpus) {
      if (strncmp(buf, model_marker, sizeof(model_marker) - 1) == 0) {
        model = buf + sizeof(model_marker) - 1;
        model = uv__strndup(model, strlen(model) - 1);  /* Strip newline. */
        if (model == NULL) {
          fclose(fp);
          return UV_ENOMEM;
        }
        ci[model_idx++].model = model;
        continue;
      }
    }
#if defined(__arm__) || defined(__mips__)
    if (model_idx < numcpus) {
#if defined(__arm__)
      /* Fallback for pre-3.8 kernels. */
      static const char model_marker[] = "Processor\t: ";
#else   /* defined(__mips__) */
      static const char model_marker[] = "cpu model\t\t: ";
#endif
      if (strncmp(buf, model_marker, sizeof(model_marker) - 1) == 0) {
        model = buf + sizeof(model_marker) - 1;
        model = uv__strndup(model, strlen(model) - 1);  /* Strip newline. */
        if (model == NULL) {
          fclose(fp);
          return UV_ENOMEM;
        }
        ci[model_idx++].model = model;
        continue;
      }
    }
#else  /* !__arm__ && !__mips__ */
    if (speed_idx < numcpus) {
      if (strncmp(buf, speed_marker, sizeof(speed_marker) - 1) == 0) {
        ci[speed_idx++].speed = atoi(buf + sizeof(speed_marker) - 1);
        continue;
      }
    }
#endif  /* __arm__ || __mips__ */
  }
 
  fclose(fp);
#endif  /* __arm__ || __i386__ || __mips__ || __x86_64__ */
 
  /* Now we want to make sure that all the models contain *something* because
   * it's not safe to leave them as null. Copy the last entry unless there
   * isn't one, in that case we simply put "unknown" into everything.
   */
  inferred_model = "unknown";
  if (model_idx > 0)
    inferred_model = ci[model_idx - 1].model;
 
  while (model_idx < numcpus) {
    model = uv__strndup(inferred_model, strlen(inferred_model));
    if (model == NULL)
      return UV_ENOMEM;
    ci[model_idx++].model = model;
  }
 
  return 0;
}

References benchmark::FILE, uv_cpu_info_s::model, NULL, uv_cpu_info_s::speed, UV__ERR, uv__open_file(), and uv__strndup().

Referenced by uv_cpu_info().

read_speeds()

static void read_speeds ( unsigned int  numcpus, uv_cpu_info_t *  ci  )

static

Definition at line 704 of file linux-core.c.

                                                                 {
  unsigned int num;
 
  for (num = 0; num < numcpus; num++)
    ci[num].speed = read_cpufreq(num) / 1000;
}

References num, and read_cpufreq().

Referenced by uv_cpu_info().

read_times()

static int read_times ( FILE *  statfile_fp, unsigned int  numcpus, uv_cpu_info_t *  ci  )

static

Definition at line 810 of file linux-core.c.

                                         {
  struct uv_cpu_times_s ts;
  unsigned int ticks;
  unsigned int multiplier;
  uint64_t user;
  uint64_t nice;
  uint64_t sys;
  uint64_t idle;
  uint64_t dummy;
  uint64_t irq;
  uint64_t num;
  uint64_t len;
  char buf[1024];
 
  ticks = (unsigned int)sysconf(_SC_CLK_TCK);
  multiplier = ((uint64_t)1000L / ticks);
  assert(ticks != (unsigned int) -1);
  assert(ticks != 0);
 
  rewind(statfile_fp);
 
  if (!fgets(buf, sizeof(buf), statfile_fp))
    abort();
 
  num = 0;
 
  while (fgets(buf, sizeof(buf), statfile_fp)) {
    if (num >= numcpus)
      break;
 
    if (strncmp(buf, "cpu", 3))
      break;
 
    /* skip "cpu<num> " marker */
    {
      unsigned int n;
      int r = sscanf(buf, "cpu%u ", &n);
      assert(r == 1);
      (void) r;  /* silence build warning */
      for (len = sizeof("cpu0"); n /= 10; len++);
    }
 
    /* Line contains user, nice, system, idle, iowait, irq, softirq, steal,
     * guest, guest_nice but we're only interested in the first four + irq.
     *
     * Don't use %*s to skip fields or %ll to read straight into the uint64_t
     * fields, they're not allowed in C89 mode.
     */
    if (6 != sscanf(buf + len,
                    "%" PRIu64 " %" PRIu64 " %" PRIu64
                    "%" PRIu64 " %" PRIu64 " %" PRIu64,
                    &user,
                    &nice,
                    &sys,
                    &idle,
                    &dummy,
                    &irq))
      abort();
 
    ts.user = user * multiplier;
    ts.nice = nice * multiplier;
    ts.sys  = sys * multiplier;
    ts.idle = idle * multiplier;
    ts.irq  = irq * multiplier;
    ci[num++].cpu_times = ts;
  }
  assert(num == numcpus);
 
  return 0;
}

References assert(), uv_cpu_info_s::cpu_times, uv_cpu_times_s::idle, int, uv_cpu_times_s::irq, len, n, nice, uv_cpu_times_s::nice, num, PRIu64, r, uv_cpu_times_s::sys, and uv_cpu_times_s::user.

Referenced by uv_cpu_info().

uv__cpu_num()

static int uv__cpu_num ( FILE *  statfile_fp, unsigned int *  numcpus  )

static

Definition at line 631 of file linux-core.c.

                                                                 {
  unsigned int num;
  char buf[1024];
 
  if (!fgets(buf, sizeof(buf), statfile_fp))
    return UV_EIO;
 
  num = 0;
  while (fgets(buf, sizeof(buf), statfile_fp)) {
    if (strncmp(buf, "cpu", 3))
      break;
    num++;
  }
 
  if (num == 0)
    return UV_EIO;
 
  *numcpus = num;
  return 0;
}

References num.

Referenced by uv_cpu_info().

uv__hrtime()

uint64_t uv__hrtime

(

uv_clocktype_t

type

)

Definition at line 512 of file linux-core.c.

                                         {
  static clock_t fast_clock_id = -1;
  struct timespec t;
  clock_t clock_id;
 
  /* Prefer CLOCK_MONOTONIC_COARSE if available but only when it has
   * millisecond granularity or better.  CLOCK_MONOTONIC_COARSE is
   * serviced entirely from the vDSO, whereas CLOCK_MONOTONIC may
   * decide to make a costly system call.
   */
  /* TODO(bnoordhuis) Use CLOCK_MONOTONIC_COARSE for UV_CLOCK_PRECISE
   * when it has microsecond granularity or better (unlikely).
   */
  clock_id = CLOCK_MONOTONIC;
  if (type != UV_CLOCK_FAST)
    goto done;
 
  clock_id = uv__load_relaxed(&fast_clock_id);
  if (clock_id != -1)
    goto done;
 
  clock_id = CLOCK_MONOTONIC;
  if (0 == clock_getres(CLOCK_MONOTONIC_COARSE, &t))
    if (t.tv_nsec <= 1 * 1000 * 1000)
      clock_id = CLOCK_MONOTONIC_COARSE;
 
  uv__store_relaxed(&fast_clock_id, clock_id);
 
done:
 
  if (clock_gettime(clock_id, &t))
    return 0;  /* Not really possible. */
 
  return t.tv_sec * (uint64_t) 1e9 + t.tv_nsec;
}

References CLOCK_MONOTONIC_COARSE, done, timespec::tv_nsec, timespec::tv_sec, type, uv__load_relaxed, uv__store_relaxed, and UV_CLOCK_FAST.

uv__ifaddr_exclude()

static int uv__ifaddr_exclude ( struct ifaddrs *  ent, int  exclude_type  )

static

Definition at line 907 of file linux-core.c.

                                                                     {
  if (!((ent->ifa_flags & IFF_UP) && (ent->ifa_flags & IFF_RUNNING)))
    return 1;
  if (ent->ifa_addr == NULL)
    return 1;
  /*
   * On Linux getifaddrs returns information related to the raw underlying
   * devices. We're not interested in this information yet.
   */
  if (ent->ifa_addr->sa_family == PF_PACKET)
    return exclude_type;
  return !exclude_type;
}

References ifaddrs::ifa_addr, ifaddrs::ifa_flags, NULL, and PF_PACKET.

Referenced by uv_interface_addresses().

uv__io_check_fd()

int uv__io_check_fd	(	uv_loop_t *	loop,
		int	fd
	)

Definition at line 170 of file linux-core.c.

                                             {
  struct epoll_event e;
  int rc;
 
  memset(&e, 0, sizeof(e));
  e.events = POLLIN;
  e.data.fd = -1;
 
  rc = 0;
  if (epoll_ctl(loop->backend_fd, EPOLL_CTL_ADD, fd, &e))
    if (errno != EEXIST)
      rc = UV__ERR(errno);
 
  if (rc == 0)
    if (epoll_ctl(loop->backend_fd, EPOLL_CTL_DEL, fd, &e))
      abort();
 
  return rc;
}

References e, EEXIST, epoll_ctl(), EPOLL_CTL_ADD, EPOLL_CTL_DEL, fd, loop, memset(), and UV__ERR.

uv__io_fork()

int uv__io_fork

(

uv_loop_t *

loop

)

Definition at line 111 of file linux-core.c.

                                 {
  int err;
  void* old_watchers;
 
  old_watchers = loop->inotify_watchers;
 
  uv__close(loop->backend_fd);
  loop->backend_fd = -1;
  uv__platform_loop_delete(loop);
 
  err = uv__platform_loop_init(loop);
  if (err)
    return err;
 
  return uv__inotify_fork(loop, old_watchers);
}

References err, loop, uv__close(), uv__inotify_fork(), uv__platform_loop_delete(), and uv__platform_loop_init().

uv__io_poll()

void uv__io_poll	(	uv_loop_t *	loop,
		int	timeout
	)

Definition at line 191 of file linux-core.c.

                                               {
  /* A bug in kernels < 2.6.37 makes timeouts larger than ~30 minutes
   * effectively infinite on 32 bits architectures.  To avoid blocking
   * indefinitely, we cap the timeout and poll again if necessary.
   *
   * Note that "30 minutes" is a simplification because it depends on
   * the value of CONFIG_HZ.  The magic constant assumes CONFIG_HZ=1200,
   * that being the largest value I have seen in the wild (and only once.)
   */
  static const int max_safe_timeout = 1789569;
  static int no_epoll_pwait_cached;
  static int no_epoll_wait_cached;
  int no_epoll_pwait;
  int no_epoll_wait;
  struct epoll_event events[1024];
  struct epoll_event* pe;
  struct epoll_event e;
  int real_timeout;
  QUEUE* q;
  uv__io_t* w;
  sigset_t sigset;
  uint64_t sigmask;
  uint64_t base;
  int have_signals;
  int nevents;
  int count;
  int nfds;
  int fd;
  int op;
  int i;
  int user_timeout;
  int reset_timeout;
 
  if (loop->nfds == 0) {
    assert(QUEUE_EMPTY(&loop->watcher_queue));
    return;
  }
 
  memset(&e, 0, sizeof(e));
 
  while (!QUEUE_EMPTY(&loop->watcher_queue)) {
    q = QUEUE_HEAD(&loop->watcher_queue);
    QUEUE_REMOVE(q);
    QUEUE_INIT(q);
 
    w = QUEUE_DATA(q, uv__io_t, watcher_queue);
    assert(w->pevents != 0);
    assert(w->fd >= 0);
    assert(w->fd < (int) loop->nwatchers);
 
    e.events = w->pevents;
    e.data.fd = w->fd;
 
    if (w->events == 0)
      op = EPOLL_CTL_ADD;
    else
      op = EPOLL_CTL_MOD;
 
    /* XXX Future optimization: do EPOLL_CTL_MOD lazily if we stop watching
     * events, skip the syscall and squelch the events after epoll_wait().
     */
    if (epoll_ctl(loop->backend_fd, op, w->fd, &e)) {
      if (errno != EEXIST)
        abort();
 
      assert(op == EPOLL_CTL_ADD);
 
      /* We've reactivated a file descriptor that's been watched before. */
      if (epoll_ctl(loop->backend_fd, EPOLL_CTL_MOD, w->fd, &e))
        abort();
    }
 
    w->events = w->pevents;
  }
 
  sigmask = 0;
  if (loop->flags & UV_LOOP_BLOCK_SIGPROF) {
    sigemptyset(&sigset);
    sigaddset(&sigset, SIGPROF);
    sigmask |= 1 << (SIGPROF - 1);
  }
 
  assert(timeout >= -1);
  base = loop->time;
  count = 48; /* Benchmarks suggest this gives the best throughput. */
  real_timeout = timeout;
 
  if (uv__get_internal_fields(loop)->flags & UV_METRICS_IDLE_TIME) {
    reset_timeout = 1;
    user_timeout = timeout;
    timeout = 0;
  } else {
    reset_timeout = 0;
    user_timeout = 0;
  }
 
  /* You could argue there is a dependency between these two but
   * ultimately we don't care about their ordering with respect
   * to one another. Worst case, we make a few system calls that
   * could have been avoided because another thread already knows
   * they fail with ENOSYS. Hardly the end of the world.
   */
  no_epoll_pwait = uv__load_relaxed(&no_epoll_pwait_cached);
  no_epoll_wait = uv__load_relaxed(&no_epoll_wait_cached);
 
  for (;;) {
    /* Only need to set the provider_entry_time if timeout != 0. The function
     * will return early if the loop isn't configured with UV_METRICS_IDLE_TIME.
     */
    if (timeout != 0)
      uv__metrics_set_provider_entry_time(loop);
 
    /* See the comment for max_safe_timeout for an explanation of why
     * this is necessary.  Executive summary: kernel bug workaround.
     */
    if (sizeof(int32_t) == sizeof(long) && timeout >= max_safe_timeout)
      timeout = max_safe_timeout;
 
    if (sigmask != 0 && no_epoll_pwait != 0)
      if (pthread_sigmask(SIG_BLOCK, &sigset, NULL))
        abort();
 
    if (no_epoll_wait != 0 || (sigmask != 0 && no_epoll_pwait == 0)) {
      nfds = epoll_pwait(loop->backend_fd,
                         events,
                         ARRAY_SIZE(events),
                         timeout,
                         &sigset);
      if (nfds == -1 && errno == ENOSYS) {
        uv__store_relaxed(&no_epoll_pwait_cached, 1);
        no_epoll_pwait = 1;
      }
    } else {
      nfds = epoll_wait(loop->backend_fd,
                        events,
                        ARRAY_SIZE(events),
                        timeout);
      if (nfds == -1 && errno == ENOSYS) {
        uv__store_relaxed(&no_epoll_wait_cached, 1);
        no_epoll_wait = 1;
      }
    }
 
    if (sigmask != 0 && no_epoll_pwait != 0)
      if (pthread_sigmask(SIG_UNBLOCK, &sigset, NULL))
        abort();
 
    /* Update loop->time unconditionally. It's tempting to skip the update when
     * timeout == 0 (i.e. non-blocking poll) but there is no guarantee that the
     * operating system didn't reschedule our process while in the syscall.
     */
    SAVE_ERRNO(uv__update_time(loop));
 
    if (nfds == 0) {
      assert(timeout != -1);
 
      if (reset_timeout != 0) {
        timeout = user_timeout;
        reset_timeout = 0;
      }
 
      if (timeout == -1)
        continue;
 
      if (timeout == 0)
        return;
 
      /* We may have been inside the system call for longer than |timeout|
       * milliseconds so we need to update the timestamp to avoid drift.
       */
      goto update_timeout;
    }
 
    if (nfds == -1) {
      if (errno == ENOSYS) {
        /* epoll_wait() or epoll_pwait() failed, try the other system call. */
        assert(no_epoll_wait == 0 || no_epoll_pwait == 0);
        continue;
      }
 
      if (errno != EINTR)
        abort();
 
      if (reset_timeout != 0) {
        timeout = user_timeout;
        reset_timeout = 0;
      }
 
      if (timeout == -1)
        continue;
 
      if (timeout == 0)
        return;
 
      /* Interrupted by a signal. Update timeout and poll again. */
      goto update_timeout;
    }
 
    have_signals = 0;
    nevents = 0;
 
    {
      /* Squelch a -Waddress-of-packed-member warning with gcc >= 9. */
      union {
        struct epoll_event* events;
        uv__io_t* watchers;
      } x;
 
      x.events = events;
      assert(loop->watchers != NULL);
      loop->watchers[loop->nwatchers] = x.watchers;
      loop->watchers[loop->nwatchers + 1] = (void*) (uintptr_t) nfds;
    }
 
    for (i = 0; i < nfds; i++) {
      pe = events + i;
      fd = pe->data.fd;
 
      /* Skip invalidated events, see uv__platform_invalidate_fd */
      if (fd == -1)
        continue;
 
      assert(fd >= 0);
      assert((unsigned) fd < loop->nwatchers);
 
      w = loop->watchers[fd];
 
      if (w == NULL) {
        /* File descriptor that we've stopped watching, disarm it.
         *
         * Ignore all errors because we may be racing with another thread
         * when the file descriptor is closed.
         */
        epoll_ctl(loop->backend_fd, EPOLL_CTL_DEL, fd, pe);
        continue;
      }
 
      /* Give users only events they're interested in. Prevents spurious
       * callbacks when previous callback invocation in this loop has stopped
       * the current watcher. Also, filters out events that users has not
       * requested us to watch.
       */
      pe->events &= w->pevents | POLLERR | POLLHUP;
 
      /* Work around an epoll quirk where it sometimes reports just the
       * EPOLLERR or EPOLLHUP event.  In order to force the event loop to
       * move forward, we merge in the read/write events that the watcher
       * is interested in; uv__read() and uv__write() will then deal with
       * the error or hangup in the usual fashion.
       *
       * Note to self: happens when epoll reports EPOLLIN|EPOLLHUP, the user
       * reads the available data, calls uv_read_stop(), then sometime later
       * calls uv_read_start() again.  By then, libuv has forgotten about the
       * hangup and the kernel won't report EPOLLIN again because there's
       * nothing left to read.  If anything, libuv is to blame here.  The
       * current hack is just a quick bandaid; to properly fix it, libuv
       * needs to remember the error/hangup event.  We should get that for
       * free when we switch over to edge-triggered I/O.
       */
      if (pe->events == POLLERR || pe->events == POLLHUP)
        pe->events |=
          w->pevents & (POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI);
 
      if (pe->events != 0) {
        /* Run signal watchers last.  This also affects child process watchers
         * because those are implemented in terms of signal watchers.
         */
        if (w == &loop->signal_io_watcher) {
          have_signals = 1;
        } else {
          uv__metrics_update_idle_time(loop);
          w->cb(loop, w, pe->events);
        }
 
        nevents++;
      }
    }
 
    if (reset_timeout != 0) {
      timeout = user_timeout;
      reset_timeout = 0;
    }
 
    if (have_signals != 0) {
      uv__metrics_update_idle_time(loop);
      loop->signal_io_watcher.cb(loop, &loop->signal_io_watcher, POLLIN);
    }
 
    loop->watchers[loop->nwatchers] = NULL;
    loop->watchers[loop->nwatchers + 1] = NULL;
 
    if (have_signals != 0)
      return;  /* Event loop should cycle now so don't poll again. */
 
    if (nevents != 0) {
      if (nfds == ARRAY_SIZE(events) && --count != 0) {
        /* Poll for more events but don't block this time. */
        timeout = 0;
        continue;
      }
      return;
    }
 
    if (timeout == 0)
      return;
 
    if (timeout == -1)
      continue;
 
update_timeout:
    assert(timeout > 0);
 
    real_timeout -= (loop->time - base);
    if (real_timeout <= 0)
      return;
 
    timeout = real_timeout;
  }
}

References ARRAY_SIZE, assert(), count, e, EEXIST, EINTR, epoll_ctl(), EPOLL_CTL_ADD, EPOLL_CTL_DEL, EPOLL_CTL_MOD, epoll_wait(), epoll_event::events, fd, epoll_event::fd, flags, i, loop, memset(), nfds, NULL, op, QUEUE_DATA, QUEUE_EMPTY, QUEUE_HEAD, QUEUE_INIT, QUEUE_REMOVE, SAVE_ERRNO, timeout, uv__get_internal_fields, uv__load_relaxed, uv__metrics_set_provider_entry_time(), uv__metrics_update_idle_time(), UV__POLLPRI, UV__POLLRDHUP, uv__store_relaxed, UV_LOOP_BLOCK_SIGPROF, UV_METRICS_IDLE_TIME, w, and x.

uv__platform_invalidate_fd()

void uv__platform_invalidate_fd	(	uv_loop_t *	loop,
		int	fd
	)

Definition at line 137 of file linux-core.c.

                                                         {
  struct epoll_event* events;
  struct epoll_event dummy;
  uintptr_t i;
  uintptr_t nfds;
 
  assert(loop->watchers != NULL);
  assert(fd >= 0);
 
  events = (struct epoll_event*) loop->watchers[loop->nwatchers];
  nfds = (uintptr_t) loop->watchers[loop->nwatchers + 1];
  if (events != NULL)
    /* Invalidate events with same file descriptor */
    for (i = 0; i < nfds; i++)
      if (events[i].data.fd == fd)
        events[i].data.fd = -1;
 
  /* Remove the file descriptor from the epoll.
   * This avoids a problem where the same file description remains open
   * in another process, causing repeated junk epoll events.
   *
   * We pass in a dummy epoll_event, to work around a bug in old kernels.
   */
  if (loop->backend_fd >= 0) {
    /* Work around a bug in kernels 3.10 to 3.19 where passing a struct that
     * has the EPOLLWAKEUP flag set generates spurious audit syslog warnings.
     */
    memset(&dummy, 0, sizeof(dummy));
    epoll_ctl(loop->backend_fd, EPOLL_CTL_DEL, fd, &dummy);
  }
}

References assert(), epoll_ctl(), EPOLL_CTL_DEL, epoll_event::events, fd, i, loop, memset(), nfds, and NULL.

uv__platform_loop_delete()

void uv__platform_loop_delete

(

uv_loop_t *

loop

)

Definition at line 129 of file linux-core.c.

                                               {
  if (loop->inotify_fd == -1) return;
  uv__io_stop(loop, &loop->inotify_read_watcher, POLLIN);
  uv__close(loop->inotify_fd);
  loop->inotify_fd = -1;
}

References loop, uv__close(), and uv__io_stop().

Referenced by uv__io_fork().

uv__platform_loop_init()

int uv__platform_loop_init

(

uv_loop_t *

loop

)

Definition at line 86 of file linux-core.c.

                                            {
  int fd;
  fd = epoll_create1(O_CLOEXEC);
 
  /* epoll_create1() can fail either because it's not implemented (old kernel)
   * or because it doesn't understand the O_CLOEXEC flag.
   */
  if (fd == -1 && (errno == ENOSYS || errno == EINVAL)) {
    fd = epoll_create(256);
 
    if (fd != -1)
      uv__cloexec(fd, 1);
  }
 
  loop->backend_fd = fd;
  loop->inotify_fd = -1;
  loop->inotify_watchers = NULL;
 
  if (fd == -1)
    return UV__ERR(errno);
 
  return 0;
}

References EINVAL, epoll_create1(), fd, loop, NULL, O_CLOEXEC, uv__cloexec, and UV__ERR.

Referenced by uv__io_fork().

uv__read_cgroups_uint64()

static uint64_t uv__read_cgroups_uint64 ( const char *  cgroup, const char *  param  )

static

Definition at line 1108 of file linux-core.c.

                                                                               {
  char filename[256];
  char buf[32];  /* Large enough to hold an encoded uint64_t. */
  uint64_t rc;
 
  rc = 0;
  snprintf(filename, sizeof(filename), "/sys/fs/cgroup/%s/%s", cgroup, param);
  if (0 == uv__slurp(filename, buf, sizeof(buf)))
    sscanf(buf, "%" PRIu64, &rc);
 
  return rc;
}

References PRIu64, snprintf, and uv__slurp().

Referenced by uv_get_constrained_memory().

uv__read_proc_meminfo()

static uint64_t uv__read_proc_meminfo ( const char *  what )

static

Definition at line 1054 of file linux-core.c.

                                                        {
  uint64_t rc;
  char* p;
  char buf[4096];  /* Large enough to hold all of /proc/meminfo. */
 
  if (uv__slurp("/proc/meminfo", buf, sizeof(buf)))
    return 0;
 
  p = strstr(buf, what);
 
  if (p == NULL)
    return 0;
 
  p += strlen(what);
 
  rc = 0;
  sscanf(p, "%" PRIu64 " kB", &rc);
 
  return rc * 1024;
}

References NULL, p, PRIu64, and uv__slurp().

Referenced by uv_get_free_memory(), and uv_get_total_memory().

uv__set_process_title()

void uv__set_process_title

(

const char *

title

)

Definition at line 1021 of file linux-core.c.

                                              {
#if defined(PR_SET_NAME)
  prctl(PR_SET_NAME, title);  /* Only copies first 16 characters. */
#endif
}

uv__slurp()

static int uv__slurp ( const char *  filename, char *  buf, size_t  len  )

static

Definition at line 1028 of file linux-core.c.

                                                                  {
  ssize_t n;
  int fd;
 
  assert(len > 0);
 
  fd = uv__open_cloexec(filename, O_RDONLY);
  if (fd < 0)
    return fd;
 
  do
    n = read(fd, buf, len - 1);
  while (n == -1 && errno == EINTR);
 
  if (uv__close_nocheckstdio(fd))
    abort();
 
  if (n < 0)
    return UV__ERR(errno);
 
  buf[n] = '\0';
 
  return 0;
}

References assert(), EINTR, fd, len, n, O_RDONLY, read(), uv__close_nocheckstdio(), UV__ERR, and uv__open_cloexec().

Referenced by uv__read_cgroups_uint64(), uv__read_proc_meminfo(), and uv_loadavg().

uv_cpu_info()

int uv_cpu_info	(	uv_cpu_info_t **	cpu_infos,
		int *	count
	)

Definition at line 653 of file linux-core.c.

                                                       {
  unsigned int numcpus;
  uv_cpu_info_t* ci;
  int err;
  FILE* statfile_fp;
 
  *cpu_infos = NULL;
  *count = 0;
 
  statfile_fp = uv__open_file("/proc/stat");
  if (statfile_fp == NULL)
    return UV__ERR(errno);
 
  err = uv__cpu_num(statfile_fp, &numcpus);
  if (err < 0)
    goto out;
 
  err = UV_ENOMEM;
  ci = uv__calloc(numcpus, sizeof(*ci));
  if (ci == NULL)
    goto out;
 
  err = read_models(numcpus, ci);
  if (err == 0)
    err = read_times(statfile_fp, numcpus, ci);
 
  if (err) {
    uv_free_cpu_info(ci, numcpus);
    goto out;
  }
 
  /* read_models() on x86 also reads the CPU speed from /proc/cpuinfo.
   * We don't check for errors here. Worst case, the field is left zero.
   */
  if (ci[0].speed == 0)
    read_speeds(numcpus, ci);
 
  *cpu_infos = ci;
  *count = numcpus;
  err = 0;
 
out:
 
  if (fclose(statfile_fp))
    if (errno != EINTR && errno != EINPROGRESS)
      abort();
 
  return err;
}

References count, EINPROGRESS, EINTR, err, benchmark::FILE, NULL, out, read_models(), read_speeds(), read_times(), uv__calloc(), uv__cpu_num(), UV__ERR, uv__open_file(), and uv_free_cpu_info().

uv_free_interface_addresses()

void uv_free_interface_addresses	(	uv_interface_address_t *	addresses,
		int	count
	)

Definition at line 1009 of file linux-core.c.

             {
  int i;
 
  for (i = 0; i < count; i++) {
    uv__free(addresses[i].name);
  }
 
  uv__free(addresses);
}

References count, i, and uv__free().

uv_get_constrained_memory()

uint64_t uv_get_constrained_memory

(

void

)

Definition at line 1122 of file linux-core.c.

                                         {
  /*
   * This might return 0 if there was a problem getting the memory limit from
   * cgroups. This is OK because a return value of 0 signifies that the memory
   * limit is unknown.
   */
  return uv__read_cgroups_uint64("memory", "memory.limit_in_bytes");
}

References uv__read_cgroups_uint64().

uv_get_free_memory()

uint64_t uv_get_free_memory

(

void

)

Definition at line 1076 of file linux-core.c.

                                  {
  struct sysinfo info;
  uint64_t rc;
 
  rc = uv__read_proc_meminfo("MemFree:");
 
  if (rc != 0)
    return rc;
 
  if (0 == sysinfo(&info))
    return (uint64_t) info.freeram * info.mem_unit;
 
  return 0;
}

References info(), sysinfo, and uv__read_proc_meminfo().

uv_get_total_memory()

uint64_t uv_get_total_memory

(

void

)

Definition at line 1092 of file linux-core.c.

                                   {
  struct sysinfo info;
  uint64_t rc;
 
  rc = uv__read_proc_meminfo("MemTotal:");
 
  if (rc != 0)
    return rc;
 
  if (0 == sysinfo(&info))
    return (uint64_t) info.totalram * info.mem_unit;
 
  return 0;
}

References info(), sysinfo, and uv__read_proc_meminfo().

uv_interface_addresses()

int uv_interface_addresses	(	uv_interface_address_t **	addresses,
		int *	count
	)

Definition at line 921 of file linux-core.c.

                                                                           {
#ifndef HAVE_IFADDRS_H
  *count = 0;
  *addresses = NULL;
  return UV_ENOSYS;
#else
  struct ifaddrs *addrs, *ent;
  uv_interface_address_t* address;
  int i;
  struct sockaddr_ll *sll;
 
  *count = 0;
  *addresses = NULL;
 
  if (getifaddrs(&addrs))
    return UV__ERR(errno);
 
  /* Count the number of interfaces */
  for (ent = addrs; ent != NULL; ent = ent->ifa_next) {
    if (uv__ifaddr_exclude(ent, UV__EXCLUDE_IFADDR))
      continue;
 
    (*count)++;
  }
 
  if (*count == 0) {
    freeifaddrs(addrs);
    return 0;
  }
 
  /* Make sure the memory is initiallized to zero using calloc() */
  *addresses = uv__calloc(*count, sizeof(**addresses));
  if (!(*addresses)) {
    freeifaddrs(addrs);
    return UV_ENOMEM;
  }
 
  address = *addresses;
 
  for (ent = addrs; ent != NULL; ent = ent->ifa_next) {
    if (uv__ifaddr_exclude(ent, UV__EXCLUDE_IFADDR))
      continue;
 
    address->name = uv__strdup(ent->ifa_name);
 
    if (ent->ifa_addr->sa_family == AF_INET6) {
      address->address.address6 = *((struct sockaddr_in6*) ent->ifa_addr);
    } else {
      address->address.address4 = *((struct sockaddr_in*) ent->ifa_addr);
    }
 
    if (ent->ifa_netmask->sa_family == AF_INET6) {
      address->netmask.netmask6 = *((struct sockaddr_in6*) ent->ifa_netmask);
    } else {
      address->netmask.netmask4 = *((struct sockaddr_in*) ent->ifa_netmask);
    }
 
    address->is_internal = !!(ent->ifa_flags & IFF_LOOPBACK);
 
    address++;
  }
 
  /* Fill in physical addresses for each interface */
  for (ent = addrs; ent != NULL; ent = ent->ifa_next) {
    if (uv__ifaddr_exclude(ent, UV__EXCLUDE_IFPHYS))
      continue;
 
    address = *addresses;
 
    for (i = 0; i < (*count); i++) {
      size_t namelen = strlen(ent->ifa_name);
      /* Alias interface share the same physical address */
      if (strncmp(address->name, ent->ifa_name, namelen) == 0 &&
          (address->name[namelen] == 0 || address->name[namelen] == ':')) {
        sll = (struct sockaddr_ll*)ent->ifa_addr;
        memcpy(address->phys_addr, sll->sll_addr, sizeof(address->phys_addr));
      }
      address++;
    }
  }
 
  freeifaddrs(addrs);
 
  return 0;
#endif
}

References uv_interface_address_s::address, uv_interface_address_s::address4, uv_interface_address_s::address6, AF_INET6, count, freeifaddrs(), getifaddrs(), i, ifaddrs::ifa_addr, ifaddrs::ifa_flags, ifaddrs::ifa_name, ifaddrs::ifa_netmask, ifaddrs::ifa_next, uv_interface_address_s::is_internal, memcpy(), uv_interface_address_s::name, uv_interface_address_s::netmask, uv_interface_address_s::netmask4, uv_interface_address_s::netmask6, NULL, uv_interface_address_s::phys_addr, uv__calloc(), UV__ERR, UV__EXCLUDE_IFADDR, UV__EXCLUDE_IFPHYS, uv__ifaddr_exclude(), and uv__strdup().

uv_loadavg()

void uv_loadavg

(

double

avg[3]

)

Definition at line 1132 of file linux-core.c.

                               {
  struct sysinfo info;
  char buf[128];  /* Large enough to hold all of /proc/loadavg. */
 
  if (0 == uv__slurp("/proc/loadavg", buf, sizeof(buf)))
    if (3 == sscanf(buf, "%lf %lf %lf", &avg[0], &avg[1], &avg[2]))
      return;
 
  if (sysinfo(&info) < 0)
    return;
 
  avg[0] = (double) info.loads[0] / 65536.0;
  avg[1] = (double) info.loads[1] / 65536.0;
  avg[2] = (double) info.loads[2] / 65536.0;
}

References info(), sysinfo, and uv__slurp().

uv_resident_set_memory()

int uv_resident_set_memory

(

size_t *

rss

)

Definition at line 549 of file linux-core.c.

                                        {
  char buf[1024];
  const char* s;
  ssize_t n;
  long val;
  int fd;
  int i;
 
  do
    fd = open("/proc/self/stat", O_RDONLY);
  while (fd == -1 && errno == EINTR);
 
  if (fd == -1)
    return UV__ERR(errno);
 
  do
    n = read(fd, buf, sizeof(buf) - 1);
  while (n == -1 && errno == EINTR);
 
  uv__close(fd);
  if (n == -1)
    return UV__ERR(errno);
  buf[n] = '\0';
 
  s = strchr(buf, ' ');
  if (s == NULL)
    goto err;
 
  s += 1;
  if (*s != '(')
    goto err;
 
  s = strchr(s, ')');
  if (s == NULL)
    goto err;
 
  for (i = 1; i <= 22; i++) {
    s = strchr(s + 1, ' ');
    if (s == NULL)
      goto err;
  }
 
  errno = 0;
  val = strtol(s, NULL, 10);
  if (errno != 0)
    goto err;
  if (val < 0)
    goto err;
 
  *rss = val * getpagesize();
  return 0;
 
err:
  return UV_EINVAL;
}

References EINTR, err, fd, i, n, NULL, O_RDONLY, read(), s, uv__close(), UV__ERR, and val.

uv_uptime()

int uv_uptime

(

double *

uptime

)

Definition at line 606 of file linux-core.c.

                              {
  static volatile int no_clock_boottime;
  struct timespec now;
  int r;
 
  /* Try CLOCK_BOOTTIME first, fall back to CLOCK_MONOTONIC if not available
   * (pre-2.6.39 kernels). CLOCK_MONOTONIC doesn't increase when the system
   * is suspended.
   */
  if (no_clock_boottime) {
    retry: r = clock_gettime(CLOCK_MONOTONIC, &now);
  }
  else if ((r = clock_gettime(CLOCK_BOOTTIME, &now)) && errno == EINVAL) {
    no_clock_boottime = 1;
    goto retry;
  }
 
  if (r)
    return UV__ERR(errno);
 
  *uptime = now.tv_sec;
  return 0;
}

References CLOCK_BOOTTIME, EINVAL, r, timespec::tv_sec, and UV__ERR.