os390-syscalls.c File Reference

#include "os390-syscalls.h"
#include <errno.h>
#include <stdlib.h>
#include <search.h>
#include <termios.h>
#include <sys/msg.h>

Go to the source code of this file.

Macros
#define	CW_INTRPT   1
#define	CW_CONDVAR   32
#define	EP_MAX_PFDS   (ULONG_MAX / sizeof(struct pollfd))
#define	EP_MAX_EVENTS   (INT_MAX / sizeof(struct epoll_event))

Functions
int	scandir (const char *maindir, struct dirent ***namelist, int(*filter)(const struct dirent *), int(*compar)(const struct dirent **, const struct dirent **))
static unsigned int	next_power_of_two (unsigned int val)
static void	maybe_resize (uv__os390_epoll *lst, unsigned int len)
static void	init_message_queue (uv__os390_epoll *lst)
static void	before_fork (void)
static void	after_fork (void)
static void	child_fork (void)
static void	epoll_init (void)
uv__os390_epoll *	epoll_create1 (int flags)
int	epoll_ctl (uv__os390_epoll *lst, int op, int fd, struct epoll_event *event)
int	epoll_wait (uv__os390_epoll *lst, struct epoll_event *events, int maxevents, int timeout)
int	epoll_file_close (int fd)
void	epoll_queue_close (uv__os390_epoll *lst)
int	nanosleep (const struct timespec *req, struct timespec *rem)
char *	mkdtemp (char *path)
ssize_t	os390_readlink (const char *path, char *buf, size_t len)
size_t	strnlen (const char *str, size_t maxlen)
int	sem_init (UV_PLATFORM_SEM_T *semid, int pshared, unsigned int value)
int	sem_destroy (UV_PLATFORM_SEM_T *semid)
int	sem_post (UV_PLATFORM_SEM_T *semid)
int	sem_trywait (UV_PLATFORM_SEM_T *semid)
int	sem_wait (UV_PLATFORM_SEM_T *semid)

Variables
static QUEUE	global_epoll_queue
static uv_mutex_t	global_epoll_lock
static uv_once_t	once = UV_ONCE_INIT

Macro Definition Documentation

CW_CONDVAR

#define CW_CONDVAR   32

Definition at line 31 of file os390-syscalls.c.

CW_INTRPT

#define CW_INTRPT   1

Definition at line 30 of file os390-syscalls.c.

EP_MAX_EVENTS

#define EP_MAX_EVENTS   (INT_MAX / sizeof(struct epoll_event))

Definition at line 281 of file os390-syscalls.c.

EP_MAX_PFDS

#define EP_MAX_PFDS   (ULONG_MAX / sizeof(struct pollfd))

Definition at line 280 of file os390-syscalls.c.

Function Documentation

after_fork()

static void after_fork ( void  )

static

Definition at line 176 of file os390-syscalls.c.

                             {
  uv_mutex_unlock(&global_epoll_lock);
}

References global_epoll_lock, and uv_mutex_unlock().

Referenced by epoll_init().

before_fork()

static void before_fork ( void  )

static

Definition at line 171 of file os390-syscalls.c.

                              {
  uv_mutex_lock(&global_epoll_lock);
}

References global_epoll_lock, and uv_mutex_lock().

Referenced by epoll_init().

child_fork()

static void child_fork ( void  )

static

Definition at line 181 of file os390-syscalls.c.

                             {
  QUEUE* q;
  uv_once_t child_once = UV_ONCE_INIT;
 
  /* reset once */
  memcpy(&once, &child_once, sizeof(child_once));
 
  /* reset epoll list */
  while (!QUEUE_EMPTY(&global_epoll_queue)) {
    uv__os390_epoll* lst;
    q = QUEUE_HEAD(&global_epoll_queue);
    QUEUE_REMOVE(q);
    lst = QUEUE_DATA(q, uv__os390_epoll, member);
    uv__free(lst->items);
    lst->items = NULL;
    lst->size = 0;
  }
 
  uv_mutex_unlock(&global_epoll_lock);
  uv_mutex_destroy(&global_epoll_lock);
}

