runtests.c revision 90221f9148b67fdc90178b67f9600b7bd4e3bc7c
/*
* 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
*/
/*
* Copyright 2016 Joyent, Inc.
*/
/*
* Validate various fcntl(2) and flock(3C) operations.
*/
#include "util.h"
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <libgen.h>
#include <signal.h>
#include <stdlib.h>
#include <strings.h>
#include <unistd.h>
#define LOCKFILE_FMT "/tmp/.lockfile-%s-%ld"
#define LOCKDIR_FMT "/tmp/.lockdir-%s-%ld"
typedef struct lockinfo {
char *lf_name;
char *lf_path;
int lf_fd;
} lockinfo_t;
static void assert_unlocked(lockinfo_t *);
static void assert_all_unlocked(void);
static int flock_mkfil(lockinfo_t *);
static int flock_mkdir(lockinfo_t *);
static void flock_rminfo(lockinfo_t *);
pid_t *, int[]);
static void flock_cleanup_child(pid_t, int []);
static void flock_test_invalid(lockinfo_t *, int, short, short,
lockinfo_t *, boolean_t);
static void flock_test_upgrade_downgrade(void);
static short cmds[8] = {
};
static void
{
continue;
}
}
static void
{
}
}
static void
{
}
static void
{
}
static void
{
}
static void
assert_all_unlocked(void)
{
}
static int
{
return (-1);
}
return (0);
}
static int
{
warnx("Failed to generate lockfile name");
return (-1);
}
return (-1);
}
return (0);
}
static int
{
warnx("Failed to generate lockfile name");
return (-1);
}
return (-1);
}
return (-1);
}
return (0);
}
static void
{
}
}
}
static void
{
if (ret == -1) {
}
/* Set up pipe for communicating with child */
if (ret == -1) {
}
if (ret == -1) {
}
closefrom(3);
}
}
static int
{
int childstat = 0;
continue;
}
return (WEXITSTATUS(childstat));
} else if (WIFSIGNALED(childstat)) {
return (1);
} else {
abort();
return (1);
}
}
static void
{
(void) flock_wait(pid);
}
static void
{
int fds[2];
flock_log("Acquiring shared locks 1, 2 and 3...");
flock_log(" ok\n");
flock_log("Upgrading lock 3 should fail w/ EWOULDBLOCK...");
flock_log(" ok\n");
flock_log("Upgrading 3 should succeed after releasing locks 1 & 2...");
flock_log(" ok\n");
flock_log("Starting up child, then downgrading lock 3 to shared...");
flock_block(fds[0]);
flock_log(" ok\n");
flock_log("Releasing child and upgrading...");
flock_alert(fds[0]);
flock_log(" ok\n");
flock_log("Releasing lock 3...");
flock_rminfo(&afd1);
flock_rminfo(&afd2);
flock_rminfo(&afd3);
flock_log(" ok\n");
}
static void
{
};
flock_log("fcntl(fd, %s, { %hd, %hd, %ld, %ld, ... })...",
flock_log(" ok\n");
}
static void
{
flock_log("Running %s + %s tests (%s)...",
/* Create child, and wait for it to acquire the lock */
flock_block(fdsA[0]);
/* Create second child, which shouldn't acquire & signal */
/* lock1 is blocked for reading and writing */
/* Tell pidA to exit */
if (kill_firstborn) {
} else {
flock_alert(fdsA[0]);
}
/* Wait for pidB to signal us */
flock_block(fdsB[0]);
/* lock1 is blocked for reading and writing */
/* Tell pidB to exit */
flock_alert(fdsB[0]);
/*
* Tests after child has released lock
*/
flock_log(" ok\n");
}
static void
{
flock_log("Running %s + %s tests (%s)...",
/* Create children, and wait for it to acquire the lock */
flock_block(fdsB[0]);
flock_block(fdsA[0]);
/* testfileA is only blocked for writing */
/* Tell pidA to exit */
if (kill_firstborn) {
} else {
flock_alert(fdsA[0]);
}
/* testfileA is still blocked for writing by pidB */
/* Tell pidB to exit */
flock_alert(fdsB[0]);
flock_log(" ok\n");
}
static void
flock_test_ofd_sameproc(void)
{
flock_log("Acquiring first two shared locks...");
flock_log(" ok\n");
flock_log("Acquiring an exclusive lock should fail w/ EWOULDBLOCK...");
flock_log(" ok\n");
flock_log("Releasing to acquire an exclusive lock...");
flock_log(" ok\n");
flock_log("Acquiring an exclusive lock...");
flock_log(" ok\n");
flock_log("Acquiring a shared lock should fail w/ EWOULDBLOCK...");
flock_log(" ok\n");
flock_log("Releasing exclusive lock...");
flock_log(" ok\n");
flock_rminfo(&afd1);
flock_rminfo(&afd2);
flock_rminfo(&afd3);
}
static void
flock_runtests(void)
{
int i;
flock_log("# Exclusive lock tests\n");
}
}
flock_log("# Shared lock tests\n");
}
}
flock_log("# flock(3C) directory lock tests\n");
flock_log("# Invalid fcntl(2) parameters tests\n");
for (i = 0; i < sizeof (cmds) / sizeof (short); i++) {
}
for (i = 3; i < sizeof (cmds) / sizeof (short); i++) {
}
flock_log("# Testing that multiple OFD locks work in a process\n");
}
int
{
int exval;
if (argc < 1) {
}
suffix += 1;
}
"Can't generate lock acquisition program name!");
}
"Can't run lock acquisition program %s", acqprog);
}
/* Create several lockfiles for testing */
if (flock_mkfil(&flock_fileA) != 0 ||
flock_mkfil(&flock_fileB) != 0 ||
flock_mkdir(&flock_dirA) != 0 ||
flock_mkdir(&flock_dirB) != 0) {
exval = 1;
goto cleanup;
}
/*
* We run the tests in a child process so that when tests fail
* we can still clean up our temporary files.
*/
testrunner = fork();
} else if (testrunner == (pid_t)0) {
return (0);
}
return (exval);
}