/*
* LTlock.c -- Lsof Test locking tests
*
* V. Abell
* Purdue University
*/
/*
* Copyright 2002 Purdue Research Foundation, West Lafayette, Indiana
* 47907. All rights reserved.
*
* Written by V. Abell.
*
* This software is not subject to any license of the American Telephone
* and Telegraph Company or the Regents of the University of California.
*
* Permission is granted to anyone to use this software for any purpose on
* any computer system, and to alter it and redistribute it freely, subject
* to the following restrictions:
*
* 1. Neither the authors nor Purdue University are responsible for any
* consequences of the use of this software.
*
* 2. The origin of this software must not be misrepresented, either by
* explicit claim or by omission. Credit to the authors and Purdue
* University must appear in documentation and sources.
*
* 3. Altered versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
*
* 4. This notice may not be removed or altered.
*/
#ifndef lint
static char copyright[] =
"@(#) Copyright 2002 Purdue Research Foundation.\nAll rights reserved.\n";
#endif
#include "LsofTest.h"
#include "lsof_fields.h"
#if defined(LT_DIAL_aix)
/*
* AIX-specific items
*/
#define USE_FCNTL
#endif /* defined(LT_DIAL_aix) */
#if defined(LT_DIAL_bsdi)
/*
* BSDI-specific items
*/
#define USE_FCNTL
#endif /* defined(LT_DIAL_bsdi) */
#if defined(LT_DIAL_darwin)
/*
* Darwin-specific items
*/
/*
* There is no Darwin USE_* definition, because lock support in lsof for
* Darwin is inadequate for this test.
*/
#endif /* defined(LT_DIAL_darwin) */
#if defined(LT_DIAL_du)
/*
* DEC_OSF/1|Digital_UNIX|Tru64_UNIX-specific items
*/
#define USE_FCNTL
#endif /* defined(LT_DIAL_du) */
#if defined(LT_DIAL_freebsd)
/*
* FreeBSD-specific items
*/
#define USE_FCNTL
#endif /* defined(LT_DIAL_freebsd) */
#if defined(LT_DIAL_linux)
/*
* Linux-specific items
*/
#define USE_FCNTL
#endif /* defined(LT_DIAL_linux) */
#if defined(LT_DIAL_netbsd)
/*
* NetBSD-specific items
*/
#define USE_FCNTL
#endif /* defined(LT_DIAL_netbsd) */
#if defined(LT_DIAL_openbsd)
/*
* OpenBSD-specific items
*/
#define USE_FCNTL
#endif /* defined(LT_DIAL_openbsd) */
#if defined(LT_DIAL_hpux)
/*
* HP-UX-specific items
*/
#define USE_FCNTL
#endif /* defined(LT_DIAL_hpux) */
#if defined(LT_DIAL_ns)
/*
* NEXTSTEP-specific items
*/
#define USE_FLOCK
#endif /* defined(LT_DIAL_ns) */
#if defined(LT_DIAL_osr)
/*
* OSR-specific items
*/
#define USE_FCNTL
#endif /* defined(LT_DIAL_osr) */
#if defined(LT_DIAL_ou)
/*
* OpenUNIX-specific items
*/
#define USE_FCNTL
#endif /* defined(LT_DIAL_ou) */
#if defined(LT_DIAL_openbsd)
/*
* OpenBSD-specific items
*/
#define USE_FCNTL
#endif /* defined(LT_DIAL_openbsd) */
#if defined(LT_DIAL_solaris)
/*
* Solaris-specific items
*/
#define USE_FCNTL
#endif /* defined(solaris) */
#if defined(LT_DIAL_uw)
/*
* UnixWare-specific items
*/
#define USE_FCNTL
#endif /* defined(LT_DIAL_uw) */
#if !defined(USE_FLOCK) && !defined(USE_FCNTL)
/*
* Here begins the version of this program for dialects that don't support
* flock() or fcntl() locking.
*/
/*
* Main program for dialects that don't support flock() of fcntl() locking.
*/
int
main(argc, argv)
int argc; /* argument count */
char *argv[]; /* arguments */
{
char *pn; /* program name */
/*
* Get program name and issue error message.
*/
if ((pn = (char *)strrchr(argv[0], '/')))
pn++;
else
pn = argv[0];
(void) printf("%s ... %s\n", pn, LT_DONT_DO_TEST);
return(0);
}
#else /* defined(USE_FLOCK) || defined(USE_FCNTL) */
/*
* Local definitions
*/
#define FULL_EX_LOCK 0 /* get a full file exclusive lock */
#define FULL_SH_LOCK 1 /* get a full file shared lock */
#define PART_EX_LOCK 2 /* get a partial file exclusive lock */
#define PART_SH_LOCK 3 /* get a partial file shared lock */
/*
* Globals
*/
int Fd = -1; /* test file descriptor; open if >= 0 */
pid_t MyPid = (pid_t)0; /* PID of this process */
char *Path = (char *)NULL; /* test file path; none if NULL */
char *Pn = (char *)NULL; /* program name */
/*
* Local function prototypes
*/
_PROTOTYPE(static void cleanup,(void));
_PROTOTYPE(static char *lkfile,(int ty));
_PROTOTYPE(static char *tstwlsof,(char *opt, char *xlk));
_PROTOTYPE(static char *unlkfile,(int ty));
/*
* Main program for dialects that support locking tests.
*/
int
main(argc, argv)
int argc; /* argument count */
char *argv[]; /* arguments */
{
char buf[2048]; /* temporary buffer */
char *em; /* error message pointer */
int ti; /* temporary index */
char *tcp; /* temporary character pointer */
int tlen; /* temporary length -- e.g., as
* returned by MkStrCpy() */
char *tstR = (char *)NULL; /* "R" lock test result */
char *tstr = (char *)NULL; /* "r" lock test result */
char *tstW = (char *)NULL; /* "W" lock test result */
char *tstw = (char *)NULL; /* "w" lock test result */
int xv = 0; /* exit value */
/*
* Get program name and PID, issue start message, and build space prefix.
*/
if ((Pn = strrchr(argv[0], '/')))
Pn++;
else
Pn = argv[0];
MyPid = getpid();
(void) printf("%s ... ", Pn);
(void) fflush(stdout);
(void) PrtMsg((char *)NULL, Pn);
/*
* Process arguments.
*/
if (ScanArg(argc, argv, "hp:", Pn))
xv = 1;
if (xv || LTopt_h) {
(void) PrtMsg ("usage: [-h] [-p path]", Pn);
(void) PrtMsg (" -h print help (this panel)", Pn);
(void) PrtMsgX(" -p path define test file path", Pn, cleanup,
xv);
}
/*
* See if lsof can be executed and can access kernel memory.
*/
if ((em = IsLsofExec()))
(void) PrtMsgX(em, Pn, cleanup, 1);
if ((em = CanRdKmem()))
(void) PrtMsgX(em, Pn, cleanup, 1);
/*
* If a path was supplied in an "-p path" option, use it. Otherwise construct
* a path in the CWD.
*/
if (!(Path = LTopt_p)) {
(void) snprintf(buf, sizeof(buf), "./config.LTlock%ld",
(long)MyPid);
buf[sizeof(buf) - 1] = '\0';
Path = MkStrCpy(buf, &tlen);
}
/*
* Fill buffer for writing to the test file.
*/
for (ti = 0; ti < sizeof(buf); ti++) {
buf[ti] = (char)(ti & 0xff);
}
/*
* Open a new test file at the specified path.
*/
(void) unlink(Path);
if ((Fd = open(Path, O_RDWR|O_CREAT, 0600)) < 0) {
(void) fprintf(stderr, "ERROR!!! can't open %s\n", Path);
print_file_error:
MsgStat = 1;
(void) snprintf(buf, sizeof(buf) - 1, " Errno %d: %s",
errno, strerror(errno));
buf[sizeof(buf) - 1] = '\0';
(void) PrtMsgX(buf, Pn, cleanup, 1);
}
/*
* Write a buffer load at the beginning of the file.
*/
if (write(Fd, buf, sizeof(buf)) != sizeof(buf)) {
(void) fprintf(stderr,
"ERROR!!! can't write %d bytes to the beginning of %s\n",
(int)sizeof(buf), Path);
goto print_file_error;
}
/*
* Fsync() the file.
*/
if (fsync(Fd)) {
(void) fprintf(stderr, "ERROR!!! can't fsync %s\n", Path);
goto print_file_error;
}
/*
* Quit (with a hint) if the test file is on an NFS file system.
*/
if (!tstwlsof("-wNa", " ")) {
(void) printf("ERROR!!! %s is NFS-mounted.\n", Path);
MsgStat = 1;
(void) PrtMsg ("Lsof can't report lock information on files that", Pn);
(void) PrtMsg ("are located on file systems mounted from a remote", Pn);
(void) PrtMsg ("NFS server.\n", Pn);
(void) PrtMsg ("Hint: try using \"-p path\" to supply a path in a", Pn);
(void) PrtMsg ("non-NFS file system.\n", Pn);
(void) PrtMsgX("See 00FAQ and 00TEST for more information.", Pn,
cleanup, 1);
}
/*
* Get an exclusive lock on the entire file and test it with lsof.
*/
if ((em = lkfile(FULL_EX_LOCK)))
(void) PrtMsgX(em, Pn, cleanup, 1);
if ((tstW = tstwlsof("-w", "W")))
(void) PrtMsg(tstW, Pn);
/*
* Get a shared lock on the entire file and test it with lsof.
*/
if ((em = unlkfile(FULL_EX_LOCK)))
(void) PrtMsgX(em, Pn, cleanup, 1);
if ((em = lkfile(FULL_SH_LOCK)))
(void) PrtMsgX(em, Pn, cleanup, 1);
if ((tstR = tstwlsof("-w", "R")))
(void) PrtMsg(tstR, Pn);
# if defined(USE_FLOCK)
/*
* If using flock(), skip the byte lock tests.
*/
tstr = tstw = (char *)NULL;
# endif /* defined(USE_FLOCK) */
# if defined(USE_FCNTL)
/*
* If using fcntl(), do exclusive and shared byte lock tests,
*/
if ((em = unlkfile(FULL_SH_LOCK)))
(void) PrtMsgX(em, Pn, cleanup, 1);
if ((em = lkfile(PART_EX_LOCK)))
(void) PrtMsgX(em, Pn, cleanup, 1);
if ((tstw = tstwlsof("-w", "w")))
(void) PrtMsg(tstw, Pn);
if ((em = unlkfile(PART_EX_LOCK)))
(void) PrtMsgX(em, Pn, cleanup, 1);
if ((em = lkfile(PART_SH_LOCK)))
(void) PrtMsgX(em, Pn, cleanup, 1);
if ((tstr = tstwlsof("-w", "r")))
(void) PrtMsg(tstr, Pn);
# endif /* defined(USE_FCNTL) */
/*
* Compute exit value and exit.
*/
if (tstr || tstR || tstw || tstW) {
tcp = (char *)NULL;
xv = 1;
} else {
tcp = "OK";
xv = 0;
}
(void) PrtMsgX(tcp, Pn, cleanup, xv);
return(0);
}
/*
* cleanup() -- release resources
*/
static void
cleanup()
{
if (Fd >= 0) {
(void) close(Fd);
Fd = -1;
if (Path) {
(void) unlink(Path);
Path = (char *)NULL;
}
}
}
/*
* lkfile() -- lock the test file
*/
static char *
lkfile(ty)
int ty; /* a *_*_LOCK requested */
{
char buf[2048]; /* temporary buffer */
int ti; /* temporary integer */
# if defined(USE_FLOCK)
int flf; /* flock() function */
# endif /* defined(USE_FLOCK) */
# if defined(USE_FCNTL)
struct flock fl; /* flock control structure */
/*
* Check fcntl() lock request.
*/
(void) memset((void *)&fl, 0, sizeof(fl));
switch(ty) {
case FULL_EX_LOCK:
fl.l_type = F_WRLCK;
break;
case FULL_SH_LOCK:
fl.l_type = F_RDLCK;
break;
case PART_EX_LOCK:
fl.l_type = F_WRLCK;
fl.l_len = (off_t)1;
break;
case PART_SH_LOCK:
fl.l_type = F_RDLCK;
fl.l_len = (off_t)1;
break;
default:
(void) snprintf(buf, sizeof(buf) - 1,
"ERROR!!! unknown lock type: %d", ty);
buf[sizeof(buf) - 1] = '\0';
return(MkStrCpy(buf, &ti));
}
/*
* Lock test file with fcntl().
*/
if (fcntl(Fd, F_SETLK, &fl) != -1)
return((char *)NULL);
(void) snprintf(buf, sizeof(buf) - 1, "ERROR!!! fcntl() lock error: %s",
strerror(errno));
buf[sizeof(buf) - 1] = '\0';
return(MkStrCpy(buf, &ti));
# endif /* defined(USE_FCNTL) */
# if defined(USE_FLOCK)
/*
* Check flock() lock request.
*/
switch(ty) {
case FULL_EX_LOCK:
flf = LOCK_EX;
break;
case FULL_SH_LOCK:
flf = LOCK_SH;
break;
case PART_EX_LOCK:
case PART_SH_LOCK:
return("ERROR!!! flock() doesn't support partial locks");
break;
default:
(void) snprintf(buf, sizeof(buf) - 1,
"ERROR!!! unknown flock() type: %d", ty);
buf[sizeof(buf) - 1] = '\0';
return(MkStrCpy(buf, &ti));
}
/*
* Acquire lock.
*/
if (!flock(Fd, flf))
return((char *)NULL);
(void) snprintf(buf, sizeof(buf) - 1,
"ERROR!!! flock() %s lock failed: %s",
(flf == LOCK_EX) ? "exclusive" : "shared",
strerror(errno));
buf[sizeof(buf) - 1] = '\0';
return(MkStrCpy(buf, &ti));
# endif /* defined(USE_FLOCK) */
}
/*
* tstwlsof() -- test the open file with lsof
*/
static char *
tstwlsof(opt, xlk)
char *opt; /* extra lsof options */
char *xlk; /* expected lock value */
{
char buf[2048]; /* temporary buffer */
LTfldo_t *cmdp; /* command pointer */
LTfldo_t *devp; /* device pointer */
char *cem; /* current error message pointer */
int ff = 0; /* file found status */
LTfldo_t *fop; /* field output pointer */
LTfldo_t *inop; /* inode number pointer */
LTfldo_t *lkp; /* lock pointer */
LTdev_t lsofdc; /* lsof device components */
int nf; /* number of fields */
LTfldo_t *nmp; /* file name pointer */
char *opv[4]; /* option vector for ExecLsof() */
char *pem = (char *)NULL; /* previous error message pointer */
pid_t pid; /* PID */
int pids = 0; /* PID found status */
struct stat sb; /* stat(2) buffer */
LTdev_t stdc; /* stat(2) device components */
char *tcp; /* temporary character pointer */
int ti; /* temporary integer */
LTfldo_t *typ; /* file type pointer */
/*
* Make sure there is an expected lock value.
*/
if (!xlk || !*xlk)
(void) PrtMsgX("ERROR!!! no expected lock value", Pn, cleanup, 1);
/*
* Get test file's information.
*/
if (stat(Path, &sb)) {
(void) snprintf(buf, sizeof(buf) - 1,
"ERROR!!! can't stat(2) %s: %s", Path, strerror(errno));
buf[sizeof(buf) - 1] = '\0';
(void) PrtMsgX(buf, Pn, cleanup, 1);
}
/*
* Extract components from test file's device number.
*/
if ((cem = ConvStatDev(&sb.st_dev, &stdc)))
(void) PrtMsgX(cem, Pn, cleanup, 1);
/*
* Complete the option vector and start lsof execution.
*/
ti = 0;
if (opt && *opt)
opv[ti++] = opt;
#if defined(USE_LSOF_C_OPT)
opv[ti++] = "-C";
#endif /* defined(USE_LSOF_C_OPT) */
opv[ti++] = Path;
opv[ti] = (char *)NULL;
if ((cem = ExecLsof(opv)))
return(cem);
/*
* Read lsof output.
*/
while (!ff && (fop = RdFrLsof(&nf, &cem))) {
if (cem) {
if (pem)
(void) PrtMsg(pem, Pn);
return(cem);
}
switch (fop->ft) {
case LSOF_FID_PID:
/*
* This is a process information line.
*/
pid = (pid_t)atoi(fop->v);
pids = 1;
cmdp = (LTfldo_t *)NULL;
for (fop++, ti = 1; ti < nf; fop++, ti++) {
switch (fop->ft) {
case LSOF_FID_CMD:
cmdp = fop;
break;
}
}
if (!cmdp || (pid != MyPid))
pids = 0;
break;
case LSOF_FID_FD:
/*
* This is a file descriptor line. Make sure its number matches the
* test file's descriptor number.
*
* Scan for lock and name fields.
*/
if (!pids)
break;
for (ti = 0, tcp = fop->v; *tcp; tcp++) {
/*
* Convert file descriptor to a number.
*/
if (*tcp == ' ')
continue;
if (((int)*tcp < (int)'0') || ((int)*tcp > (int)'9')) {
ti = -1;
break;
}
ti = (ti * 10) + (int)*tcp - (int)'0';
}
if (Fd != ti)
break;
devp = inop = lkp = nmp = (LTfldo_t *)NULL;
for (fop++, ti = 1; ti < nf; fop++, ti++) {
switch(fop->ft) {
case LSOF_FID_DEVN:
devp = fop;
break;
case LSOF_FID_INODE:
inop = fop;
break;
case LSOF_FID_LOCK:
lkp = fop;
break;
case LSOF_FID_NAME:
nmp = fop;
break;
case LSOF_FID_TYPE:
typ = fop;
break;
}
}
/*
* Check the results of the file descriptor field scan.
*
* (Don't compare path names because of symbolic link interference.)
*/
if (!devp || !inop || !nmp || !typ)
break;
if (strcasecmp(typ->v, "reg") && strcasecmp(typ->v, "vreg"))
break;
if (ConvLsofDev(devp->v, &lsofdc))
break;
if ((stdc.maj != lsofdc.maj)
|| (stdc.min != lsofdc.min)
|| (stdc.unit != lsofdc.unit))
break;
(void) snprintf(buf, sizeof(buf) - 1, "%u",
(unsigned int)sb.st_ino);
buf[sizeof(buf) - 1] = '\0';
if (strcmp(inop->v, buf))
break;
/*
* The specified file has been located. Check its lock status.
*/
ff = 1;
if (!lkp || strcmp(lkp->v, xlk)) {
if (pem)
(void) PrtMsg(pem, Pn);
(void) snprintf(buf, sizeof(buf) - 1,
"lock mismatch: expected %s, got \"%s\"", xlk,
lkp ? lkp->v : "(none)");
pem = MkStrCpy(buf, &ti);
}
break;
}
}
(void) StopLsof();
if (!ff) {
if (pem)
(void) PrtMsg(pem, Pn);
(void) snprintf(buf, sizeof(buf) - 1,
"lock test file %s not found by lsof", Path);
buf[sizeof(buf) - 1] = '\0';
return(MkStrCpy(buf, &ti));
}
return(pem);
}
/*
* unlkfile() -- unlock the test file
*/
static char *
unlkfile(ty)
int ty; /* current *_*_LOCK lock typ */
{
char buf[2048]; /* temporary buffer */
int ti; /* temporary integer */
# if defined(USE_FCNTL)
struct flock fl; /* flock control structure */
/*
* Check current fcntl() lock type.
*/
(void) memset((void *)&fl, 0, sizeof(fl));
switch(ty) {
case FULL_EX_LOCK:
case FULL_SH_LOCK:
break;
case PART_EX_LOCK:
case PART_SH_LOCK:
fl.l_len = (off_t)1;
break;
default:
(void) snprintf(buf, sizeof(buf) - 1,
"ERROR!!! unknown unlock type: %d", ty);
buf[sizeof(buf) - 1] = '\0';
return(MkStrCpy(buf, &ti));
}
/*
* Unlock test file with fcntl().
*/
fl.l_type = F_UNLCK;
if (fcntl(Fd, F_SETLK, &fl) != -1)
return((char *)NULL);
(void) snprintf(buf, sizeof(buf) - 1, "ERROR!!! fcntl() unlock error: %s",
strerror(errno));
buf[sizeof(buf) - 1] = '\0';
return(MkStrCpy(buf, &ti));
# endif /* defined(USE_FCNTL) */
# if defined(USE_FLOCK)
/*
* Check current flock() lock type.
*/
switch(ty) {
case FULL_EX_LOCK:
case FULL_SH_LOCK:
break;
default:
(void) snprintf(buf, sizeof(buf) - 1,
"ERROR!!! unknown unlock type: %s", ty);
buf[sizeof(buf) - 1] = '\0';
return(MkStrCpy(buf, &ti));
}
/*
* Unlock file with flock().
*/
if (!flock(Fd, LOCK_UN))
return((char *)NULL);
(void) snprintf(buf, sizeof(buf) - 1, "ERROR!!! flock() unlock error: %s",
strerror(errno));
return(MkStrCpy(buf, &ti));
# endif /* defined(USE_FLOCK) */
}
#endif /* !defined(USE_FLOCK) && !defined(USE_FCNTL) */