freebsd.c File Reference

#include "uv.h"
#include "internal.h"
#include <assert.h>
#include <string.h>
#include <errno.h>
#include <paths.h>
#include <sys/user.h>
#include <sys/types.h>
#include <sys/resource.h>
#include <sys/sysctl.h>
#include <vm/vm_param.h>
#include <time.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

Go to the source code of this file.

Macros
#define	CPUSTATES   5U
#define	CP_USER   0
#define	CP_NICE   1
#define	CP_SYS   2
#define	CP_IDLE   3
#define	CP_INTR   4

Functions
int	uv__platform_loop_init (uv_loop_t *loop)
void	uv__platform_loop_delete (uv_loop_t *loop)
int	uv_exepath (char *buffer, size_t *size)
uint64_t	uv_get_free_memory (void)
uint64_t	uv_get_total_memory (void)
uint64_t	uv_get_constrained_memory (void)
void	uv_loadavg (double avg[3])
int	uv_resident_set_memory (size_t *rss)
int	uv_uptime (double *uptime)
int	uv_cpu_info (uv_cpu_info_t **cpu_infos, int *count)
int	uv__sendmmsg (int fd, struct uv__mmsghdr *mmsg, unsigned int vlen)
int	uv__recvmmsg (int fd, struct uv__mmsghdr *mmsg, unsigned int vlen)

Macro Definition Documentation

CP_IDLE

#define CP_IDLE   3

Definition at line 46 of file freebsd.c.

CP_INTR

#define CP_INTR   4

Definition at line 47 of file freebsd.c.

CP_NICE

#define CP_NICE   1

Definition at line 44 of file freebsd.c.

CP_SYS

#define CP_SYS   2

Definition at line 45 of file freebsd.c.

CP_USER

#define CP_USER   0

Definition at line 43 of file freebsd.c.

CPUSTATES

#define CPUSTATES   5U

Definition at line 40 of file freebsd.c.

Function Documentation

uv__platform_loop_delete()

void uv__platform_loop_delete

(

uv_loop_t *

loop

)

Definition at line 56 of file freebsd.c.

                                               {
}

uv__platform_loop_init()

int uv__platform_loop_init

(

uv_loop_t *

loop

)

Definition at line 51 of file freebsd.c.

                                            {
  return uv__kqueue_init(loop);
}

References loop, and uv__kqueue_init().

uv__recvmmsg()

int uv__recvmmsg	(	int	fd,
		struct uv__mmsghdr *	mmsg,
		unsigned int	vlen
	)

Definition at line 276 of file freebsd.c.

                                                                      {
#if __FreeBSD__ >= 11
  return recvmmsg(fd, mmsg, vlen, 0 /* flags */, NULL /* timeout */);
#else
  return errno = ENOSYS, -1;
#endif
}

References fd, and NULL.

uv__sendmmsg()

int uv__sendmmsg	(	int	fd,
		struct uv__mmsghdr *	mmsg,
		unsigned int	vlen
	)

Definition at line 267 of file freebsd.c.

                                                                      {
#if __FreeBSD__ >= 11
  return sendmmsg(fd, mmsg, vlen, /* flags */ 0);
#else
  return errno = ENOSYS, -1;
#endif
}

References fd.

uv_cpu_info()

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

Definition at line 172 of file freebsd.c.

                                                       {
  unsigned int ticks = (unsigned int)sysconf(_SC_CLK_TCK),
               multiplier = ((uint64_t)1000L / ticks), cpuspeed, maxcpus,
               cur = 0;
  uv_cpu_info_t* cpu_info;
  const char* maxcpus_key;
  const char* cptimes_key;
  const char* model_key;
  char model[512];
  long* cp_times;
  int numcpus;
  size_t size;
  int i;
 
#if defined(__DragonFly__)
  /* This is not quite correct but DragonFlyBSD doesn't seem to have anything
   * comparable to kern.smp.maxcpus or kern.cp_times (kern.cp_time is a total,
   * not per CPU). At least this stops uv_cpu_info() from failing completely.
   */
  maxcpus_key = "hw.ncpu";
  cptimes_key = "kern.cp_time";
#else
  maxcpus_key = "kern.smp.maxcpus";
  cptimes_key = "kern.cp_times";
#endif
 
#if defined(__arm__) || defined(__aarch64__)
  /* The key hw.model and hw.clockrate are not available on FreeBSD ARM. */
  model_key = "hw.machine";
  cpuspeed = 0;
#else
  model_key = "hw.model";
 
  size = sizeof(cpuspeed);
  if (sysctlbyname("hw.clockrate", &cpuspeed, &size, NULL, 0))
    return -errno;
#endif
 
  size = sizeof(model);
  if (sysctlbyname(model_key, &model, &size, NULL, 0))
    return UV__ERR(errno);
 
  size = sizeof(numcpus);
  if (sysctlbyname("hw.ncpu", &numcpus, &size, NULL, 0))
    return UV__ERR(errno);
 
  *cpu_infos = uv__malloc(numcpus * sizeof(**cpu_infos));
  if (!(*cpu_infos))
    return UV_ENOMEM;
 
  *count = numcpus;
 
  /* kern.cp_times on FreeBSD i386 gives an array up to maxcpus instead of
   * ncpu.
   */
  size = sizeof(maxcpus);
  if (sysctlbyname(maxcpus_key, &maxcpus, &size, NULL, 0)) {
    uv__free(*cpu_infos);
    return UV__ERR(errno);
  }
 
  size = maxcpus * CPUSTATES * sizeof(long);
 
  cp_times = uv__malloc(size);
  if (cp_times == NULL) {
    uv__free(*cpu_infos);
    return UV_ENOMEM;
  }
 
  if (sysctlbyname(cptimes_key, cp_times, &size, NULL, 0)) {
    uv__free(cp_times);
    uv__free(*cpu_infos);
    return UV__ERR(errno);
  }
 
  for (i = 0; i < numcpus; i++) {
    cpu_info = &(*cpu_infos)[i];
 
    cpu_info->cpu_times.user = (uint64_t)(cp_times[CP_USER+cur]) * multiplier;
    cpu_info->cpu_times.nice = (uint64_t)(cp_times[CP_NICE+cur]) * multiplier;
    cpu_info->cpu_times.sys = (uint64_t)(cp_times[CP_SYS+cur]) * multiplier;
    cpu_info->cpu_times.idle = (uint64_t)(cp_times[CP_IDLE+cur]) * multiplier;
    cpu_info->cpu_times.irq = (uint64_t)(cp_times[CP_INTR+cur]) * multiplier;
 
    cpu_info->model = uv__strdup(model);
    cpu_info->speed = cpuspeed;
 
    cur+=CPUSTATES;
  }
 
  uv__free(cp_times);
  return 0;
}

