JehanneOS/newlib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Importing Egor's testsuite.

Browse Source
This commit is contained in:
Christopher Faylor
2000-09-03 03:52:30 +00:00
parent 312a668a22
commit 42f03f6757
31 changed files with 6749 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
winsup/testsuite/libltp/include/dataascii.h Normal file
View File

@ -0,0 +1,65 @@
/*
* Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it would be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* Further, this software is distributed without any warranty that it is
* free of the rightful claim of any third person regarding infringement
* or the like. Any license provided herein, whether implied or
* otherwise, applies only to this software file. Patent licenses, if
* any, provided herein do not apply to combinations of this program with
* other software, or any other product whatsoever.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write the Free Software Foundation, Inc., 59
* Temple Place - Suite 330, Boston MA 02111-1307, USA.
*
* Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
* Mountain View, CA 94043, or:
*
* http://www.sgi.com
*
* For further information regarding this notice, see:
*
* http://oss.sgi.com/projects/GenInfo/NoticeExplan/
*/
#ifndef _DATAASCII_H_
#define _DATAASCII_H_
/***********************************************************************
* int dataasciigen(listofchars, buffer, size, offset)
*
* This function fills buffer with ascii characters.
* The ascii characters are obtained from listofchars or the CHARS array
* if listofchars is NULL.
* Each char is selected by an index. The index is the remainder
* of count divided by the array size.
* This method allows more than one process to write to a location
* in a file without corrupting it for another process' point of view.
*
* The return value will be the number of character written in buffer
* (size).
*
***********************************************************************/
int dataasciigen(char *, char *, int, int);
/***********************************************************************
* int dataasciichk(listofchars, buffer, size, count, errmsg)
*
* This function checks the contents of a buffer produced by
* dataasciigen.
*
* return values:
* >= 0 : error at character count
* < 0 : no error
***********************************************************************/
int dataasciichk(char *, char *, int, int, char**);
#endif

44
winsup/testsuite/libltp/include/databin.h Normal file
View File

@ -0,0 +1,44 @@
#ifndef _DATABIN_H_
#define _DATABIN_H_
/*******************************************************************************
* NAME
* databingen - fill a buffer with a data pattern
*
* SYNOPSIS
* (void) databingen(mode, buffer, bsize, offset)
* int mode;
* char *buffer;
* int bsize;
* int offset;
*
* DESCRIPTION
* datagen fills the buffer pointed to by 'buffer' with 'bsize' bytes
* of data of the form indicated by 'mode'.
* All modes (expect r -random) are file offset based.
* This allows more than process to do writing to the file without
* corrupting it if the same modes were used.
* They data modes to choose from, these are:
*
* 'a' - writes an alternating bit pattern (i.e. 0x5555555...)
*
* 'c' - writes a checkerboard pattern (i.e. 0xff00ff00ff00...)
*
* 'C' - writes counting pattern (i.e. 0 - 07, 0 - 07, ...);
*
* 'o' - writes all bits set (i.e. 0xffffffffffffff...)
*
* 'z' - writes all bits cleared (i.e. 0x000000000...);
*
* 'r' - writes random integers
*
* RETURN VALUE
* None
*
*******************************************************************************/
void databingen( int mode, unsigned char *buffer, int bsize, int offset );
void databinchedk( int mode, unsigned char *buffer, int bsize, int offset, char **errmsg);
#endif

40
winsup/testsuite/libltp/include/file_lock.h Normal file
View File

@ -0,0 +1,40 @@
/*
* Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it would be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* Further, this software is distributed without any warranty that it is
* free of the rightful claim of any third person regarding infringement
* or the like. Any license provided herein, whether implied or
* otherwise, applies only to this software file. Patent licenses, if
* any, provided herein do not apply to combinations of this program with
* other software, or any other product whatsoever.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write the Free Software Foundation, Inc., 59
* Temple Place - Suite 330, Boston MA 02111-1307, USA.
*
* Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
* Mountain View, CA 94043, or:
*
* http://www.sgi.com
*
* For further information regarding this notice, see:
*
* http://oss.sgi.com/projects/GenInfo/NoticeExplan/
*/
#ifndef _FILE_LOCK_H_
#define _FILE_LOCK_H_
extern char Fl_syscall_str[128];
int file_lock( int , int, char ** );
int record_lock( int , int , int , int , char ** );
#endif /* _FILE_LOCK_H_ */

63
winsup/testsuite/libltp/include/forker.h Normal file
View File

@ -0,0 +1,63 @@
/*
* Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it would be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* Further, this software is distributed without any warranty that it is
* free of the rightful claim of any third person regarding infringement
* or the like. Any license provided herein, whether implied or
* otherwise, applies only to this software file. Patent licenses, if
* any, provided herein do not apply to combinations of this program with
* other software, or any other product whatsoever.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write the Free Software Foundation, Inc., 59
* Temple Place - Suite 330, Boston MA 02111-1307, USA.
*
* Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
* Mountain View, CA 94043, or:
*
* http://www.sgi.com
*
* For further information regarding this notice, see:
*
* http://oss.sgi.com/projects/GenInfo/NoticeExplan/
*/
#ifndef _FORKER_H_
#define _FORKER_H_
#define FORKER_MAX_PIDS 4098
extern int Forker_pids[FORKER_MAX_PIDS]; /* holds pids of forked processes */
extern int Forker_npids; /* number of entries in Forker_pids */
/*
* This function will fork and the parent will exit zero and
* the child will return. This will orphan the returning process
* putting it in the background.
*/
int background( char * );
/*
* Forker will fork ncopies-1 copies of self.
*
* arg 1: Number of copies of the process to be running after return.
* This value minus one is the number of forks performed.
* arg 2: mode: 0 - all children are first generation descendents.
* 1 - each subsequent child is a descendent of another
* descendent, resulting in only one direct descendent of the
* parent and each other child is a child of another child in
* relation to the parent.
* arg 3: prefix: string to preceed any error messages. A value of NULL
* results in no error messages on failure.
* returns: returns to parent the number of children forked.
*/
int forker( int , int , char * );
#endif /* _FORKER_H_ */