References global_epoll_lock, global_epoll_queue, uv__os390_epoll::items, memcpy(), NULL, once, QUEUE_DATA, QUEUE_EMPTY, QUEUE_HEAD, QUEUE_REMOVE, uv__os390_epoll::size, uv__free(), uv_mutex_destroy(), uv_mutex_unlock(), and UV_ONCE_INIT.

Referenced by epoll_init().

epoll_create1()

uv__os390_epoll* epoll_create1

(

int

flags

)

Definition at line 214 of file os390-syscalls.c.

                                          {
  uv__os390_epoll* lst;
 
  lst = uv__malloc(sizeof(*lst));
  if (lst != NULL) {
    /* initialize list */
    lst->size = 0;
    lst->items = NULL;
    init_message_queue(lst);
    maybe_resize(lst, 1);
    lst->items[lst->size - 1].fd = lst->msg_queue;
    lst->items[lst->size - 1].events = POLLIN;
    lst->items[lst->size - 1].revents = 0;
    uv_once(&once, epoll_init);
    uv_mutex_lock(&global_epoll_lock);
    QUEUE_INSERT_TAIL(&global_epoll_queue, &lst->member);
    uv_mutex_unlock(&global_epoll_lock);
  }
 
  return lst;
}

References epoll_init(), global_epoll_lock, global_epoll_queue, init_message_queue(), uv__os390_epoll::items, maybe_resize(), uv__os390_epoll::member, uv__os390_epoll::msg_queue, NULL, once, QUEUE_INSERT_TAIL, uv__os390_epoll::size, uv__malloc(), uv_mutex_lock(), uv_mutex_unlock(), and uv_once().

Referenced by uv__platform_loop_init().

epoll_ctl()

int epoll_ctl	(	uv__os390_epoll *	lst,
		int	op,
		int	fd,
		struct epoll_event *	event
	)

Definition at line 237 of file os390-syscalls.c.

                                         {
  uv_mutex_lock(&global_epoll_lock);
 
  if (op == EPOLL_CTL_DEL) {
    if (fd >= lst->size || lst->items[fd].fd == -1) {
      uv_mutex_unlock(&global_epoll_lock);
      errno = ENOENT;
      return -1;
    }
    lst->items[fd].fd = -1;
  } else if (op == EPOLL_CTL_ADD) {
 
    /* Resizing to 'fd + 1' would expand the list to contain at least
     * 'fd'. But we need to guarantee that the last index on the list 
     * is reserved for the message queue. So specify 'fd + 2' instead.
     */
    maybe_resize(lst, fd + 2);
    if (lst->items[fd].fd != -1) {
      uv_mutex_unlock(&global_epoll_lock);
      errno = EEXIST;
      return -1;
    }
    lst->items[fd].fd = fd;
    lst->items[fd].events = event->events;
    lst->items[fd].revents = 0;
  } else if (op == EPOLL_CTL_MOD) {
    if (fd >= lst->size - 1 || lst->items[fd].fd == -1) {
      uv_mutex_unlock(&global_epoll_lock);
      errno = ENOENT;
      return -1;
    }
    lst->items[fd].events = event->events;
    lst->items[fd].revents = 0;
  } else
    abort();
 
  uv_mutex_unlock(&global_epoll_lock);
  return 0;
}

References EEXIST, ENOENT, EPOLL_CTL_ADD, EPOLL_CTL_DEL, EPOLL_CTL_MOD, fd, global_epoll_lock, uv__os390_epoll::items, maybe_resize(), uv__os390_epoll::size, uv_mutex_lock(), and uv_mutex_unlock().

Referenced by uv__io_check_fd(), uv__io_poll(), and uv__platform_invalidate_fd().

epoll_file_close()

int epoll_file_close

(

int

fd

)

Definition at line 353 of file os390-syscalls.c.

                             {
  QUEUE* q;
 
  uv_once(&once, epoll_init);
  uv_mutex_lock(&global_epoll_lock);
  QUEUE_FOREACH(q, &global_epoll_queue) {
    uv__os390_epoll* lst;
 
    lst = QUEUE_DATA(q, uv__os390_epoll, member);
    if (fd < lst->size && lst->items != NULL && lst->items[fd].fd != -1)
      lst->items[fd].fd = -1;
  }
 
  uv_mutex_unlock(&global_epoll_lock);
  return 0;
}