References count, CP_IDLE, CP_INTR, CP_NICE, CP_SYS, CP_USER, uv_cpu_info_s::cpu_times, CPUSTATES, i, uv_cpu_times_s::idle, int, uv_cpu_times_s::irq, long, uv_cpu_info_s::model, uv_cpu_times_s::nice, NULL, uv_cpu_info_s::speed, uv_cpu_times_s::sys, uv_cpu_times_s::user, UV__ERR, uv__free(), uv__malloc(), and uv__strdup().

uv_exepath()

int uv_exepath	(	char *	buffer,
		size_t *	size
	)

Definition at line 59 of file freebsd.c.

                                           {
  char abspath[PATH_MAX * 2 + 1];
  int mib[4];
  size_t abspath_size;
 
  if (buffer == NULL || size == NULL || *size == 0)
    return UV_EINVAL;
 
  mib[0] = CTL_KERN;
  mib[1] = KERN_PROC;
  mib[2] = KERN_PROC_PATHNAME;
  mib[3] = -1;
 
  abspath_size = sizeof abspath;
  if (sysctl(mib, ARRAY_SIZE(mib), abspath, &abspath_size, NULL, 0))
    return UV__ERR(errno);
 
  assert(abspath_size > 0);
  abspath_size -= 1;
  *size -= 1;
 
  if (*size > abspath_size)
    *size = abspath_size;
 
  memcpy(buffer, abspath, *size);
  buffer[*size] = '\0';
 
  return 0;
}

References ARRAY_SIZE, assert(), memcpy(), NULL, and UV__ERR.

uv_get_constrained_memory()

uint64_t uv_get_constrained_memory

(

void

)

Definition at line 114 of file freebsd.c.

                                         {
  return 0;  /* Memory constraints are unknown. */
}

uv_get_free_memory()

uint64_t uv_get_free_memory

(

void

)

Definition at line 89 of file freebsd.c.

                                  {
  int freecount;
  size_t size = sizeof(freecount);
 
  if (sysctlbyname("vm.stats.vm.v_free_count", &freecount, &size, NULL, 0))
    return UV__ERR(errno);
 
  return (uint64_t) freecount * sysconf(_SC_PAGESIZE);
 
}

References NULL, and UV__ERR.

uv_get_total_memory()

uint64_t uv_get_total_memory

(

void

)

Definition at line 101 of file freebsd.c.

                                   {
  unsigned long info;
  int which[] = {CTL_HW, HW_PHYSMEM};
 
  size_t size = sizeof(info);
 
  if (sysctl(which, ARRAY_SIZE(which), &info, &size, NULL, 0))
    return UV__ERR(errno);
 
  return (uint64_t) info;
}

References ARRAY_SIZE, info(), NULL, UV__ERR, and which.

uv_loadavg()

void uv_loadavg

(

double

avg[3]

)

Definition at line 119 of file freebsd.c.

                               {
  struct loadavg info;
  size_t size = sizeof(info);
  int which[] = {CTL_VM, VM_LOADAVG};
 
  if (sysctl(which, ARRAY_SIZE(which), &info, &size, NULL, 0) < 0) return;
 
  avg[0] = (double) info.ldavg[0] / info.fscale;
  avg[1] = (double) info.ldavg[1] / info.fscale;
  avg[2] = (double) info.ldavg[2] / info.fscale;
}

References ARRAY_SIZE, info(), test-lz4-speed::loadavg, NULL, and which.

uv_resident_set_memory()

int uv_resident_set_memory

(

size_t *

rss

)

Definition at line 132 of file freebsd.c.

                                        {
  struct kinfo_proc kinfo;
  size_t page_size;
  size_t kinfo_size;
  int mib[4];
 
  mib[0] = CTL_KERN;
  mib[1] = KERN_PROC;
  mib[2] = KERN_PROC_PID;
  mib[3] = getpid();
 
  kinfo_size = sizeof(kinfo);
 
  if (sysctl(mib, ARRAY_SIZE(mib), &kinfo, &kinfo_size, NULL, 0))
    return UV__ERR(errno);
 
  page_size = getpagesize();
 
#ifdef __DragonFly__
  *rss = kinfo.kp_vm_rssize * page_size;
#else
  *rss = kinfo.ki_rssize * page_size;
#endif
 
  return 0;
}

References ARRAY_SIZE, NULL, and UV__ERR.

uv_uptime()

int uv_uptime

(

double *

uptime

)

Definition at line 160 of file freebsd.c.

                              {
  int r;
  struct timespec sp;
  r = clock_gettime(CLOCK_MONOTONIC, &sp);
  if (r)
    return UV__ERR(errno);
 
  *uptime = sp.tv_sec;
  return 0;
}

References r, sp, and UV__ERR.