73
winsup/testsuite/libltp/include/open_flags.h Normal file
View File

@ -0,0 +1,73 @@
/*
* Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it would be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* Further, this software is distributed without any warranty that it is
* free of the rightful claim of any third person regarding infringement
* or the like. Any license provided herein, whether implied or
* otherwise, applies only to this software file. Patent licenses, if
* any, provided herein do not apply to combinations of this program with
* other software, or any other product whatsoever.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write the Free Software Foundation, Inc., 59
* Temple Place - Suite 330, Boston MA 02111-1307, USA.
*
* Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
* Mountain View, CA 94043, or:
*
* http://www.sgi.com
*
* For further information regarding this notice, see:
*
* http://oss.sgi.com/projects/GenInfo/NoticeExplan/
*/
#ifndef _OPEN_FLAGS_H_
#define _OPEN_FLAGS_H_
/***********************************************************************
* This function attempts to convert open flag bits into human readable
* symbols (i.e. O_TRUNC). If there are more than one symbol,
* the <sep> string will be placed as a separator between symbols.
* Commonly used separators would be a comma "," or pipe "|".
* If <mode> is one and not all <openflags> bits can be converted to
* symbols, the "UNKNOWN" symbol will be added to return string.
*
* Return Value
* openflags2symbols will return the indentified symbols.
* If no symbols are recognized the return value will be a empty
* string or the "UNKNOWN" symbol.
*
* Limitations
* Currently (05/96) all known symbols are coded into openflags2symbols.
* If new open flags are added this code will have to updated
* to know about them or they will not be recognized.
*
* The Open_symbols must be large enough to hold all possible symbols
* for a given system.
*
***********************************************************************/
char *openflags2symbols( int, char *, int );
/***********************************************************************
* This function will take a string of comma separated open flags symbols
* and translate them into an open flag bitmask.
* If any symbol is not valid, -1 is returned. On this error condition
* the badname pointer is updated if not NULL. badname will point
* to the beginning location of where the invalid symbol was found.
* string will be returned unchanged.
*
* A signal received while parsing string could cause the string to
* contain a NULL character in the middle of it.
*
***********************************************************************/
int parse_open_flags( char *, char ** );
#endif

90
winsup/testsuite/libltp/include/pattern.h Normal file
View File

@ -0,0 +1,90 @@
/*
* Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it would be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* Further, this software is distributed without any warranty that it is
* free of the rightful claim of any third person regarding infringement
* or the like. Any license provided herein, whether implied or
* otherwise, applies only to this software file. Patent licenses, if
* any, provided herein do not apply to combinations of this program with
* other software, or any other product whatsoever.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write the Free Software Foundation, Inc., 59
* Temple Place - Suite 330, Boston MA 02111-1307, USA.
*
* Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
* Mountain View, CA 94043, or:
*
* http://www.sgi.com
*
* For further information regarding this notice, see:
*
* http://oss.sgi.com/projects/GenInfo/NoticeExplan/
*/
#ifndef _PATTERN_H_
#define _PATTERN_H_
/*
* pattern_check(buf, buflen, pat, patlen, patshift)
*
* Check a buffer of length buflen against repeated occurrances of
* a pattern whose length is patlen. Patshift can be used to rotate
* the pattern by patshift bytes to the left.
*
* Patshift may be greater than patlen, the pattern will be rotated by
* (patshift % patshift) bytes.
*
* pattern_check returns -1 if the buffer does not contain repeated
* occurrances of the indicated pattern (shifted by patshift).
*
* The algorithm used to check the buffer relies on the fact that buf is
* supposed to be repeated copies of pattern. The basic algorithm is
* to validate the first patlen bytes of buf against the pat argument
* passed in - then validate the next patlen bytes against the 1st patlen
* bytes - the next (2*patlen) bytes against the 1st (2*pathen) bytes, and
* so on. This algorithm only works when the assumption of a buffer full
* of repeated copies of a pattern holds, and gives MUCH better results
* then walking the buffer byte by byte.
*
* Performance wise, It appears to be about 5% slower than doing a straight
* memcmp of 2 buffers, but the big win is that it does not require a
* 2nd comparison buffer, only the pattern.
*/
int pattern_check( char * , int , char * , int , int );
/*
* pattern_fill(buf, buflen, pat, patlen, patshift)
*
* Fill a buffer of length buflen with repeated occurrances of
* a pattern whose length is patlen. Patshift can be used to rotate
* the pattern by patshift bytes to the left.
*
* Patshift may be greater than patlen, the pattern will be rotated by
* (patshift % patlen) bytes.
*
* If buflen is not a multiple of patlen, a partial pattern will be written
* in the last part of the buffer. This implies that a buffer which is
* shorter than the pattern length will receive only a partial pattern ...
*
* pattern_fill always returns 0 - no validation of arguments is done.
*
* The algorithm used to fill the buffer relies on the fact that buf is
* supposed to be repeated copies of pattern. The basic algorithm is
* to fill the first patlen bytes of buf with the pat argument
* passed in - then copy the next patlen bytes with the 1st patlen
* bytes - the next (2*patlen) bytes with the 1st (2*pathen) bytes, and
* so on. This algorithm only works when the assumption of a buffer full
* of repeated copies of a pattern holds, and gives MUCH better results
* then filling the buffer 1 byte at a time.
*/
int pattern_fill( char * , int , char * , int , int );
#endif