References epoll_init(), fd, global_epoll_lock, global_epoll_queue, uv__os390_epoll::items, NULL, once, QUEUE_DATA, QUEUE_FOREACH, uv_mutex_lock(), uv_mutex_unlock(), and uv_once().

Referenced by uv__close().

epoll_init()

static void epoll_init ( void  )

static

Definition at line 204 of file os390-syscalls.c.

                             {
  QUEUE_INIT(&global_epoll_queue);
  if (uv_mutex_init(&global_epoll_lock))
    abort();
 
  if (pthread_atfork(&before_fork, &after_fork, &child_fork))
    abort();
}

References after_fork(), before_fork(), child_fork(), global_epoll_lock, global_epoll_queue, QUEUE_INIT, and uv_mutex_init().

Referenced by epoll_create1(), and epoll_file_close().

epoll_queue_close()

void epoll_queue_close

(

uv__os390_epoll *

lst

)

Definition at line 370 of file os390-syscalls.c.

                                             {
  /* Remove epoll instance from global queue */
  uv_mutex_lock(&global_epoll_lock);
  QUEUE_REMOVE(&lst->member);
  uv_mutex_unlock(&global_epoll_lock);
 
  /* Free resources */
  msgctl(lst->msg_queue, IPC_RMID, NULL);
  lst->msg_queue = -1;
  uv__free(lst->items);
  lst->items = NULL;
}

References global_epoll_lock, uv__os390_epoll::items, uv__os390_epoll::member, uv__os390_epoll::msg_queue, NULL, QUEUE_REMOVE, uv__free(), uv_mutex_lock(), and uv_mutex_unlock().

Referenced by uv__platform_loop_delete().

epoll_wait()

int epoll_wait	(	uv__os390_epoll *	lst,
		struct epoll_event *	events,
		int	maxevents,
		int	timeout
	)

Definition at line 283 of file os390-syscalls.c.

                                           {
  nmsgsfds_t size;
  struct pollfd* pfds;
  int pollret;
  int reventcount;
  int nevents;
  struct pollfd msg_fd;
  int i;
 
  if (!lst || !lst->items || !events) {
    errno = EFAULT;
    return -1;
  }
 
  if (lst->size > EP_MAX_PFDS) {
    errno = EINVAL;
    return -1;
  }
 
  if (maxevents <= 0 || maxevents > EP_MAX_EVENTS) {
    errno = EINVAL;
    return -1;
  }
 
  if (lst->size > 0)
    _SET_FDS_MSGS(size, 1, lst->size - 1);
  else
    _SET_FDS_MSGS(size, 0, 0);
  pfds = lst->items;
  pollret = poll(pfds, size, timeout);
  if (pollret <= 0)
    return pollret;
 
  assert(lst->size > 0);
 
  pollret = _NFDS(pollret) + _NMSGS(pollret);
 
  reventcount = 0;
  nevents = 0;
  msg_fd = pfds[lst->size - 1];
  for (i = 0;
       i < lst->size && i < maxevents && reventcount < pollret; ++i) {
    struct epoll_event ev;
    struct pollfd* pfd;
 
    pfd = &pfds[i];
    if (pfd->fd == -1 || pfd->revents == 0)
      continue;
 
    ev.fd = pfd->fd;
    ev.events = pfd->revents;
    ev.is_msg = 0;
    if (pfd->revents & POLLIN && pfd->revents & POLLOUT)
      reventcount += 2;
    else if (pfd->revents & (POLLIN | POLLOUT))
      ++reventcount;
 
    pfd->revents = 0;
    events[nevents++] = ev;
  }
 
  if (msg_fd.revents != 0 && msg_fd.fd != -1)
    if (i == lst->size)
      events[nevents - 1].is_msg = 1;
 
  return nevents;
}

References assert(), EFAULT, EINVAL, EP_MAX_EVENTS, EP_MAX_PFDS, epoll_event::events, epoll_event::fd, i, epoll_event::is_msg, uv__os390_epoll::items, poll, uv__os390_epoll::size, and timeout.

Referenced by uv__io_poll().

init_message_queue()

