ibmi.c File Reference

#include "uv.h"
#include "internal.h"
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/time.h>
#include <unistd.h>
#include <fcntl.h>
#include <utmp.h>
#include <libgen.h>
#include <sys/protosw.h>
#include <procinfo.h>
#include <sys/proc.h>
#include <sys/procfs.h>
#include <ctype.h>
#include <sys/mntctl.h>
#include <sys/vmount.h>
#include <limits.h>
#include <strings.h>
#include <sys/vnode.h>
#include <as400_protos.h>
#include <as400_types.h>

Go to the source code of this file.

Classes
struct	SSTS0200
struct	LIND0500
struct	errcode_s

Functions
static void	iconv_e2a (unsigned char src[], unsigned char dst[], size_t length)
static void	iconv_a2e (const char *src, unsigned char dst[], size_t length)
void	init_process_title_mutex_once (void)
static int	get_ibmi_system_status (SSTS0200 *rcvr)
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)
static int	get_ibmi_physical_address (const char *line, char(*phys_addr)[6])
int	uv_interface_addresses (uv_interface_address_t **addresses, int *count)
void	uv_free_interface_addresses (uv_interface_address_t *addresses, int count)
char **	uv_setup_args (int argc, char **argv)
int	uv_set_process_title (const char *title)
int	uv_get_process_title (char *buffer, size_t size)
void	uv__process_title_cleanup (void)

Variables
char *	original_exepath = NULL
uv_mutex_t	process_title_mutex
uv_once_t	process_title_mutex_once = UV_ONCE_INIT
static const unsigned char	e2a [256]
static const unsigned char	a2e [256]

Function Documentation

get_ibmi_physical_address()

static int get_ibmi_physical_address ( const char *  line, char(*)  phys_addr[6]  )

static

Definition at line 314 of file ibmi.c.

                                                                             {
  LIND0500 rcvr;
  /* rcvrlen is input parameter 2 to QDCRLIND */
  unsigned int rcvrlen = sizeof(rcvr);
  unsigned char format[8], line_name[10];
  unsigned char mac_addr[sizeof(rcvr.loca_adapter_address)];
  int c[6];
 
  /* format is input parameter 3 to QDCRLIND */
  iconv_a2e("LIND0500", format, sizeof(format));
 
  /* line_name is input parameter 4 to QDCRLIND */
  iconv_a2e(line, line_name, sizeof(line_name));
 
  /* err is input parameter 5 to QDCRLIND */
  errcode_s err;
 
  /* qwcrssts_pointer is the 16-byte tagged system pointer to QDCRLIND */
  ILEpointer __attribute__((aligned(16))) qdcrlind_pointer;
 
  /* qwcrssts_argv is the array of argument pointers to QDCRLIND */
  void* qdcrlind_argv[6];
 
  /* Set the IBM i pointer to the QSYS/QDCRLIND *PGM object */
  int rc = _RSLOBJ2(&qdcrlind_pointer, RSLOBJ_TS_PGM, "QDCRLIND", "QSYS");
 
  if (rc != 0)
    return rc;
 
  /* initialize the QDCRLIND returned info structure */
  memset(&rcvr, 0, sizeof(rcvr));
 
  /* initialize the QDCRLIND error code structure */
  memset(&err, 0, sizeof(err));
  err.bytes_provided = sizeof(err);
 
  /* initialize the array of argument pointers for the QDCRLIND API */
  qdcrlind_argv[0] = &rcvr;
  qdcrlind_argv[1] = &rcvrlen;
  qdcrlind_argv[2] = &format;
  qdcrlind_argv[3] = &line_name;
  qdcrlind_argv[4] = &err;
  qdcrlind_argv[5] = NULL;
 
  /* Call the IBM i QDCRLIND API from PASE */
  rc = _PGMCALL(&qdcrlind_pointer, qdcrlind_argv, 0);
  if (rc != 0)
    return rc;
 
  /* convert ebcdic loca_adapter_address to ascii first */
  iconv_e2a(rcvr.loca_adapter_address, mac_addr,
            sizeof(rcvr.loca_adapter_address));
 
  /* convert loca_adapter_address(char[12]) to phys_addr(char[6]) */
  int r = sscanf(mac_addr, "%02x%02x%02x%02x%02x%02x",
                &c[0], &c[1], &c[2], &c[3], &c[4], &c[5]);
 
  if (r == ARRAY_SIZE(c)) {
    (*phys_addr)[0] = c[0];
    (*phys_addr)[1] = c[1];
    (*phys_addr)[2] = c[2];
    (*phys_addr)[3] = c[3];
    (*phys_addr)[4] = c[4];
    (*phys_addr)[5] = c[5];
  } else {
    memset(*phys_addr, 0, sizeof(*phys_addr));
    rc = -1;
  }
  return rc;
}