45
winsup/testsuite/libltp/include/random_range.h Normal file
View File

@ -0,0 +1,45 @@
/*
* Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it would be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* Further, this software is distributed without any warranty that it is
* free of the rightful claim of any third person regarding infringement
* or the like. Any license provided herein, whether implied or
* otherwise, applies only to this software file. Patent licenses, if
* any, provided herein do not apply to combinations of this program with
* other software, or any other product whatsoever.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write the Free Software Foundation, Inc., 59
* Temple Place - Suite 330, Boston MA 02111-1307, USA.
*
* Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
* Mountain View, CA 94043, or:
*
* http://www.sgi.com
*
* For further information regarding this notice, see:
*
* http://oss.sgi.com/projects/GenInfo/NoticeExplan/
*/
#ifndef _RANDOM_RANGE_H_
#define _RANDOM_RANGE_H_
int parse_ranges ( char *, int, int, int, int (*)(), char **, char ** );
int range_min ( char *, int );
int range_max ( char *, int );
int range_mult ( char *, int );
long random_range ( int, int, int, char ** );
long random_rangel ( long, long, long, char ** );
long long random_rangell ( long long, long long, long long, char ** );
void random_range_seed( long );
long random_bit ( long );
#endif

12
winsup/testsuite/libltp/include/rmobj.h Normal file
View File

@ -0,0 +1,12 @@
#ifndef _RMOBJ_H_
#define _RMOBJ_H_
/*
* rmobj() - Remove the specified object. If the specified object is a
* directory, recursively remove everything inside of it. If
* there are any problems, set errmsg (if it is not NULL) and
* return -1. Otherwise return 0.
*/
int rmobj( char *object , char **errmesg );
#endif

36
winsup/testsuite/libltp/include/search_path.h Normal file
View File

@ -0,0 +1,36 @@
/*
* Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it would be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* Further, this software is distributed without any warranty that it is
* free of the rightful claim of any third person regarding infringement
* or the like. Any license provided herein, whether implied or
* otherwise, applies only to this software file. Patent licenses, if
* any, provided herein do not apply to combinations of this program with
* other software, or any other product whatsoever.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write the Free Software Foundation, Inc., 59
* Temple Place - Suite 330, Boston MA 02111-1307, USA.
*
* Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
* Mountain View, CA 94043, or:
*
* http://www.sgi.com
*
* For further information regarding this notice, see:
*
* http://oss.sgi.com/projects/GenInfo/NoticeExplan/
*/
/* $Id$ */
int search_path(char *cmd, char *res_path, int access_mode, int fullpath);

39
winsup/testsuite/libltp/include/str_to_bytes.h Normal file
View File

@ -0,0 +1,39 @@
/*
* Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it would be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* Further, this software is distributed without any warranty that it is
* free of the rightful claim of any third person regarding infringement
* or the like. Any license provided herein, whether implied or
* otherwise, applies only to this software file. Patent licenses, if
* any, provided herein do not apply to combinations of this program with
* other software, or any other product whatsoever.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write the Free Software Foundation, Inc., 59
* Temple Place - Suite 330, Boston MA 02111-1307, USA.
*
* Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
* Mountain View, CA 94043, or:
*
* http://www.sgi.com
*
* For further information regarding this notice, see:
*
* http://oss.sgi.com/projects/GenInfo/NoticeExplan/
*/
#ifndef _STR_TO_BYTES_
#define _STR_TO_BYTES_
int str_to_bytes ( char * );
long str_to_lbytes ( char * );
long long str_to_llbytes( char * );
#endif

48
winsup/testsuite/libltp/include/string_to_tokens.h Normal file
View File

@ -0,0 +1,48 @@
/*
* Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it would be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* Further, this software is distributed without any warranty that it is
* free of the rightful claim of any third person regarding infringement
* or the like. Any license provided herein, whether implied or
* otherwise, applies only to this software file. Patent licenses, if
* any, provided herein do not apply to combinations of this program with
* other software, or any other product whatsoever.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write the Free Software Foundation, Inc., 59
* Temple Place - Suite 330, Boston MA 02111-1307, USA.
*
* Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
* Mountain View, CA 94043, or:
*
* http://www.sgi.com
*
* For further information regarding this notice, see:
*
* http://oss.sgi.com/projects/GenInfo/NoticeExplan/
*/
#ifndef _STRING_TO_TOKENS_H_
#define _STRING_TO_TOKENS_H_
/*
* string_to_tokens()
*
* This function parses the string 'arg_string', placing pointers to
* the 'separator' separated tokens into the elements of 'arg_array'.
* The array is terminated with a null pointer.
*
* NOTE: This function uses strtok() to parse 'arg_string', and thus
* physically alters 'arg_string' by placing null characters where the
* separators originally were.
*/
int string_to_tokens(char *, char **, int, char *);
#endif

216
winsup/testsuite/libltp/include/test.h Normal file
View File

