/*
*
* Copyright (c) International Business Machines Corp., 2001
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
* the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/*
* NAME
* fcntl11.c
*
* DESCRIPTION
* Testcase to check locking of regions of a file
*
* ALGORITHM
* Test changing lock sections around a write lock
*
* USAGE
* fcntl11
*
* HISTORY
* 07/2001 Ported by Wayne Boyer
*
* RESTRICTIONS
* None
*/
#include <fcntl.h>
#include <errno.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <inttypes.h>
#include "test.h"
#include "safe_macros.h"
#define STRINGSIZE 27
#define STRING "abcdefghijklmnopqrstuvwxyz\n"
#define STOP 0xFFF0
int parent_pipe[2];
int child_pipe[2];
int fd;
pid_t parent_pid, child_pid;
void parent_put();
void parent_get();
void child_put();
void child_get();
void stop_child();
void compare_lock(struct flock *, short, short, int, int, pid_t);
void unlock_file();
void do_test(struct flock *, short, short, int, int);
void catch_child();
char *str_type();
int do_lock(int, short, short, int, int);
char *TCID = "fcntl11";
int TST_TOTAL = 1;
int fail;
void cleanup(void)
{
tst_rmdir();
}
void setup(void)
{
char *buf = STRING;
char template[PATH_MAX];
struct sigaction act;
tst_sig(FORK, DEF_HANDLER, cleanup);
tst_tmpdir();
umask(0);
TEST_PAUSE;
SAFE_PIPE(cleanup, parent_pipe);
SAFE_PIPE(cleanup, child_pipe);
parent_pid = getpid();
snprintf(template, PATH_MAX, "fcntl11XXXXXX");
if ((fd = mkstemp(template)) < 0)
tst_resm(TFAIL, "Couldn't open temp file! errno = %d", errno);
SAFE_WRITE(cleanup, 0, fd, buf, STRINGSIZE);
memset(&act, 0, sizeof(act));
act.sa_handler = catch_child;
sigemptyset(&act.sa_mask);
sigaddset(&act.sa_mask, SIGCHLD);
if ((sigaction(SIGCHLD, &act, NULL)) < 0)
tst_brkm(TBROK | TERRNO, cleanup,
"sigaction(SIGCHLD, ..) failed");
}
void do_child(void)
{
struct flock fl;
close(parent_pipe[1]);
close(child_pipe[0]);
while (1) {
child_get(&fl);
if (fcntl(fd, F_GETLK, &fl) < 0)
tst_resm(TFAIL | TERRNO, "fcntl on file failed");
child_put(&fl);
}
}
int do_lock(int cmd, short type, short whence, int start, int len)
{
struct flock fl;
fl.l_type = type;
fl.l_whence = whence;
fl.l_start = start;
fl.l_len = len;
return (fcntl(fd, cmd, &fl));
}
void do_test(struct flock *fl, short type, short whence, int start, int len)
{
fl->l_type = type;
fl->l_whence = whence;
fl->l_start = start;
fl->l_len = len;
fl->l_pid = (short)0;
parent_put(fl);
parent_get(fl);
}
void
compare_lock(struct flock *fl, short type, short whence, int start, int len,
pid_t pid)
{
if (fl->l_type != type)
tst_resm(TFAIL, "lock type is wrong should be %s is %s",
str_type(type), str_type(fl->l_type));
if (fl->l_whence != whence)
tst_resm(TFAIL, "lock whence is wrong should be %d is %d",
whence, fl->l_whence);
if (fl->l_start != start)
tst_resm(TFAIL, "region starts in wrong place, should be "
"%d is %" PRId64, start, (int64_t) fl->l_start);
if (fl->l_len != len)
tst_resm(TFAIL,
"region length is wrong, should be %d is %" PRId64,
len, (int64_t) fl->l_len);
if (fl->l_pid != pid)
tst_resm(TFAIL, "locking pid is wrong, should be %d is %d",
pid, fl->l_pid);
}
void unlock_file(void)
{
struct flock fl;
if (do_lock(F_SETLK, (short)F_UNLCK, (short)0, 0, 0) < 0)
tst_resm(TFAIL | TERRNO, "fcntl on file failed");
do_test(&fl, F_WRLCK, 0, 0, 0);
compare_lock(&fl, (short)F_UNLCK, (short)0, 0, 0, (pid_t) 0);
}
char *str_type(int type)
{
static char buf[20];
switch (type) {
case 0:
return ("F_RDLCK");
case 1:
return ("F_WRLCK");
case 2:
return ("F_UNLCK");
default:
sprintf(buf, "BAD VALUE: %d", type);
return (buf);
}
}
void parent_put(struct flock *l)
{
SAFE_WRITE(cleanup, 1, parent_pipe[1], l, sizeof(*l));
}
void parent_get(struct flock *l)
{
SAFE_READ(cleanup, 1, child_pipe[0], l, sizeof(*l));
}
void child_put(struct flock *l)
{
SAFE_WRITE(NULL, 1, child_pipe[1], l, sizeof(*l));
}
void child_get(struct flock *l)
{
SAFE_READ(NULL, 1, parent_pipe[0], l, sizeof(*l));
if (l->l_type == (short)STOP)
exit(0);
}
void stop_child(void)
{
struct flock fl;
signal(SIGCHLD, SIG_DFL);
fl.l_type = STOP;
parent_put(&fl);
wait(0);
}
void catch_child(void)
{
tst_brkm(TFAIL, cleanup, "Unexpected death of child process");
}
int main(int ac, char **av)
{
struct flock tl;
int lc;
tst_parse_opts(ac, av, NULL, NULL);
#ifdef UCLINUX
maybe_run_child(&do_child, "ddddd", &parent_pipe[0],
&parent_pipe[1], &child_pipe[0], &child_pipe[1], &fd);
#endif
setup(); /* global setup */
/* Check for looping state if -i option is given */
for (lc = 0; TEST_LOOPING(lc); lc++) {
/* reset tst_count in case we are looping */
tst_count = 0;
if ((child_pid = FORK_OR_VFORK()) == 0) { /* parent */
#ifdef UCLINUX
if (self_exec(av[0], "ddddd", parent_pipe[0],
parent_pipe[1], child_pipe[0],
child_pipe[1], fd) < 0)
tst_brkm(TBROK | TERRNO, cleanup,
"self_exec failed");
#else
do_child();
#endif
} else if (child_pid == -1)
tst_brkm(TBROK | TERRNO, cleanup, "fork failed");
SAFE_CLOSE(cleanup, parent_pipe[0]);
SAFE_CLOSE(cleanup, child_pipe[1]);
/* //block1: */
tst_resm(TINFO, "Enter block 1");
/*
* Add a write lock to the middle of the file and a read
* at the begining
*/
if (do_lock(F_SETLK, (short)F_WRLCK, (short)0, 10, 5) < 0)
tst_resm(TFAIL | TERRNO, "fcntl on file failed");
if (do_lock(F_SETLK, (short)F_RDLCK, (short)0, 1, 5) < 0)
tst_resm(TFAIL | TERRNO, "fcntl on file failed");
/*
* Test read lock
*/
do_test(&tl, F_WRLCK, 0, 0, 0);
compare_lock(&tl, (short)F_RDLCK, (short)0, 1, 5, parent_pid);
/*
* Test write lock
*/
do_test(&tl, F_WRLCK, 0, 6, 0);
compare_lock(&tl, (short)F_WRLCK, (short)0, 10, 5, parent_pid);
/*
* Test that the rest of the file is unlocked
*/
do_test(&tl, F_WRLCK, 0, 15, 0);
compare_lock(&tl, (short)F_UNLCK, (short)0, 15, 0, 0);
/*
* remove all the locks set above
*/
unlock_file();
tst_resm(TINFO, "Exit block 1");
/* //block2: */
tst_resm(TINFO, "Enter block 2");
/*
* Set a write lock at the middle of the file and a
* read lock just before
*/
if (do_lock(F_SETLK, (short)F_WRLCK, (short)0, 10, 5) < 0)
tst_resm(TFAIL | TERRNO, "fcntl on file failed");
if (do_lock(F_SETLK, (short)F_RDLCK, (short)0, 5, 5) < 0)
tst_resm(TFAIL | TERRNO, "fcntl on file failed");
/*
* Test the read lock
*/
do_test(&tl, (short)F_WRLCK, (short)0, 0, 0);
compare_lock(&tl, (short)F_RDLCK, (short)0, 5, 5, parent_pid);
/*
* Test the write lock.
*/
do_test(&tl, (short)F_WRLCK, (short)0, 10, 0);
compare_lock(&tl, (short)F_WRLCK, (short)0, 10, 5, parent_pid);
/*
* Test to make sure the rest of the file is unlocked.
*/
do_test(&tl, (short)F_WRLCK, (short)0, 15, 0);
compare_lock(&tl, (short)F_UNLCK, (short)0, 15, 0, 0);
/*
* remove all the locks set above
*/
unlock_file();
tst_resm(TINFO, "Exit block 2");
/* //block3: */
tst_resm(TINFO, "Enter block 3");
/*
* Set a write lock in the middle and a read lock that
* ends at the first byte of the write lock
*/
if (do_lock(F_SETLK, (short)F_WRLCK, (short)0, 10, 5) < 0)
tst_resm(TFAIL | TERRNO, "fcntl on file failed");
if (do_lock(F_SETLK, (short)F_RDLCK, (short)0, 5, 6) < 0)
tst_resm(TFAIL | TERRNO, "fcntl on file failed");
/*
* Test read lock
*/
do_test(&tl, (short)F_WRLCK, (short)0, 0, 0);
compare_lock(&tl, (short)F_RDLCK, (short)0, 5, 6, parent_pid);
/*
* Test write lock
*/
do_test(&tl, (short)F_WRLCK, (short)0, 11, 0);
compare_lock(&tl, (short)F_WRLCK, (short)0, 11, 4, parent_pid);
/*
* Test to make sure the rest of the file is unlocked.
*/
do_test(&tl, (short)F_WRLCK, (short)0, 15, 0);
compare_lock(&tl, (short)F_UNLCK, (short)0, 15, 0, 0);
/*
* remove all the locks set above
*/
unlock_file();
tst_resm(TINFO, "Exit block 3");
/* //block4: */
tst_resm(TINFO, "Enter block 4");
/*
* Set a write lock on the middle of the file and a read
* lock that overlaps the front of the write.
*/
if (do_lock(F_SETLK, (short)F_WRLCK, (short)0, 10, 5) < 0)
tst_resm(TFAIL | TERRNO, "fcntl on file failed");
if (do_lock(F_SETLK, (short)F_RDLCK, (short)0, 5, 8) < 0)
tst_resm(TFAIL | TERRNO, "fcntl on file failed");
/*
* Test the read lock
*/
do_test(&tl, (short)F_WRLCK, (short)0, 5, 0);
compare_lock(&tl, (short)F_RDLCK, (short)0, 5, 8, parent_pid);
/*
* Test the write lock
*/
do_test(&tl, (short)F_WRLCK, (short)0, 13, 0);
compare_lock(&tl, (short)F_WRLCK, (short)0, 13, 2, parent_pid);
/*
* Test to make sure the rest of the file is unlocked.
*/
do_test(&tl, (short)F_WRLCK, (short)0, 15, 0);
compare_lock(&tl, (short)F_UNLCK, (short)0, 15, 0, 0);
/*
* remove all the locks set above
*/
unlock_file();
tst_resm(TINFO, "Exit block 4");
/* //block5: */
tst_resm(TINFO, "Enter block 5");
/*
* Set a write lock in the middle of a file and a read
* lock in the middle of it
*/
if (do_lock(F_SETLK, (short)F_WRLCK, (short)0, 10, 10) < 0)
tst_resm(TFAIL | TERRNO, "fcntl on file failed");
if (do_lock(F_SETLK, (short)F_RDLCK, (short)0, 13, 5) < 0)
tst_resm(TFAIL | TERRNO, "fcntl on file failed");
/*
* Test the first write lock
*/
do_test(&tl, (short)F_WRLCK, (short)0, 0, 0);
compare_lock(&tl, (short)F_WRLCK, (short)0, 10, 3, parent_pid);
/*
* Test the read lock
*/
do_test(&tl, (short)F_WRLCK, (short)0, 13, 0);
compare_lock(&tl, (short)F_RDLCK, (short)0, 13, 5, parent_pid);
/*
* Test the second write lock
*/
do_test(&tl, (short)F_WRLCK, (short)0, 18, 0);
compare_lock(&tl, (short)F_WRLCK, (short)0, 18, 2, parent_pid);
/*
* Test to make sure the rest of the file is unlocked
*/
do_test(&tl, (short)F_WRLCK, (short)0, 20, 0);
compare_lock(&tl, (short)F_UNLCK, (short)0, 20, 0, 0);
/*
* remove all the locks set above.
*/
unlock_file();
tst_resm(TINFO, "Exit block 5");
/* //block6: */
tst_resm(TINFO, "Enter block 6");
/*
* Set a write lock in the middle of the file and a read
* lock that overlaps the end
*/
if (do_lock(F_SETLK, (short)F_WRLCK, (short)0, 10, 5) < 0)
tst_resm(TFAIL | TERRNO, "fcntl on file failed");
/*
* Set a read lock on the whole file
*/
if (do_lock(F_SETLK, (short)F_RDLCK, (short)0, 13, 5) < 0)
tst_resm(TFAIL | TERRNO, "fcntl on file failed");
/*
* Test the write lock
*/
do_test(&tl, (short)F_WRLCK, (short)0, 0, 0);
compare_lock(&tl, (short)F_WRLCK, (short)0, 10, 3, parent_pid);
/*
* Test the read lock
*/
do_test(&tl, (short)F_WRLCK, (short)0, 13, 0);
compare_lock(&tl, (short)F_RDLCK, (short)0, 13, 5, parent_pid);
/*
* Test to make sure the rest of the file is unlocked
*/
do_test(&tl, (short)F_WRLCK, (short)0, 18, 0);
compare_lock(&tl, (short)F_UNLCK, (short)0, 18, 0, 0);
/*
* remove all the locks set above
*/
unlock_file();
tst_resm(TINFO, "Exit block 6");
/* //block7: */
tst_resm(TINFO, "Enter block 7");
/*
* Set a write lock in the middle of the file and a read
* lock starting at the last byte of the write lock
*/
if (do_lock(F_SETLK, (short)F_WRLCK, (short)0, 10, 5) < 0)
tst_resm(TFAIL | TERRNO, "fcntl on file failed");
/*
* Set a read lock on the whole file.
*/
if (do_lock(F_SETLK, (short)F_RDLCK, (short)0, 14, 5) < 0)
tst_resm(TFAIL | TERRNO, "fcntl on file failed");
/*
* Test write lock
*/
do_test(&tl, (short)F_WRLCK, (short)0, 0, 0);
compare_lock(&tl, (short)F_WRLCK, (short)0, 10, 4, parent_pid);
/*
* Test the read lock
*/
do_test(&tl, (short)F_WRLCK, (short)0, 14, 0);
compare_lock(&tl, (short)F_RDLCK, (short)0, 14, 5, parent_pid);
/*
* Test to make sure the end of the file is unlocked
*/
do_test(&tl, (short)F_WRLCK, (short)0, 19, 0);
compare_lock(&tl, (short)F_UNLCK, (short)0, 19, 0, 0);
/*
* remove all the locks set above
*/
unlock_file();
tst_resm(TINFO, "Exit block 7");
/* //block8: */
tst_resm(TINFO, "Enter block 8");
/*
* Set a write lock in the middle of the file and a read
* lock that starts just after the last byte of the
* write lock.
*/
if (do_lock(F_SETLK, (short)F_WRLCK, (short)0, 10, 5) < 0)
tst_resm(TFAIL | TERRNO, "fcntl on file failed");
/*
* Set a read lock on the whole file
*/
if (do_lock(F_SETLK, (short)F_RDLCK, (short)0, 15, 5) < 0)
tst_resm(TFAIL | TERRNO, "fcntl on file failed");
/*
* Test the write lock
*/
do_test(&tl, (short)F_WRLCK, (short)0, 0, 0);
compare_lock(&tl, (short)F_WRLCK, (short)0, 10, 5, parent_pid);
/*
* Test the read lock
*/
do_test(&tl, (short)F_WRLCK, (short)0, 15, 0);
compare_lock(&tl, (short)F_RDLCK, (short)0, 15, 5, parent_pid);
/*
* Test to make sure the rest of the file is unlocked
*/
do_test(&tl, (short)F_WRLCK, (short)0, 20, 0);
compare_lock(&tl, (short)F_UNLCK, (short)0, 20, 0, 0);
/*
* remove all the locks set above
*/
unlock_file();
tst_resm(TINFO, "Exit block 8");
/* //block9: */
tst_resm(TINFO, "Enter block 9");
/*
* Set a write lock at the middle of the file and a read
* lock that starts past the end of the write lock.
*/
if (do_lock(F_SETLK, (short)F_WRLCK, (short)0, 10, 5) < 0)
tst_resm(TFAIL | TERRNO, "fcntl on file failed");
if (do_lock(F_SETLK, (short)F_RDLCK, (short)0, 16, 5) < 0)
tst_resm(TFAIL | TERRNO, "fcntl on file failed");
/*
* Test the write lock
*/
do_test(&tl, (short)F_WRLCK, (short)0, 0, 0);
compare_lock(&tl, (short)F_WRLCK, (short)0, 10, 5, parent_pid);
/*
* Test that byte in between is unlocked
*/
do_test(&tl, (short)F_WRLCK, (short)0, 15, 1);
compare_lock(&tl, (short)F_UNLCK, (short)0, 15, 1, 0);
/*
* Test the read lock
*/
do_test(&tl, (short)F_WRLCK, (short)0, 16, 0);
compare_lock(&tl, (short)F_RDLCK, (short)0, 16, 5, parent_pid);
/*
* Test to make sure the rest of the file is unlocked
*/
do_test(&tl, (short)F_WRLCK, (short)0, 21, 0);
compare_lock(&tl, (short)F_UNLCK, (short)0, 21, 0, 0);
/*
* remove all the locks set above
*/
unlock_file();
tst_resm(TINFO, "Exit block 9");
stop_child();
SAFE_CLOSE(cleanup, fd);
}
cleanup();
tst_exit();
}