References __attribute__, ARRAY_SIZE, c, err, iconv_a2e(), iconv_e2a(), setup::line, LIND0500::loca_adapter_address, memset(), NULL, and r.

Referenced by uv_interface_addresses().

get_ibmi_system_status()

static int get_ibmi_system_status ( SSTS0200 *  rcvr )

static

Definition at line 181 of file ibmi.c.

                                                  {
  /* rcvrlen is input parameter 2 to QWCRSSTS */
  unsigned int rcvrlen = sizeof(*rcvr);
  unsigned char format[8], reset_status[10];
 
  /* format is input parameter 3 to QWCRSSTS */
  iconv_a2e("SSTS0200", format, sizeof(format));
  /* reset_status is input parameter 4 */
  iconv_a2e("*NO", reset_status, sizeof(reset_status));
 
  /* errcode is input parameter 5 to QWCRSSTS */
  errcode_s errcode;
 
  /* qwcrssts_pointer is the 16-byte tagged system pointer to QWCRSSTS */
  ILEpointer __attribute__((aligned(16))) qwcrssts_pointer;
 
  /* qwcrssts_argv is the array of argument pointers to QWCRSSTS */
  void* qwcrssts_argv[6];
 
  /* Set the IBM i pointer to the QSYS/QWCRSSTS *PGM object */
  int rc = _RSLOBJ2(&qwcrssts_pointer, RSLOBJ_TS_PGM, "QWCRSSTS", "QSYS");
 
  if (rc != 0)
    return rc;
 
  /* initialize the QWCRSSTS returned info structure */
  memset(rcvr, 0, sizeof(*rcvr));
 
  /* initialize the QWCRSSTS error code structure */
  memset(&errcode, 0, sizeof(errcode));
  errcode.bytes_provided = sizeof(errcode);
 
  /* initialize the array of argument pointers for the QWCRSSTS API */
  qwcrssts_argv[0] = rcvr;
  qwcrssts_argv[1] = &rcvrlen;
  qwcrssts_argv[2] = &format;
  qwcrssts_argv[3] = &reset_status;
  qwcrssts_argv[4] = &errcode;
  qwcrssts_argv[5] = NULL;
 
  /* Call the IBM i QWCRSSTS API from PASE */
  rc = _PGMCALL(&qwcrssts_pointer, qwcrssts_argv, 0);
 
  return rc;
}

References __attribute__, errcode_s::bytes_provided, iconv_a2e(), memset(), and NULL.

Referenced by uv_get_free_memory(), uv_get_total_memory(), and uv_loadavg().

iconv_a2e()

static void iconv_a2e ( const char *  src, unsigned char  dst[], size_t  length  )

static

Definition at line 163 of file ibmi.c.

                                                                           {
  size_t srclen;
  size_t i;
 
  srclen = strlen(src);
  if (srclen > length)
    abort();
  for (i = 0; i < srclen; i++)
    dst[i] = a2e[src[i]];
  /* padding the remaining part with spaces */
  for (; i < length; i++)
    dst[i] = a2e[' '];
}

References a2e, dst, i, length, and src.

Referenced by get_ibmi_physical_address(), and get_ibmi_system_status().

iconv_e2a()

static void iconv_e2a ( unsigned char  src[], unsigned char  dst[], size_t  length  )

static

Definition at line 156 of file ibmi.c.

                                                                               {
  size_t i;
  for (i = 0; i < length; i++)
    dst[i] = e2a[src[i]];
}

References dst, e2a, i, length, and src.

Referenced by get_ibmi_physical_address().