@ -0,0 +1,216 @@
/*
* Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it would be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* Further, this software is distributed without any warranty that it is
* free of the rightful claim of any third person regarding infringement
* or the like. Any license provided herein, whether implied or
* otherwise, applies only to this software file. Patent licenses, if
* any, provided herein do not apply to combinations of this program with
* other software, or any other product whatsoever.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write the Free Software Foundation, Inc., 59
* Temple Place - Suite 330, Boston MA 02111-1307, USA.
*
* Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
* Mountain View, CA 94043, or:
*
* http://www.sgi.com
*
* For further information regarding this notice, see:
*
* http://oss.sgi.com/projects/GenInfo/NoticeExplan/
*/
/* $Id$ */
#ifndef __TEST_H__
#define __TEST_H__
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#define TPASS 0 /* Test passed flag */
#define TFAIL 1 /* Test failed flag */
#define TBROK 2 /* Test broken flag */
#define TWARN 4 /* Test warning flag */
#define TRETR 8 /* Test retire flag */
#define TINFO 16 /* Test information flag */
#define TCONF 32 /* Test not appropriate for configuration flag */
/*
* To determine if you are on a Umk or Unicos system,
* use sysconf(_SC_CRAY_SYSTEM). But since _SC_CRAY_SYSTEM
* is not defined until 90, it will be define here if not already
* defined.
* if ( sysconf(_SC_CRAY_SYSTEM) == 1 )
* on UMK
* else # returned 0 or -1
* on Unicos
* This is only being done on CRAY systems.
*/
#ifdef CRAY
#ifndef _SC_CRAY_SYSTEM
#define _SC_CRAY_SYSTEM 140
#endif /* ! _SC_CRAY_SYSTEM */
#endif /* CRAY */
/*
* Ensure that NUMSIGS is defined.
* It should be defined in signal.h or sys/signal.h on
* UNICOS/mk and IRIX systems. On UNICOS systems,
* it is not defined, thus it is being set to UNICOS's NSIG.
* Note: IRIX's NSIG (signals are 1-(NSIG-1))
* is not same meaning as UNICOS/UMK's NSIG (signals 1-NSIG)
*/
#ifndef NUMSIGS
#define NUMSIGS NSIG
#endif
/* defines for unexpected signal setup routine (set_usig.c) */
#define FORK 1 /* SIGCLD is to be ignored */
#define NOFORK 0 /* SIGCLD is to be caught */
#define DEF_HANDLER 0 /* tells set_usig() to use default signal handler */
/*
* The following defines are used to control tst_res and t_result reporting.
*/
#define TOUTPUT "TOUTPUT" /* The name of the environment variable */
/* that can be set to one of the following */
/* strings to control tst_res output */
/* If not set, TOUT_VERBOSE_S is assumed */
#define TOUT_VERBOSE_S "VERBOSE" /* All test cases reported */
#define TOUT_CONDENSE_S "CONDENSE" /* ranges are used where identical messages*/
/* occur for sequential test cases */
#define TOUT_NOPASS_S "NOPASS" /* No pass test cases are reported */
#define TOUT_DISCARD_S "DISCARD" /* No output is reported */
#define TST_NOBUF "TST_NOBUF" /* The name of the environment variable */
/* that can be set to control whether or not */
/* tst_res will buffer output into 4096 byte */
/* blocks of output */
/* If not set, buffer is done. If set, no */
/* internal buffering will be done in tst_res */
/* t_result does not have internal buffering */
/*
* The following defines are used to control tst_tmpdir, tst_wildcard and t_mkchdir
*/
#define TDIRECTORY "TDIRECTORY" /* The name of the environment variable */
/* that if is set, the value (directory) */
/* is used by all tests as their working */
/* directory. tst_rmdir and t_rmdir will */
/* not attempt to clean up. */
/* This environment variable should only */
/* be set when doing system testing since */
/* tests will collide and break and fail */
/* because of setting it. */
#define TEMPDIR "/tmp" /* This is the default temporary directory. */
/* The environment variable TMPDIR is */
/* used prior to this valid by tempnam(3). */
/* To control the base location of the */
/* temporary directory, set the TMPDIR */
/* environment variable to desired path */
/*
* The following contains support for error message passing.
* See test_error.c for details.
*/
#define TST_ERR_MESG_SIZE 1023 /* max size of error message */
#define TST_ERR_FILE_SIZE 511 /* max size of module name used by compiler */
#define TST_ERR_FUNC_SIZE 127 /* max size of func name */
typedef struct {
int te_line; /* line where last error was reported. Use */
/* "__LINE__" and let compiler do the rest */
int te_level; /* If set, will prevent current stored */
/* error to not be overwritten */
char te_func[TST_ERR_FUNC_SIZE+1]; /* name of function of last error */
/* Name of function or NULL */
char te_file[TST_ERR_FILE_SIZE+1]; /* module of last error. Use */
/* "__FILE__" and let compiler do the rest */
char te_mesg[TST_ERR_MESG_SIZE+1]; /* string of last error */
} _TST_ERROR;
extern _TST_ERROR Tst_error; /* defined in test_error.c */
#if __STDC__
extern void tst_set_error(char *file, int line, char *func, char *fmt, ...);
#else
extern void tst_set_error();
#endif
extern void tst_clear_error();
/*
* The following define contains the name of an environmental variable
* that can be used to specify the number of iterations.
* It is supported in parse_opts.c and USC_setup.c.
*/
#define USC_ITERATION_ENV "USC_ITERATIONS"
/*
* The following define contains the name of an environmental variable
* that can be used to specify to iteration until desired time
* in floating point seconds has gone by.
* Supported in USC_setup.c.
*/
#define USC_LOOP_WALLTIME "USC_LOOP_WALLTIME"
/*
* The following define contains the name of an environmental variable
* that can be used to specify that no functional checks are wanted.
* It is supported in parse_opts.c and USC_setup.c.
*/
#define USC_NO_FUNC_CHECK "USC_NO_FUNC_CHECK"
/*
* The following define contains the name of an environmental variable
* that can be used to specify the delay between each loop iteration.
* The value is in seconds (fractional numbers are allowed).
* It is supported in parse_opts.c.
*/
#define USC_LOOP_DELAY "USC_LOOP_DELAY"
/*
* The following prototypes are needed to remove compile errors
* on IRIX systems when compiled with -n32 and -64.
*/
extern void tst_res(int ttype, char *fname, char *arg_fmt, ...);
extern void tst_resm(int ttype, char *arg_fmt, ...);
extern void tst_brk(int ttype, char *fname, void (*func)(),
char *arg_fmt, ...);
extern void tst_brkloop(int ttype, char *fname, void (*func)(),
char *arg_fmt, ...);
extern void tst_brkm(int ttype, void (*func)(), char *arg_fmt, ...);
extern void tst_brkloopm(int ttype, void (*func)(), char *arg_fmt, ...);
extern int tst_environ();
extern void tst_exit();
extern void tst_flush();
/* prototypes for the t_res.c functions */
extern void t_result(char *tcid, int tnum, int ttype, char *tmesg);
extern void tt_exit();
extern int t_environ();
extern void t_breakum(char *tcid, int total, int typ, char *msg, void (*fnc)());
extern void tst_sig(int fork_flag, void (*handler)(), void (*cleanup)());
extern void tst_tmpdir();
extern void tst_rmdir();
#endif /* end of __TEST_H__ */