static void init_message_queue ( uv__os390_epoll *  lst )

static

Definition at line 145 of file os390-syscalls.c.

                                                     {
  struct {
    long int header;
    char body;
  } msg;
 
  /* initialize message queue */
  lst->msg_queue = msgget(IPC_PRIVATE, 0600 | IPC_CREAT);
  if (lst->msg_queue == -1)
    abort();
 
  /*
     On z/OS, the message queue will be affiliated with the process only
     when a send is performed on it. Once this is done, the system
     can be queried for all message queues belonging to our process id.
  */
  msg.header = 1;
  if (msgsnd(lst->msg_queue, &msg, sizeof(msg.body), 0) != 0)
    abort();
 
  /* Clean up the dummy message sent above */
  if (msgrcv(lst->msg_queue, &msg, sizeof(msg.body), 0, 0) != sizeof(msg.body))
    abort();
}

References header, msg, and uv__os390_epoll::msg_queue.

Referenced by epoll_create1().

maybe_resize()

static void maybe_resize ( uv__os390_epoll *  lst, unsigned int  len  )

static

Definition at line 112 of file os390-syscalls.c.

                                                                 {
  unsigned int newsize;
  unsigned int i;
  struct pollfd* newlst;
  struct pollfd event;
 
  if (len <= lst->size)
    return;
 
  if (lst->size == 0)
    event.fd = -1;
  else {
    /* Extract the message queue at the end. */
    event = lst->items[lst->size - 1];
    lst->items[lst->size - 1].fd = -1;
  }
 
  newsize = next_power_of_two(len);
  newlst = uv__reallocf(lst->items, newsize * sizeof(lst->items[0]));
 
  if (newlst == NULL)
    abort();
  for (i = lst->size; i < newsize; ++i)
    newlst[i].fd = -1;
 
  /* Restore the message queue at the end */
  newlst[newsize - 1] = event;
 
  lst->items = newlst;
  lst->size = newsize;
}

References i, uv__os390_epoll::items, len, next_power_of_two(), NULL, uv__os390_epoll::size, and uv__reallocf().

Referenced by epoll_create1(), and epoll_ctl().

mkdtemp()

char* mkdtemp

(

char *

path

)

Definition at line 424 of file os390-syscalls.c.

                          {
  static const char* tempchars =
    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
  static const size_t num_chars = 62;
  static const size_t num_x = 6;
  char *ep, *cp;
  unsigned int tries, i;
  size_t len;
  uint64_t v;
  int fd;
  int retval;
  int saved_errno;
 
  len = strlen(path);
  ep = path + len;
  if (len < num_x || strncmp(ep - num_x, "XXXXXX", num_x)) {
    errno = EINVAL;
    return NULL;
  }
 
  fd = open("/dev/urandom", O_RDONLY);
  if (fd == -1)
    return NULL;
 
  tries = TMP_MAX;
  retval = -1;
  do {
    if (read(fd, &v, sizeof(v)) != sizeof(v))
      break;
 
    cp = ep - num_x;
    for (i = 0; i < num_x; i++) {
      *cp++ = tempchars[v % num_chars];
      v /= num_chars;
    }
 
    if (mkdir(path, S_IRWXU) == 0) {
      retval = 0;
      break;
    }
    else if (errno != EEXIST)
      break;
  } while (--tries);
 
  saved_errno = errno;
  uv__close(fd);
  if (tries == 0) {
    errno = EEXIST;
    return NULL;
  }
 
  if (retval == -1) {
    errno = saved_errno;
    return NULL;
  }
 
  return path;
}

References EEXIST, EINVAL, fd, i, len, mkdir, NULL, O_RDONLY, path, read(), uv__close(), and v.

Referenced by uv__fs_mkdtemp(), and uv__fs_work().

nanosleep()

int nanosleep	(	const struct timespec *	req,
		struct timespec *	rem
	)