init_process_title_mutex_once()

void init_process_title_mutex_once

(

void

)

Definition at line 177 of file ibmi.c.

                                         {
  uv_mutex_init(&process_title_mutex);
}

References process_title_mutex, and uv_mutex_init().

Referenced by uv_exepath(), and uv_setup_args().

uv__process_title_cleanup()

void uv__process_title_cleanup

(

void

)

Definition at line 500 of file ibmi.c.

                                     {
}

uv_cpu_info()

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

Definition at line 283 of file ibmi.c.

                                                       {
  unsigned int numcpus, idx = 0;
  uv_cpu_info_t* cpu_info;
 
  *cpu_infos = NULL;
  *count = 0;
 
  numcpus = sysconf(_SC_NPROCESSORS_ONLN);
 
  *cpu_infos = uv__malloc(numcpus * sizeof(uv_cpu_info_t));
  if (!*cpu_infos) {
    return UV_ENOMEM;
  }
 
  cpu_info = *cpu_infos;
  for (idx = 0; idx < numcpus; idx++) {
    cpu_info->speed = 0;
    cpu_info->model = uv__strdup("unknown");
    cpu_info->cpu_times.user = 0;
    cpu_info->cpu_times.sys = 0;
    cpu_info->cpu_times.idle = 0;
    cpu_info->cpu_times.irq = 0;
    cpu_info->cpu_times.nice = 0;
    cpu_info++;
  }
  *count = numcpus;
 
  return 0;
}

References count, uv_cpu_info_s::cpu_times, uv_cpu_times_s::idle, setup::idx, uv_cpu_times_s::irq, 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__malloc(), and uv__strdup().

uv_free_interface_addresses()

void uv_free_interface_addresses	(	uv_interface_address_t *	addresses,
		int	count
	)

Definition at line 459 of file ibmi.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 248 of file ibmi.c.

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

uv_get_free_memory()

uint64_t uv_get_free_memory

(

void

)

Definition at line 228 of file ibmi.c.

                                  {
  SSTS0200 rcvr;
 
  if (get_ibmi_system_status(&rcvr))
    return 0;
 
  return (uint64_t)rcvr.main_storage_size * 1024ULL;
}

References get_ibmi_system_status(), and SSTS0200::main_storage_size.

uv_get_process_title()

int uv_get_process_title	(	char *	buffer,
		size_t	size
	)

Definition at line 492 of file ibmi.c.

                                                    {
  if (buffer == NULL || size == 0)
    return UV_EINVAL;
 
  buffer[0] = '\0';
  return 0;
}

References NULL.

uv_get_total_memory()

uint64_t uv_get_total_memory

(

void

)

Definition at line 238 of file ibmi.c.

                                   {
  SSTS0200 rcvr;
 
  if (get_ibmi_system_status(&rcvr))
    return 0;
 
  return (uint64_t)rcvr.main_storage_size * 1024ULL;
}

References get_ibmi_system_status(), and SSTS0200::main_storage_size.

uv_interface_addresses()

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