148
winsup/testsuite/libltp/include/tlibio.h Normal file
View File

@ -0,0 +1,148 @@
/*
* Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it would be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* Further, this software is distributed without any warranty that it is
* free of the rightful claim of any third person regarding infringement
* or the like. Any license provided herein, whether implied or
* otherwise, applies only to this software file. Patent licenses, if
* any, provided herein do not apply to combinations of this program with
* other software, or any other product whatsoever.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write the Free Software Foundation, Inc., 59
* Temple Place - Suite 330, Boston MA 02111-1307, USA.
*
* Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
* Mountain View, CA 94043, or:
*
* http://www.sgi.com
*
* For further information regarding this notice, see:
*
* http://oss.sgi.com/projects/GenInfo/NoticeExplan/
*/
#define LIO_IO_SYNC 00001 /* read/write */
#define LIO_IO_ASYNC 00002 /* reada/writea/aio_write/aio_read */
#define LIO_IO_SLISTIO 00004 /* single stride sync listio */
#define LIO_IO_ALISTIO 00010 /* single stride async listio */
#define LIO_IO_SYNCV 00020 /* single-buffer readv/writev */
#define LIO_IO_SYNCP 00040 /* pread/pwrite */
#ifdef sgi
#define LIO_IO_ATYPES 00077 /* all io types */
#define LIO_IO_TYPES 00061 /* all io types, non-async */
#endif /* sgi */
#ifdef linux
#define LIO_IO_TYPES 00021 /* all io types */
#endif /* linux */
#ifdef CRAY
#define LIO_IO_TYPES 00017 /* all io types */
#endif /* CRAY */
#define LIO_WAIT_NONE 00010000 /* return asap -- use with care */
#define LIO_WAIT_ACTIVE 00020000 /* spin looking at iosw fields, or EINPROGRESS */
#define LIO_WAIT_RECALL 00040000 /* call recall(2)/aio_suspend(3) */
#define LIO_WAIT_SIGPAUSE 00100000 /* call pause */
#define LIO_WAIT_SIGACTIVE 00200000 /* spin waiting for signal */
#ifdef sgi
#define LIO_WAIT_CBSUSPEND 00400000 /* aio_suspend waiting for callback */
#define LIO_WAIT_SIGSUSPEND 01000000 /* aio_suspend waiting for signal */
#define LIO_WAIT_ATYPES 01760000 /* all async wait types, except nowait */
#define LIO_WAIT_TYPES 00020000 /* all sync wait types (sorta) */
#endif /* sgi */
#ifdef linux
#define LIO_WAIT_TYPES 00300000 /* all wait types, except nowait */
#endif /* linux */
#ifdef CRAY
#define LIO_WAIT_TYPES 00360000 /* all wait types, except nowait */
#endif /* CRAY */
/* meta wait io */
/* 00 000 0000 */
#ifdef sgi
/* all callback wait types */
#define LIO_WAIT_CBTYPES (LIO_WAIT_CBSUSPEND)
/* all signal wait types */
#define LIO_WAIT_SIGTYPES (LIO_WAIT_SIGPAUSE|LIO_WAIT_SIGACTIVE|LIO_WAIT_SIGSUSPEND)
/* all aio_{read,write} or lio_listio */
#define LIO_IO_ASYNC_TYPES (LIO_IO_ASYNC|LIO_IO_SLISTIO|LIO_IO_ALISTIO)
#endif /* sgi */
#ifdef linux
/* all signal wait types */
#define LIO_WAIT_SIGTYPES (LIO_WAIT_SIGPAUSE)
#endif /* linux */
#ifdef CRAY
/* all signal wait types */
#define LIO_WAIT_SIGTYPES (LIO_WAIT_SIGPAUSE|LIO_WAIT_SIGACTIVE)
#endif /* CRAY */
/*
* This bit provides a way to randomly pick an io type and wait method.
* lio_read_buffer() and lio_write_buffer() functions will call
* lio_random_methods() with the given method.
*/
#define LIO_RANDOM 010000000
/*
* This bit provides a way for the programmer to use async i/o with
* signals and to use their own signal handler. By default,
* the signal will only be given to the system call if the wait
* method is LIO_WAIT_SIGPAUSE or LIO_WAIT_SIGACTIVE.
* Whenever these wait methods are used, libio signal handler
* will be used.
*/
#define LIO_USE_SIGNAL 020000000
/*
* prototypes/structures for functions in the libio.c module. See comments
* in that module, or man page entries for information on the individual
* functions.
*/
int stride_bounds(int offset, int stride, int nstrides,
int bytes_per_stride, int *min_byte, int *max_byte);
int lio_set_debug(int level);
int lio_parse_io_arg1(char *string);
void lio_help1(char *prefex);
int lio_parse_io_arg2(char *string, char **badtoken);
void lio_help2(char *prefex);
int lio_write_buffer(int fd, int method, char *buffer, int size,
int sig, char **errmsg, long wrd);
int lio_read_buffer(int fd, int method, char *buffer, int size,
int sig, char **errmsg, long wrd);
int lio_random_methods(long mask);
#if CRAY
#include <sys/iosw.h>
int lio_wait4asyncio(int method, int fd, struct iosw **statptr);
int lio_check_asyncio(char *io_type, int size, struct iosw *status);
#endif /* CRAY */
#ifdef sgi
#include <aio.h>
int lio_wait4asyncio(int method, int fd, aiocb_t *aiocbp);
int lio_check_asyncio(char *io_type, int size, aiocb_t *aiocbp, int method);
#endif /* sgi */
/*
* Define the structure that contains the infomation that is used
* by the parsing and help functions.
*/
struct lio_info_type {
char *token;
int bits;
char *desc;
};

