diff options
Diffstat (limited to 'ltp_framework/include/write_log.h')
| -rw-r--r-- | ltp_framework/include/write_log.h | 170 |
1 files changed, 170 insertions, 0 deletions
diff --git a/ltp_framework/include/write_log.h b/ltp_framework/include/write_log.h new file mode 100644 index 0000000..84d6313 --- /dev/null +++ b/ltp_framework/include/write_log.h @@ -0,0 +1,170 @@ +/* + * 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 + /* NB: sgi is pissy about fields > 32 bit, even cc -mips3 */ + 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_ */ + |