Definition at line 386 of file ibmi.c.

                                                                           {
  uv_interface_address_t* address;
  struct ifaddrs_pase *ifap = NULL, *cur;
  int inet6, r = 0;
 
  *count = 0;
  *addresses = NULL;
 
  if (Qp2getifaddrs(&ifap))
    return UV_ENOSYS;
 
  /* The first loop to get the size of the array to be allocated */
  for (cur = ifap; cur; cur = cur->ifa_next) {
    if (!(cur->ifa_addr->sa_family == AF_INET6 ||
          cur->ifa_addr->sa_family == AF_INET))
      continue;
 
    if (!(cur->ifa_flags & IFF_UP && cur->ifa_flags & IFF_RUNNING))
      continue;
 
    (*count)++;
  }
 
  if (*count == 0) {
    Qp2freeifaddrs(ifap);
    return 0;
  }
 
  /* Alloc the return interface structs */
  *addresses = uv__calloc(*count, sizeof(**addresses));
  if (*addresses == NULL) {
    Qp2freeifaddrs(ifap);
    return UV_ENOMEM;
  }
  address = *addresses;
 
  /* The second loop to fill in the array */
  for (cur = ifap; cur; cur = cur->ifa_next) {
    if (!(cur->ifa_addr->sa_family == AF_INET6 ||
          cur->ifa_addr->sa_family == AF_INET))
      continue;
 
    if (!(cur->ifa_flags & IFF_UP && cur->ifa_flags & IFF_RUNNING))
      continue;
 
    address->name = uv__strdup(cur->ifa_name);
 
    inet6 = (cur->ifa_addr->sa_family == AF_INET6);
 
    if (inet6) {
      address->address.address6 = *((struct sockaddr_in6*)cur->ifa_addr);
      address->netmask.netmask6 = *((struct sockaddr_in6*)cur->ifa_netmask);
      address->netmask.netmask6.sin6_family = AF_INET6;
    } else {
      address->address.address4 = *((struct sockaddr_in*)cur->ifa_addr);
      address->netmask.netmask4 = *((struct sockaddr_in*)cur->ifa_netmask);
      address->netmask.netmask4.sin_family = AF_INET;
    }
    address->is_internal = cur->ifa_flags & IFF_LOOPBACK ? 1 : 0;
    if (!address->is_internal) {
      int rc = get_ibmi_physical_address(address->name, &address->phys_addr);
      if (rc != 0)
        r = rc;
    }
 
    address++;
  }
 
  Qp2freeifaddrs(ifap);
  return r;
}

References uv_interface_address_s::address, uv_interface_address_s::address4, uv_interface_address_s::address6, AF_INET, AF_INET6, count, get_ibmi_physical_address(), uv_interface_address_s::is_internal, 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, r, uv__calloc(), and uv__strdup().

uv_loadavg()

void uv_loadavg

(

double

avg[3]

)

Definition at line 253 of file ibmi.c.

                               {
  SSTS0200 rcvr;
 
  if (get_ibmi_system_status(&rcvr)) {
    avg[0] = avg[1] = avg[2] = 0;
    return;
  }
 
  /* The average (in tenths) of the elapsed time during which the processing
   * units were in use. For example, a value of 411 in binary would be 41.1%.
   * This percentage could be greater than 100% for an uncapped partition.
   */
  double processing_unit_used_percent =
    rcvr.percent_processing_unit_used / 1000.0;
 
  avg[0] = avg[1] = avg[2] = processing_unit_used_percent;
}

References get_ibmi_system_status(), and SSTS0200::percent_processing_unit_used.

uv_resident_set_memory()

int uv_resident_set_memory

(

size_t *

rss

)

Definition at line 272 of file ibmi.c.

                                        {
  *rss = 0;
  return 0;
}

uv_set_process_title()

int uv_set_process_title

(

const char *

title

)

Definition at line 488 of file ibmi.c.

                                            {
  return 0;
}

uv_setup_args()

char** uv_setup_args	(	int	argc,
		char **	argv
	)

Definition at line 469 of file ibmi.c.

                                            {
  char exepath[UV__PATH_MAX];
  char* s;
  size_t size;
 
  if (argc > 0) {
    /* Use argv[0] to determine value for uv_exepath(). */
    size = sizeof(exepath);
    if (uv__search_path(argv[0], exepath, &size) == 0) {
      uv_once(&process_title_mutex_once, init_process_title_mutex_once);
      uv_mutex_lock(&process_title_mutex);
      original_exepath = uv__strdup(exepath);
      uv_mutex_unlock(&process_title_mutex);
    }
  }
 
  return argv;
}

References argv, init_process_title_mutex_once(), original_exepath, process_title_mutex, process_title_mutex_once, s, UV__PATH_MAX, uv__search_path(), uv__strdup(), uv_mutex_lock(), uv_mutex_unlock(), and uv_once().

uv_uptime()

int uv_uptime

(

double *

uptime

)

Definition at line 278 of file ibmi.c.

                              {
  return UV_ENOSYS;
}

Variable Documentation

a2e

const unsigned char a2e[256]

static

Initial value:

