Diff of /doc/man3/write_log.3 [000000] .. [7ce3a7]  Maximize  Restore

Switch to side-by-side view

--- a
+++ b/doc/man3/write_log.3
@@ -0,0 +1,244 @@
+.\" $Id: write_log.3,v 1.1 2000/07/27 16:59:03 alaffin Exp $
+.\" 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
+.\" 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/
+.TH WRITE_LOG 3 07/25/2000 "Linux Test Project"
+write_log \- a set of routines for logging writes to a history file
+\fB#include "write_log.h"\fP
+\fBint wlog_open(struct wlog_file *\fIwfile\fB, int \fItrunc\fB, int \fImode\fB);\fR
+\fBint wlog_close(struct wlog_file *\fIwfile\fB);\fR
+\fBint wlog_record_write(struct wlog_file *\fIwfile\fB, struct wlog_rec *\fIwrec\fB, long \fIoffset\fB);\fR
+\fBint wlog_scan_backward(struct wlog_file *\fIwfile\fB, int \fInrecs\fB, int (*func)(struct wlog_rec *\fIrec\fB), long \fIdata\fB);\fR
+\fBchar *Wlog_Error_String;\fR
+The write_log package is a set of routines for creating a history file
+of write operations done to a set of files.
+It is assumed that the actual pattern written to the file will be 
+repeated occurrences of a string whose length is no greater than
+WLOG_MAX_PATTERN.  See the pattern(3) man
+page for routines to conveniently generate buffers of this kind.
+wlog_open() initializes the history file contained in wfile->w_file, and 
+fills in the wfile structure.  If trunc is non-zero, and existing history
+file by the same name will be truncated.  If no history file exists, it
+will be created with the specified mode.
+wlog_close() releases any resources associated with the given wfile.  Use
+of wfile after this point is undefined until it is initialized again with
+wlog_record_write() is the main routine for putting a wlog_rec into the
+history file.  The caller is responsible for supplying a fully initialized
+wlog_rec structure.  If offset is < 0, the record will be appended to the
+end of the history file.  If offset is >= 0, the record will be written
+at the indicated offset.  This, along with the w_done field in the wlog_rec
+structure, provide a mechanism for 'pre-logging' a write, doing the write
+operation, and then overlaying the original record with the w_done flag
+set to 1.  This is useful for async writes which may not complete in a 
+timely manner.  It is also useful for seeing which write operations were
+pending at the time of a system crash - the ones whose w_done flag is 0 have
+not yet been verified as complete.
+The return value from wlog_record_write() is the offset
+in the history file at which the record was written.
+wlog_scan_backward() can be used to conveniently scan a write history file.
+The routine scans the file in reverse order (ie. first record written is
+scanned last).  For every record found, the user supplied function is called
+with 2 parameters:  the read record, and an arbitrary word passed in by the
+user.  This word may be interpreted however the user desires.  If nrecs is
+greater than 0, up to nrecs will be scanned.  The user supplied function should
+return 1 of the following:  WLOG_STOP_SCAN, or WLOG_CONTINUE_SCAN.
+WLOG_STOP_SCAN provides a way for the user supplied function to prematurely
+abort the scanning process.  WLOG_CONTINUE_SCAN instructs wlog_scan_backward()
+to continue scanning the next record.
+In order for the history file to be effective, some basic rules must
+be followed by the programs using the history mechanism:
+.in +.5i
+.ll -.5i
+The area of the data file being written must be locked from
+before the write operation, until after the wlog_record_write()
+is complete.  This is necessary to 'synchronize' simultaneous
+writes to the same area of a file.  Note that the entire file
+does not need to be locked, only the portion being written to.
+If the calling program can guarantee that there will never be more
+than 1 process writing to the same area of a file at the same time, 
+locking is not necessary.  (Note:  UNICOS Shared File Systems do not support
+record locking.  The whole file is silently locked.)
+Pathnames in the history file (w_path field) should be full
+pathnames if possible.  This allows validation tools to be
+able to find the test files without having to take working
+directory considerations into account.
+.ll +.5i
+.in -.5i
+.ta .25i +.5i +1i
+ * write log file data type.  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 */
+.ta .25i +.5i +2.0i
+ * User view of a history file record.  Note that this is not
+ * necessarily how the data is formatted on disk (significant
+ * compression occurs), so don't expect to od(1) the history file and
+ * see things formatted this way.  See the file write_log.h for comments
+ * on how the data is actually written to disk.
+ */
+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 */
+	int	w_hostlen;	/* host name length */
+	char	w_path[WLOG_MAX_PATH+1];	/* file written to */
+	int	w_pathlen;	/* file name length */
+	char	w_pattern[WLOG_MAX_PATTERN+1];	/* pattern written */
+	int	w_patternlen;	/* pattern length */
+Note:  The history files can become very large very quickly if a lot of
+processes are logging writes.  This is especially apt to happen if long
+pathnames or patterns are used.  This is because the w_host, w_path, and
+w_pattern fields are variable length fields when stored on disk.  Thus, use
+short pathnames and patterns to minimize the size of the history file.  If
+any of the w_path, w_pattern, or w_host fields are not important to you, set
+the respective length field to 0 in the wlog_rec structure.
+This is a simple example of how to initialize a history file, and
+record a write to it.
+#include "write_log.h"
+	struct wlog_rec wrec;
+	struct wlog_file wfile;
+	...
+	strcpy(wfile.w_file, hisfile);
+	if (wlog_open(&wfile, 1, 0666) < 0) {
+		fprintf("wlog_open failed\n");
+		exit(2);
+	}
+	...
+	wrec.w_pid = getpid();
+	wrec.w_offset = write_offset;
+	wrec.w_nbytes = nbytes;
+	wrec.w_oflags = open_flags;
+	wrec.w_done = 0;
+	wrec.w_async = 0;
+	wrec.w_host = 0;             /* don't care about host */
+	wrec.w_pathlen = sprintf(wrec.w_path, "%s", path);
+	wrec.w_patternlen = sprintf(wrec.w_pattern, "%s", pattern);
+	pattern_fill(buf, nbytes, pattern, strlen(pattern), 0);
+	... lock fd here ...
+	log_offset = wlog_record_write(&wfile, &wrec, -1);
+	write(fd, buf, nbytes);
+	wrec.w_done = 1;
+	wlog_record_write(&wfile, &wrec, log_offset);
+	... unlock fd here ...
+	...
+	/*
+	 * Scan the logfile printing records for the file in 'path'.
+	 */
+	wlog_scan_backward(&wfile, 0, print_log_record, (long)path);
+print_log_record(record, data)
+struct wlog_rec	*record;
+long		data;
+	char	*path;
+	path = (char *)data;
+	if (strcmp(record->w_path, path) == 0) {
+		printf("write() of %d bytes to %s at offset %d by pid %d\n",
+			record->w_nbytes, record->path, record->w_offset, record->w_pid);
+	}
+All routines return a value < 0 on failure, and >= 0 on success.  Error
+messages can be accessed through Wlog_Error_String.
+None known.

Get latest updates about Open Source Projects, Conferences and News.

Sign up for the SourceForge newsletter:

No, thanks