319
winsup/testsuite/libltp/include/usctest.h Normal file
View File

@ -0,0 +1,319 @@
/*
* Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it would be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* Further, this software is distributed without any warranty that it is
* free of the rightful claim of any third person regarding infringement
* or the like. Any license provided herein, whether implied or
* otherwise, applies only to this software file. Patent licenses, if
* any, provided herein do not apply to combinations of this program with
* other software, or any other product whatsoever.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write the Free Software Foundation, Inc., 59
* Temple Place - Suite 330, Boston MA 02111-1307, USA.
*
* Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
* Mountain View, CA 94043, or:
*
* http://www.sgi.com
*
* For further information regarding this notice, see:
*
* http://oss.sgi.com/projects/GenInfo/NoticeExplan/
*/
/* $Id$ */
/**********************************************************
*
* IRIX/Linux Feature Test and Evaluation - Silicon Graphics, Inc.
*
* FUNCTION NAME : usctest.h
*
* FUNCTION TITLE : System Call Test Macros
*
* SYNOPSIS:
* See DESCRIPTION below.
*
* AUTHOR : William Roske
*
* INITIAL RELEASE : UNICOS 7.0
*
* DESCRIPTION
* TEST(SCALL) - calls a system call
* TEST_VOID(SCALL) - same as TEST() but for syscalls with no return value.
* TEST_CLEANUP - print the log of errno return counts if STD_ERRNO_LOG
* is set.
* TEST_PAUSEF(HAND) - Pause for SIGUSR1 if the pause flag is set.
* Use "hand" as the interrupt handling function
* TEST_PAUSE - Pause for SIGUSR1 if the pause flag is set.
* Use internal function to do nothing on signal and go on.
* TEST_LOOPING(COUNTER) - Conditional to check if test should
* loop. Evaluates to TRUE (1) or FALSE (0).
* TEST_ERROR_LOG(eno) - log that this errno was received,
* if STD_ERRNO_LOG is set.
* TEST_EXP_ENOS(array) - set the bits in TEST_VALID_ENO array at
* positions specified in integer "array"
*
* RETURN VALUE
* TEST(SCALL) - Global Variables set:
* int TEST_RETURN=return code from SCALL
* int TEST_ERRNO=value of errno at return from SCALL
* TEST_VOID(SCALL) - Global Variables set:
* int TEST_ERRNO=value of errno at return from SCALL
* TEST_CLEANUP - None.
* TEST_PAUSEF(HAND) - None.
* TEST_PAUSE - None.
* TEST_LOOPING(COUNTER) - True if COUNTER < STD_LOOP_COUNT or
* STD_INFINITE is set.
* TEST_ERROR_LOG(eno) - None
* TEST_EXP_ENOS(array) - None
*
* KNOWN BUGS
* If you use the TEST_PAUSE or TEST_LOOPING macros, you must
* link in parse_opts.o, which contains the code for those functions.
*
*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#**/
#ifndef __USCTEST_H__
#define __USCTEST_H__ 1
#ifndef _SC_CLK_TCK
#include <unistd.h>
#endif
#include <sys/param.h>
/*
* Ensure that PATH_MAX is defined
*/
#ifndef PATH_MAX
#ifdef MAXPATHLEN
#define PATH_MAX MAXPATHLEN
#else
#define PATH_MAX 1024
#endif
#endif
#ifndef CRAY
#ifndef BSIZE
#define BSIZE BBSIZE
#endif
#endif
/***********************************************************************
* Define option_t structure type.
* Entries in this struct are used by the parse_opts routine
* to indicate valid options and return option arguments
***********************************************************************/
typedef struct {
char *option; /* Valid option string (one option only) like "a:" */
int *flag; /* pointer to location to set true if option given */
char **arg; /* pointer to location to place argument, if needed */
} option_t;
/***********************************************************************
* The following globals are defined in parse_opts.c but must be
* externed here because they are used in the macros defined below.
***********************************************************************/
extern int STD_FUNCTIONAL_TEST, /* turned off by -f to not do functional test */
STD_TIMING_ON, /* turned on by -t to print timing stats */
STD_PAUSE, /* turned on by -p to pause before loop */
STD_INFINITE, /* turned on by -c0 to loop forever */
STD_LOOP_COUNT, /* changed by -cn to set loop count to n */
STD_ERRNO_LOG, /* turned on by -e to log errnos returned */
STD_ERRNO_LIST[], /* counts of errnos returned. indexed by errno */
STD_COPIES,
STD_argind;
extern float STD_LOOP_DURATION, /* wall clock time to iterate */
STD_LOOP_DELAY; /* delay time after each iteration */
#define USC_MAX_ERRNO 2000
/**********************************************************************
* Prototype for parse_opts routine
**********************************************************************/
extern char *parse_opts(int ac, char **av, option_t *user_optarr, void (*uhf)());
/*
* define a structure
*/
struct usc_errno_t {
int flag;
};
/***********************************************************************
****
****
****
**********************************************************************/
#ifdef _USC_LIB_
extern int TEST_RETURN;
extern int TEST_ERRNO;
#else
/***********************************************************************
* Global array of bit masks to indicate errnos that are expected.
* Bits set by TEST_EXP_ENOS() macro and used by TEST_CLEANUP() macro.
***********************************************************************/
struct usc_errno_t TEST_VALID_ENO[USC_MAX_ERRNO];
/***********************************************************************
* Globals for returning the return code and errno from the system call
* test macros.
***********************************************************************/
int TEST_RETURN;
int TEST_ERRNO;
/***********************************************************************
* temporary variables for determining max and min times in TEST macro
***********************************************************************/
long btime, etime, tmptime;
#endif /* _USC_LIB_ */
/***********************************************************************
* structure for timing accumulator and counters
***********************************************************************/
struct tblock {
long tb_max;
long tb_min;
long tb_total;
long tb_count;
};
/***********************************************************************
* The following globals are externed here so that they are accessable
* in the macros that follow.
***********************************************************************/
extern struct tblock tblock;
extern void STD_go();
extern int (*_TMP_FUNC)(void);
extern void STD_opts_help();
/***********************************************************************
* TEST: calls a system call
*
* parameters:
* SCALL = system call and parameters to execute
*
***********************************************************************/
#define TEST(SCALL) TEST_RETURN = (unsigned) SCALL; TEST_ERRNO=errno;
/***********************************************************************
* TEST_VOID: calls a system call
*
* parameters:
* SCALL = system call and parameters to execute
*
* Note: This is IDENTICAL to the TEST() macro except that it is intended
* for use with syscalls returning no values (void syscall()). The
* Typecasting nothing (void) into an unsigned integer causes compilation
* errors.
*
***********************************************************************/
#define TEST_VOID(SCALL) SCALL; TEST_ERRNO=errno;
/***********************************************************************
* TEST_CLEANUP: print system call timing stats and errno log entries
* to stdout if STD_TIMING_ON and STD_ERRNO_LOG are set, respectively.
* Do NOT print ANY information if no system calls logged.
*
* parameters:
* none
*
***********************************************************************/
#define TEST_CLEANUP \
if ( STD_ERRNO_LOG ) { \
for (tmptime=0; tmptime<USC_MAX_ERRNO; tmptime++) { \
if ( STD_ERRNO_LIST[tmptime] ) { \
if ( TEST_VALID_ENO[tmptime].flag ) \
tst_resm(TINFO, "ERRNO %d:\tReceived %d Times", \
tmptime, STD_ERRNO_LIST[tmptime]); \
else \
tst_resm(TINFO, \
"ERRNO %d:\tReceived %d Times ** UNEXPECTED **", \
tmptime, STD_ERRNO_LIST[tmptime]); \
} \
} \
}
/***********************************************************************
* TEST_PAUSEF: Pause for SIGUSR1 if the pause flag is set.
* Set the user specified function as the interrupt
* handler instead of "STD_go"
*
* parameters:
* none
*
***********************************************************************/
#define TEST_PAUSEF(HANDLER) \
if ( STD_PAUSE ) { \
_TMP_FUNC = (int (*)())signal(SIGUSR1, HANDLER); \
pause(); \
signal(SIGUSR1, (void (*)())_TMP_FUNC); \
}
/***********************************************************************
* TEST_PAUSE: Pause for SIGUSR1 if the pause flag is set.
* Just continue when signal comes in.
*
* parameters:
* none
*
***********************************************************************/
#define TEST_PAUSE usc_global_setup_hook();
int usc_global_setup_hook();
/***********************************************************************
* TEST_LOOPING now call the usc_test_looping function.
* The function will return 1 if the test should continue
* iterating.
*
***********************************************************************/
#define TEST_LOOPING usc_test_looping
int usc_test_looping(int counter);
/***********************************************************************
* TEST_ERROR_LOG(eno): log this errno if STD_ERRNO_LOG flag set
*
* parameters:
* int eno: the errno location in STD_ERRNO_LIST to log.
*
***********************************************************************/
#define TEST_ERROR_LOG(eno) \
if ( STD_ERRNO_LOG ) \
if ( eno < USC_MAX_ERRNO ) \
STD_ERRNO_LIST[eno]++; \
/***********************************************************************
* TEST_EXP_ENOS(array): set the bits associated with the nput errnos
* in the TEST_VALID_ENO array.
*
* parameters:
* int array[]: a zero terminated array of errnos expected.
*
***********************************************************************/
#define TEST_EXP_ENOS(array) \
tmptime=0; \
while (array[tmptime] != 0) { \
if (array[tmptime] < USC_MAX_ERRNO) \
TEST_VALID_ENO[array[tmptime]].flag=1; \
tmptime++; \
}
#endif /* end of __USCTEST_H__ */