= {
    0, 1, 2, 3, 55, 45, 46, 47, 22, 5, 37, 11, 12, 13, 14, 15,
    16, 17, 18, 19, 60, 61, 50, 38, 24, 25, 63, 39, 28, 29, 30, 31,
    64, 79, 127, 123, 91, 108, 80, 125, 77, 93, 92, 78, 107, 96, 75, 97,
    240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 122, 94, 76, 126, 110, 111,
    124, 193, 194, 195, 196, 197, 198, 199, 200, 201, 209, 210, 211, 212, 213, 214,
    215, 216, 217, 226, 227, 228, 229, 230, 231, 232, 233, 74, 224, 90, 95, 109,
    121, 129, 130, 131, 132, 133, 134, 135, 136, 137, 145, 146, 147, 148, 149, 150,
    151, 152, 153, 162, 163, 164, 165, 166, 167, 168, 169, 192, 106, 208, 161, 7,
    32, 33, 34, 35, 36, 21, 6, 23, 40, 41, 42, 43, 44, 9, 10, 27,
    48, 49, 26, 51, 52, 53, 54, 8, 56, 57, 58, 59, 4, 20, 62, 225,
    65, 66, 67, 68, 69, 70, 71, 72, 73, 81, 82, 83, 84, 85, 86, 87,
    88, 89, 98, 99, 100, 101, 102, 103, 104, 105, 112, 113, 114, 115, 116, 117,
    118, 119, 120, 128, 138, 139, 140, 141, 142, 143, 144, 154, 155, 156, 157, 158,
    159, 160, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183,
    184, 185, 186, 187, 188, 189, 190, 191, 202, 203, 204, 205, 206, 207, 218, 219,
    220, 221, 222, 223, 234, 235, 236, 237, 238, 239, 250, 251, 252, 253, 254, 255}

Definition at line 137 of file ibmi.c.

Referenced by iconv_a2e().

e2a

const unsigned char e2a[256]

static

Initial value:

= {
    0, 1, 2, 3, 156, 9, 134, 127, 151, 141, 142, 11, 12, 13, 14, 15,
    16, 17, 18, 19, 157, 133, 8, 135, 24, 25, 146, 143, 28, 29, 30, 31,
    128, 129, 130, 131, 132, 10, 23, 27, 136, 137, 138, 139, 140, 5, 6, 7,
    144, 145, 22, 147, 148, 149, 150, 4, 152, 153, 154, 155, 20, 21, 158, 26,
    32, 160, 161, 162, 163, 164, 165, 166, 167, 168, 91, 46, 60, 40, 43, 33,
    38, 169, 170, 171, 172, 173, 174, 175, 176, 177, 93, 36, 42, 41, 59, 94,
    45, 47, 178, 179, 180, 181, 182, 183, 184, 185, 124, 44, 37, 95, 62, 63,
    186, 187, 188, 189, 190, 191, 192, 193, 194, 96, 58, 35, 64, 39, 61, 34,
    195, 97, 98, 99, 100, 101, 102, 103, 104, 105, 196, 197, 198, 199, 200, 201,
    202, 106, 107, 108, 109, 110, 111, 112, 113, 114, 203, 204, 205, 206, 207, 208,
    209, 126, 115, 116, 117, 118, 119, 120, 121, 122, 210, 211, 212, 213, 214, 215,
    216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231,
    123, 65, 66, 67, 68, 69, 70, 71, 72, 73, 232, 233, 234, 235, 236, 237,
    125, 74, 75, 76, 77, 78, 79, 80, 81, 82, 238, 239, 240, 241, 242, 243,
    92, 159, 83, 84, 85, 86, 87, 88, 89, 90, 244, 245, 246, 247, 248, 249,
    48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 250, 251, 252, 253, 254, 255}

Definition at line 118 of file ibmi.c.

Referenced by iconv_e2a().

original_exepath

char* original_exepath = NULL

Definition at line 61 of file ibmi.c.

Referenced by uv_exepath(), and uv_setup_args().

process_title_mutex

uv_mutex_t process_title_mutex

Definition at line 62 of file ibmi.c.

Referenced by init_process_title_mutex_once(), uv_exepath(), and uv_setup_args().

process_title_mutex_once

uv_once_t process_title_mutex_once = UV_ONCE_INIT

Definition at line 63 of file ibmi.c.

Referenced by uv_exepath(), and uv_setup_args().