xref: /illumos-gate/usr/src/test/os-tests/tests/file-locking/util.c (revision 44bf619d)

/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2019 Joyent, Inc.
 */

/*
 * Utility functions for use in both acquire-lock and runtests.
 */

#include "util.h"
#include <err.h>
#include <errno.h>
#include <poll.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <unistd.h>


boolean_t LOG = B_FALSE;


void
flock_log(const char *format, ...)
{
	va_list ap;
	if (!LOG) {
		return;
	}

	va_start(ap, format);
	(void) vfprintf(stderr, format, ap);
	va_end(ap);
}


boolean_t
flock_nodata(int fd)
{
	struct pollfd pfd = { fd, POLLIN, 0 };
	int ret = poll(&pfd, 1, 1000);

	if (ret == -1) {
		err(EXIT_FAILURE, "poll failed");
	}

	return (ret == 0);
}


void
flock_block(int fd)
{
	char buf[1];
	int ret = 0;
	while (ret < 1) {
		ret = read(fd, buf, 1);
		if (ret == -1) {
			if (errno == EINTR)
				continue;
			err(EXIT_FAILURE, "read failed");
		}
	}
}


void
flock_alert(int fd)
{
	int ret = 0;
	while (ret < 1) {
		ret = write(fd, "1", 1);
		if (ret == -1) {
			if (errno == EINTR)
				continue;
			err(EXIT_FAILURE, "write failed");
		}
	}
}


lock_style_t
flock_styleenum(char *stylestr)
{
	if (strcmp(stylestr, "posix") == 0) {
		return (LSTYLE_POSIX);
	} else if (strcmp(stylestr, "ofd") == 0) {
		return (LSTYLE_OFD);
	} else if (strcmp(stylestr, "flock") == 0) {
		return (LSTYLE_FLOCK);
	} else {
		errx(EXIT_FAILURE, BAD_LOCK_MESSAGE);
	}
}


char *
flock_stylestr(lock_style_t style)
{
	switch (style) {
	case LSTYLE_POSIX:
		return ("posix");
	case LSTYLE_OFD:
		return ("ofd");
	case LSTYLE_FLOCK:
		return ("flock");
	default:
		abort();
	}
}


char *
flock_stylename(lock_style_t style)
{
	switch (style) {
	case LSTYLE_POSIX:
		return ("fcntl(2) POSIX");
	case LSTYLE_OFD:
		return ("fcntl(2) OFD");
	case LSTYLE_FLOCK:
		return ("flock(3C)");
	default:
		abort();
	}
}


void
flock_reinit(struct flock *flp, int ltype)
{
	bzero(flp, sizeof (*flp));
	flp->l_type = ltype;
}


char *
flock_cmdname(int cmd)
{
	switch (cmd) {
	case F_SETLK:
		return ("F_SETLK");
	case F_OFD_SETLK:
		return ("F_OFD_SETLK");
	case F_SETLKW:
		return ("F_SETLKW");
	case F_OFD_SETLKW:
		return ("F_OFD_SETLKW");
	case F_GETLK:
		return ("F_GETLK");
	case F_OFD_GETLK:
		return ("F_OFD_GETLK");
	case F_FLOCK:
		return ("F_FLOCK");
	case F_FLOCKW:
		return ("F_FLOCKW");
#if !defined(_LP64)
	case F_OFD_SETLK64:
		return ("F_OFD_SETLK64");
	case F_OFD_SETLKW64:
		return ("F_OFD_SETLKW64");
	case F_OFD_GETLK64:
		return ("F_OFD_GETLK64");
#endif
	default:
		abort();
	}
}