169
winsup/testsuite/libltp/include/write_log.h Normal file
View File

@ -0,0 +1,169 @@
/*
* Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it would be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* Further, this software is distributed without any warranty that it is
* free of the rightful claim of any third person regarding infringement
* or the like. Any license provided herein, whether implied or
* otherwise, applies only to this software file. Patent licenses, if
* any, provided herein do not apply to combinations of this program with
* other software, or any other product whatsoever.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write the Free Software Foundation, Inc., 59
* Temple Place - Suite 330, Boston MA 02111-1307, USA.
*
* Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
* Mountain View, CA 94043, or:
*
* http://www.sgi.com
*
* For further information regarding this notice, see:
*
* http://oss.sgi.com/projects/GenInfo/NoticeExplan/
*/
#ifndef _WRITE_LOG_H_
#define _WRITE_LOG_H_
/*
* Constants defining the max size of various wlog_rec fields. ANY SIZE
* CHANGES HERE MUST BE REFLECTED IN THE WLOG_REC_DISK STRUCTURE DEFINED
* BELOW.
*/
#define WLOG_MAX_PATH 128
#define WLOG_MAX_PATTERN 64
#define WLOG_MAX_HOST 8
#define WLOG_REC_MAX_SIZE (sizeof(struct wlog_rec)+WLOG_MAX_PATH+WLOG_MAX_PATTERN+WLOG_MAX_HOST+2)
/*
* User view of a write log record. Note that this is not necessiliary
* how the data is formatted on disk (signifigant compression occurrs), so
* don't expect to od the write log file and see things formatted this way.
*/
struct wlog_rec {
int w_pid; /* pid doing the write */
int w_offset; /* file offset */
int w_nbytes; /* # bytes written */
int w_oflags; /* low-order open() flags */
int w_done; /* 1 if io confirmed done */
int w_async; /* 1 if async write (writea) */
char w_host[WLOG_MAX_HOST+1]; /* host doing write - */
/* null terminated */
int w_hostlen; /* host name length */
char w_path[WLOG_MAX_PATH+1]; /* file written to - */
/* null terminated */
int w_pathlen; /* file name length */
char w_pattern[WLOG_MAX_PATTERN+1]; /* pattern written - */
/* null terminated */
int w_patternlen; /* pattern length */
};
#ifndef uint
#define uint unsigned int
#endif
/*
* On-disk structure of a wlog_rec. Actually, the record consists of
* 3 parts: [wlog_rec_disk structure][variable length data][length]
* where length is a 2 byte field containing the total record length
* (including the 2 bytes). It is used for scanning the logfile in reverse
* order.
*
* The variable length data includes the path, host, and pattern (in that
* order). The lengths of these pieces of data are held in the
* wlog_rec_disk structure. Thus, the actual on-disk record looks like
* this (top is lower byte offset):
*
* struct wlog_rec_disk
* path (w_pathlen bytes - not null terminated)
* host (w_hostlen bytes - not null terminated)
* pattern (w_patternlen bytes - not null terminated)
* 2-byte record length
*
* Another way of looking at it is:
*
* <struct wlog_rec_disk><path (wpathlen bytes)>-->
* --><host (w_hostlen bytes)><pattern (w_patternlen bytes)><length (2 bytes)>
*
* The maximum length of this record is defined by the WLOG_REC_MAX_SIZE
* record. Note that the 2-byte record length forces this to be
* <= 64k bytes.
*
* Note that there is lots of bit-masking done here. The w_pathlen,
* w_hostlen, and w_patternlen fields MUST have enough bits to hold
* WLOG_MAX_PATH, WLOG_MAX_HOST, and WLOG_MAX_PATTERN bytes respectivly.
*/
struct wlog_rec_disk {
#ifdef CRAY
uint w_offset : 44; /* file offset */
uint w_extra0 : 20; /* EXTRA BITS IN WORD 0 */
#else
uint w_offset : 32; /* file offset */
uint w_extra0 : 32; /* EXTRA BITS IN WORD 0 */
#endif
uint w_nbytes : 32; /* # bytes written */
uint w_oflags : 32; /* low-order open() flags */
uint w_pid : 17; /* pid doing the write */
uint w_pathlen : 7; /* length of file path */
uint w_patternlen: 6; /* length of pattern */
uint w_hostlen : 4; /* length of host */
uint w_done : 1; /* 1 if io confirmed done */
uint w_async : 1; /* 1 if async write (writea) */
uint w_extra2 : 28; /* EXTRA BITS IN WORD 2 */
};
/*
* write log file datatype. wlog_open() initializes this structure
* which is then passed around to the various wlog_xxx routines.
*/
struct wlog_file {
int w_afd; /* append fd */
int w_rfd; /* random-access fd */
char w_file[1024]; /* name of the write_log */
};
/*
* return value defines for the user-supplied function to
* wlog_scan_backward().
*/
#define WLOG_STOP_SCAN 0
#define WLOG_CONTINUE_SCAN 1
/*
* wlog prototypes
*/
#if __STDC__
extern int wlog_open(struct wlog_file *wfile, int trunc, int mode);
extern int wlog_close(struct wlog_file *wfile);
extern int wlog_record_write(struct wlog_file *wfile,
struct wlog_rec *wrec, long offset);
extern int wlog_scan_backward(struct wlog_file *wfile, int nrecs,
int (*func)(struct wlog_rec *rec),
long data);
#else
int wlog_open();
int wlog_close();
int wlog_record_write();
int wlog_scan_backward();
#endif
extern char Wlog_Error_String[];
#endif /* _WRITE_LOG_H_ */