Definition at line 384 of file os390-syscalls.c.

                                                                {
  unsigned nano;
  unsigned seconds;
  unsigned events;
  unsigned secrem;
  unsigned nanorem;
  int rv;
  int err;
  int rsn;
 
  nano = (int)req->tv_nsec;
  seconds = req->tv_sec;
  events = CW_CONDVAR | CW_INTRPT;
  secrem = 0;
  nanorem = 0;
 
#if defined(_LP64)
  BPX4CTW(&seconds, &nano, &events, &secrem, &nanorem, &rv, &err, &rsn);
#else
  BPX1CTW(&seconds, &nano, &events, &secrem, &nanorem, &rv, &err, &rsn);
#endif
 
  /* Don't clobber errno unless BPX1CTW/BPX4CTW errored.
   * Don't leak EAGAIN, that just means the timeout expired.
   */
  if (rv == -1)
    if (err == EAGAIN)
      rv = 0;
    else
      errno = err;
 
  if (rem != NULL && (rv == 0 || err == EINTR)) {
    rem->tv_nsec = nanorem;
    rem->tv_sec = secrem;
  }
 
  return rv;
}

References CW_CONDVAR, CW_INTRPT, EAGAIN, EINTR, err, int, NULL, req, timespec::tv_nsec, and timespec::tv_sec.

next_power_of_two()

static unsigned int next_power_of_two ( unsigned int  val )

static

Definition at line 100 of file os390-syscalls.c.

                                                        {
  val -= 1;
  val |= val >> 1;
  val |= val >> 2;
  val |= val >> 4;
  val |= val >> 8;
  val |= val >> 16;
  val += 1;
  return val;
}

References val.

Referenced by maybe_resize().

os390_readlink()

ssize_t os390_readlink	(	const char *	path,
		char *	buf,
		size_t	len
	)

Definition at line 484 of file os390-syscalls.c.

                                                                {
  ssize_t rlen;
  ssize_t vlen;
  ssize_t plen;
  char* delimiter;
  char old_delim;
  char* tmpbuf;
  char realpathstr[PATH_MAX + 1];
 
  tmpbuf = uv__malloc(len + 1);
  if (tmpbuf == NULL) {
    errno = ENOMEM;
    return -1;
  }
 
  rlen = readlink(path, tmpbuf, len);
  if (rlen < 0) {
    uv__free(tmpbuf);
    return rlen;
  }
 
  if (rlen < 3 || strncmp("/$", tmpbuf, 2) != 0) {
    /* Straightforward readlink. */
    memcpy(buf, tmpbuf, rlen);
    uv__free(tmpbuf);
    return rlen;
  }
 
  /*
   * There is a parmlib variable at the beginning
   * which needs interpretation.
   */
  tmpbuf[rlen] = '\0';
  delimiter = strchr(tmpbuf + 2, '/');
  if (delimiter == NULL)
    /* No slash at the end */
    delimiter = strchr(tmpbuf + 2, '\0');
 
  /* Read real path of the variable. */
  old_delim = *delimiter;
  *delimiter = '\0';
  if (realpath(tmpbuf, realpathstr) == NULL) {
    uv__free(tmpbuf);
    return -1;
  }
 
  /* realpathstr is not guaranteed to end with null byte.*/
  realpathstr[PATH_MAX] = '\0';
 
  /* Reset the delimiter and fill up the buffer. */
  *delimiter = old_delim;
  plen = strlen(delimiter);
  vlen = strlen(realpathstr);
  rlen = plen + vlen;
  if (rlen > len) {
    uv__free(tmpbuf);
    errno = ENAMETOOLONG;
    return -1;
  }
  memcpy(buf, realpathstr, vlen);
  memcpy(buf + vlen, delimiter, plen);
 
  /* Done using temporary buffer. */
  uv__free(tmpbuf);
 
  return rlen;
}

References ENOMEM, len, memcpy(), NULL, path, readlink, uv__free(), and uv__malloc().

Referenced by uv__fs_readlink().

scandir()

int scandir	(	const char *	maindir,
		struct dirent ***	namelist,
		int(*)(const struct dirent *)	filter,
		int(*)(const struct dirent **, const struct dirent **)	compar
	)

Definition at line 40 of file os390-syscalls.c.

                                     {
  struct dirent** nl;
  struct dirent** nl_copy;
  struct dirent* dirent;
  unsigned count;
  size_t allocated;
  DIR* mdir;
 
  nl = NULL;
  count = 0;
  allocated = 0;
  mdir = opendir(maindir);
  if (!mdir)
    return -1;
 
  while (1) {
    dirent = readdir(mdir);
    if (!dirent)
      break;
    if (!filter || filter(dirent)) {
      struct dirent* copy;
      copy = uv__malloc(sizeof(*copy));
      if (!copy)
        goto error;
      memcpy(copy, dirent, sizeof(*copy));
 
      nl_copy = uv__realloc(nl, sizeof(*copy) * (count + 1));
      if (nl_copy == NULL) {
        uv__free(copy);
        goto error;
      }
 
      nl = nl_copy;
      nl[count++] = copy;
    }
  }
 
  qsort(nl, count, sizeof(struct dirent *),
       (int (*)(const void *, const void *)) compar);
 
  closedir(mdir);
 
  *namelist = nl;
  return count;
 
error:
  while (count > 0) {
    dirent = nl[--count];
    uv__free(dirent);
  }
  uv__free(nl);
  closedir(mdir);
  errno = ENOMEM;
  return -1;
}

References count, ENOMEM, error(), filter(), memcpy(), NULL, qsort(), readdir, uv__free(), uv__malloc(), and uv__realloc().

Referenced by uv__fs_scandir(), and uv__fs_work().

sem_destroy()

int sem_destroy

(

UV_PLATFORM_SEM_T *

semid

)

Definition at line 567 of file os390-syscalls.c.

                                          {
  UNREACHABLE();
}

References UNREACHABLE.

Referenced by ptrace_wrap_instance_start(), ptrace_wrap_instance_stop(), rz_th_sem_free(), and uv__sem_destroy().

sem_init()

int sem_init	(	UV_PLATFORM_SEM_T *	semid,
		int	pshared,
		unsigned int	value
	)

Definition at line 562 of file os390-syscalls.c.

                                                                        {
  UNREACHABLE();
}

References UNREACHABLE.

Referenced by ptrace_wrap_instance_start(), rz_th_sem_new(), and uv__sem_init().

sem_post()

int sem_post

(

UV_PLATFORM_SEM_T *

semid

)

Definition at line 572 of file os390-syscalls.c.

                                       {
  UNREACHABLE();
}

References UNREACHABLE.

Referenced by ptrace_wrap(), ptrace_wrap_fork(), ptrace_wrap_func(), ptrace_wrap_instance_stop(), rz_th_sem_post(), th_run(), and uv__sem_post().

sem_trywait()

int sem_trywait

(

UV_PLATFORM_SEM_T *

semid

)

Definition at line 577 of file os390-syscalls.c.

                                          {
  UNREACHABLE();
}

References UNREACHABLE.

Referenced by uv__sem_trywait().

sem_wait()

int sem_wait

(

UV_PLATFORM_SEM_T *

semid

)

Definition at line 582 of file os390-syscalls.c.

                                       {
  UNREACHABLE();
}

References UNREACHABLE.

Referenced by ptrace_wrap(), ptrace_wrap_fork(), ptrace_wrap_func(), rz_th_sem_wait(), th_run(), and uv__sem_wait().

strnlen()

size_t strnlen	(	const char *	str,
		size_t	maxlen
	)

Definition at line 553 of file os390-syscalls.c.

                                               {
  char* p = memchr(str, 0, maxlen);
  if (p == NULL)
    return maxlen;
  else
    return p - str;
}

References maxlen, NULL, p, and cmd_descs_generate::str.

Referenced by rz_str_nlen(), and uv_if_indextoname().

Variable Documentation

global_epoll_lock

uv_mutex_t global_epoll_lock

static

Definition at line 37 of file os390-syscalls.c.

Referenced by after_fork(), before_fork(), child_fork(), epoll_create1(), epoll_ctl(), epoll_file_close(), epoll_init(), and epoll_queue_close().

global_epoll_queue

QUEUE global_epoll_queue

static

Definition at line 36 of file os390-syscalls.c.

Referenced by child_fork(), epoll_create1(), epoll_file_close(), and epoll_init().

once

uv_once_t once = UV_ONCE_INIT

static

Definition at line 38 of file os390-syscalls.c.

Referenced by child_fork(), epoll_create1(), and epoll_file_close().