OpenSolaris_b135/cmd/bnu/perfstat.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 1997 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* This module is intended to collect performance statistics about the
* operation of uucico. All instances of uucico will write their log
* entries to the files who's path is defined by PERFLOG. Statistics
* will only be collected if PERFLOG exists when uucico starts, it will
* not be created automatically. This gives the SA an easy way to turn
* statistics collection on or off at run time. Three types
* of records will be written to the file, and each record will be
* identified by a mnemonic type at the begining of the record. The record
* types are as follows:
*
* conn - Contains statistics about the establishment of
* a connection.
*
* xfer - Contains statistics about a file transfer.
*
* The intention is to use grep to select the conn and xfer records and put
* them in two Unity data bases. No attempt will be made to process the
* error records with Unity.
*
* Both the conn and the xfer records will contain a time stamp field.
* This field will be written in case there is a desire to do time of
* day traffic studies. The time that will be written will be GMT
* to avoid the vagaries of time zone setting for uucico. The time
* stamp will contain 12 digits of the form YYMMDDhhmmss. This allows
* proper sorting by time, and the fixed length field type of Unity
* can be used to pick it apart if necessary. The time stamp is the
* time that the record is written.
*
* Statistics will be collected on the wall clock (real) time to perform
* an action and CPU consumption to perform an action. These times will
* be written in seconds and fractions of a second to two decimal places.
*
* The conn and xfer records will be written so that they can be processed
* with the following Unity schema (D files). For those not familiar with
* Unity, the columns are:
*
* column 1 - field name
* column 2 - field type (t=variable width) and field separator.
* column 3 - number of columns to use when printing the field
* with uprint.
* column 4 - a user friendly field name.
*
* Conn:
*
* type t| 4 record type (always conn)
* ts t| 12 time stamp
* procid t| 5 uucico's process id
* myname t| 6 name of the machine where the record is written
* role t| 1 M = master, S = slave
* remote t| 6 name of remote system
* device t| 6 name of device used for connection
* protocol t| 1 the protocal that is used for communication
* netid t| 6 physical network ID
* real t| 6 real time to connect
* user t| 6 user time to connect
* sys t\n 6 system (kernal) time to connect
*
* The timer for connection processing starts immediately after the
* command line processing is complete, and it is stopped after the
* protocol has been selected.
*
* Xfer:
*
* type t| 4 record type (always xfer)
* jobgrade t| 1 job grade ID
* ts t| 12 time stamp
* procid t| 5 uucico's process id
* myname t| 6 name of the machine where the record is written
* role t| 1 M = master, S = slave
* remote t| 6 name of remote system
* device t| 6 name of device used for connection
* protocol t| 1 the protocal that is used for communication
* netid t| 6 physical network ID
* job t| 7 name of the job. (Master only).
* inqueue t| 6 time in seconds that file was in queue (Master
* only).
* tat t| 6 turn around time in sec. (Master only).
* bytes t| 6 size of the file that was transferred
* flags t| 3 m = mail to requester on completion,
* n = notify remote user, s = write status
* file. (Master only).
* streal t| 6 real time to start up transfer (master only).
* stuser t| 6
* stsys t| 6
* xfrreal t| 6 real time to transfer file
* xfruser t| 6
* xfrsys t| 6
* trmreal t| 6 real time to terminate the transfer
* trmuser t| 6
* trmsys t| 6
* text t| 12 "PARTIAL FILE" if the data is being transmitted
* before breaking the transmission; blank if the
* partial file after the breakpoint or the whole
* file is being transmitted completely.
*
* Start up time includes the time for the master to search the queues
* for the next file, for the master and slave to exchange work vectors,
* and time to open files. It is only recorded on the master.
* Xfer times is the time to transfer the data, close the file, and
* exchange confirmation messages. Termination time is the time to send
* mail notifications and write status files. Turn around time is the
* difference between the time that the file was queued and the time that
* the final notification was sent.
*/
#include "uucp.h"
#include "log.h"
/*
* SYMBOL DEFINITIONS
*/
#define FS '|' /* Field seperator for output records. */
#define LOGCHECK {if ((Initialized == FALSE) || \
(Collecting == FALSE)) return; }
/* Subscripts for connection time marks: */
#define CT_START 0 /* Start connection establishment. */
#define CT_CONNECTED 1 /* Connection completed. */
#define CT_SIZE 2 /* Number of elements in array. */
/* Subscripts for xfer time marks: */
#define XT_LOOK 0 /* Start looking for a file (master only). */
#define XT_FOUND 1 /* File found (master only). */
#define XT_BEGXFER 2 /* Start of xfer of data. */
#define XT_ENDXFER 3 /* Data xfer complete. */
#define XT_ENDFILE 4 /* Done mailing and notifying. */
#define XT_SIZE 5 /* Number of elements in array. */
/*
* STRUCTURE DEFINITIONS
*/
typedef struct timeUsed /* Time consummed between events. */
{
float tu_real; /* Real time used. */
float tu_user; /* User time used. */
float tu_sys; /* System time used. */
} TUSED;
typedef struct timeMark /* Holds times for an event. */
{
int tm_valid; /* True if data present. */
long tm_real; /* Relative wall clock. */
struct tms tm_cycles; /* CPU consumption. */
} TMARK;
struct connData /* Data for construction of conn record. */
{
char cn_role; /* Master/slave indicator. */
TMARK cn_times[CT_SIZE]; /* Event data. */
};
struct xferData /* Data for construction of xfer record. */
{
char xf_role; /* Master/slave indicator. */
char xf_direction; /* Send/receive indicator. */
time_t xf_intoque; /* Time that file was placed
* in the queue. (master
* only). */
long xf_deque; /* Time that file was
* dequeued. (master only)*/
long xf_filedone; /* Time that file was
* completed. */
char xf_jobname[MODSTR]; /* C. file (master only)*/
char xf_jobgrade[MODSTR]; /* job grade id */
off_t xf_bytes; /* Bytes transferred. */
char xf_flags[MODSTR]; /* Notification flags. */
TMARK xf_times[XT_SIZE]; /* Event data. */
};
/*
* LOCAL DATA
*/
static int Collecting = FALSE; /* True if we are collecting
* data. */
static struct connData Conn = {0}; /* Connection data. */
static char Device[MODSTR] = ""; /* Type of communication
* device. */
static int Initialized = FALSE; /* True if we have been
* initialized. */
static int LogFile = CLOSED; /* Log file file destriptor. */
static char LogName[] = PERFLOG; /* Name of our log file. */
static pid_t Procid = {0}; /* Our processid. */
static char Record[LOGSIZE]; /* Place to build log records. */
static char Remote[MODSTR] = ""; /* Name of the remote system. */
static char myname[MAXBASENAME+1] = ""; /* Name of the source system
. */
static char Protocol[MODSTR]; /* Protocol in use */
static char Netid[MODSTR] = NOTAVAIL; /* Network ID in use */
static struct xferData Xfer = {0}; /* Transfer data. */
/* Messages: */
static char Msg_badopen[] = "failed to open %s. Errno=%%d\n";
static char Msg_opening[] = "attempting to open %s\n";
static char Msg_write[] = "error in writing to %s. Errno=%%d.\n";
/*
* LOCAL FUNCTIONS
*/
/* Declarations of functions: */
STATIC_FUNC void grabTimes();
STATIC_FUNC void pfloat();
STATIC_FUNC void reportConn();
STATIC_FUNC void reportFile();
STATIC_FUNC void reportTimes();
STATIC_FUNC void subTimes();
/*
* Local Function: grabTimes - Get Real and CPU Times
*
* This function uses times(2) to obtain the current real time and CPU
* consumption. The time mark is also marked as valid.
*
* Parameters:
*
* markptr - Address of structure to save times.
*
* Return:
*
* none.
*/
STATIC_FUNC void
grabTimes (markptr)
register TMARK * markptr;
{
markptr->tm_real = times(&markptr->tm_cycles);
if (markptr->tm_real != FAIL)
markptr->tm_valid = TRUE;
return;
}
/*
* Local Function: pfloat - Print a Floating Number
*
* Format a floating point number for output to the Unity data base.
* If the number is NOTIME, "na" will be displayed instead.
*
* Parameters:
*
* dest - The result will be concatenated to this string.
*
* number - The number to be formated.
*
* sep - Field separator character.
*/
STATIC_FUNC void
pfloat (dest, number, sep)
char * dest;
double number; /* float is promoted to double for args. */
char sep;
{
static char rformat[] = "%c%.2f";
static char naformat[] = "%c%s";
register char * cp;
cp = dest + strlen(dest);
if (number == (float) NOTIME)
sprintf(cp, naformat, sep, NOTAVAIL);
else
sprintf(cp, rformat, sep, number);
return;
}
/*
* Local Function: reportConn - Write Out Conn Record
*
* This function writes a conn record to the logfile.
*
* Parameters:
*
* None.
*
* Returns:
*
* None.
*/
STATIC_FUNC void
reportConn ()
{
TUSED contimes; /* Times to make connection. */
static char format[] = "%s%c%s%c%ld%c%s%c%c%c%s%c%s%c%s%c%s";
sprintf(Record, format,
"conn", FS, /* record type. */
gmt(), FS, /* current time. */
(long) Procid, FS, /* our process id. */
myname, FS, /* name of local system */
Conn.cn_role, FS, /* slave or master. */
Remote, FS, /* name of remote system. */
Device, FS, /* device used for communication. */
Protocol, FS, /* protocol used for comm. */
Netid /* Network ID */
);
subTimes(&contimes, &Conn.cn_times[CT_CONNECTED],
&Conn.cn_times[CT_START]);
reportTimes(Record, &contimes, FS);
strcat(Record, EOR);
writeLog(Record,&LogFile,LogName,&Collecting);
return;
}
/*
* Local Function: reportFile - Write File Statistics to Log
*
* This function writes statistics about the current file to the log
* file.
*
* Parameters:
*
* none.
*/
STATIC_FUNC void
reportFile (breakmsg)
char * breakmsg;
{
/* minuend, subtrahand */
static int drvtab[] = {
XT_FOUND, XT_LOOK, /* startup */
XT_ENDXFER, XT_BEGXFER, /* xfer */
XT_ENDFILE, XT_ENDXFER /* term. */
};
static char format1[] = "%s%c%s%c%s%c%ld%c%s%c%c%c%s%c%s%c%s%c%s%c%s";
static char format2[] = "%c%ld%c%s"; /* Bytes & flags. */
register struct xferData * xdptr;
register TMARK * tdptr;
register int i;
TUSED diff; /* time difference between events. */
float inque; /* time in queue. */
int lastbyte; /* Offset to last byte in Record. */
char * na = NOTAVAIL; /* String to show data not available*/
char role; /* Current master/slave status. */
float tat; /* Turn around time. */
xdptr = &Xfer; /* Point to Xfer data. */
role = xdptr->xf_role;
sprintf(Record, format1,
"xfer", FS, /* Record type. */
(role == MCHAR) ? xdptr->xf_jobgrade : na ,FS, /* job grade */
gmt(), FS, /* Current time. */
(long) Procid, FS, /* Our process id. */
myname, FS, /* name of local system */
role, FS, /* master/slave. */
Remote, FS, /* remote. */
Device, FS, /* communications device. */
Protocol, FS, /* protocol used for comm. */
Netid, FS, /* Network ID */
(role == MCHAR) ? xdptr->xf_jobname : na
);
/* Do time in queue and turn around time. */
if (role == MCHAR)
{
inque = (float) (xdptr->xf_deque - xdptr->xf_intoque);
tat = (float) (xdptr->xf_filedone - xdptr->xf_intoque);
} else
{
inque = (float) NOTIME; /* Not app. if not master. */
tat = (float) NOTIME;
}
pfloat(Record, inque, FS);
pfloat(Record, tat, FS);
/*
* Report bytes transferred and notification flags.
*/
lastbyte = strlen(Record);
(void) sprintf(Record+lastbyte, format2,
FS, getfilesize(),FS,
(role == MCHAR) ? xdptr->xf_flags : na
);
/*
* Report resource consumption for file startup, file transfer,
* and file termination. This means reporting the differences
* between pairs of elements in the xf_times array of Xfer. This
* will be controled by drvtab which contains pairs of subscripts
* to designate the xf_times elements.
*/
tdptr = &xdptr->xf_times[0];
for (i = 0; i < sizeof(drvtab)/(sizeof(int)); i += 2)
{
subTimes(&diff, (tdptr + drvtab[i]), (tdptr + drvtab[i+1]));
reportTimes(Record, &diff, FS);
}
/*
* write file status
*/
lastbyte = strlen(Record);
(void) sprintf(Record+lastbyte, "%c%s%c",
FS, (*breakmsg == NULLCHAR) ? NOTAVAIL : breakmsg, FS);
/* Terminate the record and write it out. */
(void) strcat(Record, EOR);
writeLog(Record,&LogFile,LogName,&Collecting);
return;
}
/*
* Local Function: reportTimes - Print Real, User, and Sys Times
*
* This function is used to convert the real, user, and system times from
* a TUSED structure to Ascii strings. The results are concatenated to
* the dest string. If any of the times are NOTIME, they will be reported
* as "na". The fields will be seperated by the sep character and the
* sep character will be the first character concatenated to the buffer. No
* seperator character will be placed at the end. Thus, the output string
* will be of the form:
*
* |real|user|sys
*
* Parameters:
*
* dest - String to receive Ascii times.
*
* diffptr - Address of the time data.
*
* sep - The field seperator character.
*/
STATIC_FUNC void
reportTimes (dest, diffptr, sep)
register char * dest;
register TUSED * diffptr;
char sep;
{
pfloat(dest, diffptr->tu_real, sep);
pfloat(dest, diffptr->tu_user, sep);
pfloat(dest, diffptr->tu_sys, sep);
return;
}
/*
* Local Function: subTimes - Subtract Times Between Events
*
* This function takes the output from two calls to times(2) in the form
* of two TMARK structures, and determines the amount of time consummed
* for various categories. The result is stored in the specified
* TUSED structure.
*
* Parameters:
*
* diff - Place to store the result of the subtraction.
* minuend - The second time event.
* subtra - The subtrahend in the subtraction. This should
* be the first of two time events.
*
* On the large scale this function does the following:
*
* diff = minuend - subtra
*/
STATIC_FUNC void
subTimes (diff, minuend, subtra)
register TUSED * diff;
register TMARK * minuend;
register TMARK * subtra;
{
register struct tms * mintms;
register struct tms * subtms;
long ltemp; /* Temporary storage for long arith. */
float ticks; /* Clock interrupts per second. */
if ((minuend->tm_valid != TRUE) || (subtra->tm_valid != TRUE))
{ /* If data has not been collected. */
diff->tu_real = NOTIME;
diff->tu_user = NOTIME;
diff->tu_sys = NOTIME;
} else
{
ticks = (float) HZ; /* HZ defined in <sys/param.h>. */
mintms = &minuend->tm_cycles;
subtms = &subtra->tm_cycles;
/* Calculate real time. */
ltemp = minuend->tm_real - subtra->tm_real;
diff->tu_real = ((float) ltemp)/ticks;
/* Calculate user time. */
ltemp = mintms->tms_utime
- subtms->tms_utime
+ mintms->tms_cutime
- subtms->tms_cutime;
diff->tu_user = ((float) ltemp)/ticks;
/* Calculate user time. */
ltemp = mintms->tms_stime
- subtms->tms_stime
+ mintms->tms_cstime
- subtms->tms_cstime;
diff->tu_sys = ((float) ltemp)/ticks;
}
return;
}
/*
* EXTERNAL FUNCTIONS
*/
/*
* Function: gmt - Generate Current Time String
*
* This function returns the address a string containing the current
* GMT in the form YYMMDDhhmmss.
*
* Parameters:
*
* none
*
* Return:
*
* An address of a static character array containing the date.
*/
char *
gmt()
{
static char date[] = "YYMMDDhhmmss";
register struct tm * td;
time_t now; /* Current time. */
now = time((time_t *) 0);
td = gmtime(&now);
(void) sprintf(date, "%02d%02d%02d%02d%02d%02d",
(td->tm_year % 100),
td->tm_mon + 1,
td->tm_mday,
td->tm_hour,
td->tm_min,
td->tm_sec
);
return date;
}
/*
* Function: writeLog - Write String to Log File
*
* After insuring that the log file is open, this function will write
* the specified string to the log file. If a write error occurs,
* statistics collection will be disabled.
*
* Parameters:
*
* string - Null terminated string to be written out.
* logfile - file descripter
* logname - name of log file.
* collecting - log enable/disable
*/
void
writeLog (string, logfile, logname, collecting)
char * string;
int * logfile;
char * logname;
int * collecting;
{
register int length; /* Length of the string. */
register int rv; /* Return value from write. */
char errmsg[BUFSIZ]; /* Place for error messages. */
if (openLog(logfile,logname) != SUCCESS){
*collecting = FALSE;
return;
}
length = strlen(string);
do
{
rv = write(*logfile, string, (unsigned) length);
} while ((rv < 0) && (errno == EINTR)); /* Retry if interrupted. */
if (rv < length)
{ /* Error or incomplete output. */
(void) sprintf(errmsg, Msg_write, logname);
DEBUG(DB_IMPORTANT, errmsg, errno);
/* If we had a write error, lets give up on loggine. */
closeLog(logfile);
*collecting = FALSE;
}
return;
}
/*
* Function: closeLog - Close the Log File
*
* This function allows uucico to close the log file in preparation for
* forking.
*
* Parameters:
*
* log file descriptor
*/
void
closeLog (logfile)
int *logfile;
{
if (*logfile != CLOSED)
{
(void) close(*logfile);
*logfile = CLOSED;
}
return;
}
/*
* Function: copyText - Copy String to Dynamic Memory
*
* This function copies a string to a buffer. It insures that there is
* no overflow of the buffer and that the result is null terminated.
*
* Parameters:
*
* tptr - address of the buffer where the string is to
* be stored.
*
* size - number of bytes in the buffer.
*
* string - string to be saved.
*
* Returns:
*
* none.
*/
void
copyText (tptr, size, string)
register char * tptr;
register int size;
char * string;
{
(void) strncpy(tptr, string, size);
*(tptr + size - 1) = NULLCHAR;
return;
}
/*
* Function: pfConnected - Report Connection Completion
*
* Uucico uses pfConnected to tell this performance package that a connection
* has been established with the remote system.
*
* Parameters:
*
* remote - name of the remote system.
*
* device - the type of device being used for communicaitons.
*/
void
pfConnected (remote, device)
char * remote;
char * device;
{
register int i;
register TMARK * tptr;
LOGCHECK;
grabTimes(&Conn.cn_times[CT_CONNECTED]);
copyText(Remote, sizeof(Remote), remote);
copyText(Device, sizeof(Device), device);
reportConn();
tptr = &Conn.cn_times[0];
/*
* Mark connection times as invalid. This is really unnecessary
* since there should only be one connection per invocation of uucico.
* We do it for consistency with use of the transfer data.
*/
for (i = 0; i < CT_SIZE; i++, tptr++)
tptr->tm_valid = FALSE;
return;
}
/*
* Function: pfEndFile - Report End of File
*
* Uucico uses pfEndFile to tell our statistics collection package that
* all processing has been finished on the current file. PfEndfile should
* be called after all notifications have been done and after the status
* file has been written. PfEndfile writes out a xfer record for the
* file that just completed.
*
* Parameters:
*
* none
*/
void
pfEndfile (breakmsg)
char * breakmsg;
{
register int i;
register TMARK * tdptr;
register struct xferData * xptr = &Xfer;
LOGCHECK;
grabTimes(&Xfer.xf_times[XT_ENDFILE]);
Xfer.xf_filedone = time((time_t *) 0);
reportFile(breakmsg);
/* Now that we have reported them, mark all times as invalid. */
copyText(xptr->xf_flags, sizeof(xptr->xf_flags), NOTAVAIL);
tdptr = &Xfer.xf_times[0];
for (i = 0; i < XT_SIZE; i++, tdptr++)
tdptr->tm_valid = FALSE;
return;
}
/*
* Function: pfEndXfer - File Transfer Complete
*
* Calling pfEndXfer tells the performance package that a file transfer
* has been completed. It should be called after the destination site
* closes the file and confirms receipt, but before notifications are done.
*
* Parameters:
*
* none
*/
void
pfEndXfer ()
{
LOGCHECK;
grabTimes(&Xfer.xf_times[XT_ENDXFER]);
return;
}
/*
* Function: pfFindFile - Looking for Another File
*
* Uucico uses pfFindFile to announce that it is going to explore the
* queues for another file transfer to do. PfFindFile is only called
* when uucico is in the role of master.
*
* Parameters:
*
* none
*/
void
pfFindFile ()
{
LOGCHECK;
grabTimes(&Xfer.xf_times[XT_LOOK]);
return;
}
/*
* Function: pfFound - Found Another File
*
* PfFound is a counterpart of pfFindFile. It is called when a new file
* has been found. Like pfFindFile it is called only by a master uucico.
*
* Parameters:
*
* jobid - The name of the job that was found.
*
* flags - Options flags that were stored in the queue.
* These flags are originally set by uucp.
*
* intoQue - The time that the C. file was placed in the queue.
*/
void
pfFound (jobid, flags, intoQue)
char * jobid;
char * flags;
time_t intoQue;
{
register struct xferData * xptr = &Xfer;
LOGCHECK;
grabTimes(&xptr->xf_times[XT_FOUND]);
copyText(xptr->xf_jobname, sizeof(xptr->xf_jobname), jobid);
xptr->xf_jobgrade[0] = jobid[strlen(jobid)-5];
xptr->xf_jobgrade[1] = NULLCHAR;/* get job grade from jobid */
copyText(xptr->xf_flags, sizeof(xptr->xf_flags), flags);
/* Save time that file was placed in queue and current time. */
xptr->xf_intoque = intoQue;
xptr->xf_deque = time((time_t *) 0);
return;
}
/*
* Function: pfInit - Initialize Performance Package
*
* This function allows the performance package to initialize its internal
* data structures. It should be called one time only when uucico starts
* running.
*
* Parameters:
*
* none
*/
void
pfInit ()
{
register struct xferData * xptr = &Xfer;
if (Initialized == TRUE)
return;
Procid = getpid();
myName(myname);
copyText(xptr->xf_flags, sizeof(xptr->xf_flags), NOTAVAIL);
/*
* Attempt to open the log file. If we can't do it, then we
* won't collect statistics.
*/
if (openLog(&LogFile,LogName) == SUCCESS)
Collecting = TRUE;
else
Collecting = FALSE;
Initialized = TRUE;
return;
}
/*
* Function: pfStrtConn - Going to Establish Connection
*
* Uucico uses pfStrtConn to announce that it is going to attempt
* to establish a connection.
*
* Parameters:
*
* role - An indication of whether uucico is currently
* running in master or slave mode. M = master,
* S = slave.
*/
void
pfStrtConn (role)
char role;
{
LOGCHECK;
grabTimes(&Conn.cn_times[CT_START]);
Conn.cn_role = role;
return;
}
/*
* Function: pfStrtXfer - Starting File Transfer
*
* This function should be called just as the first byte of data is
* about to be transferred.
*
* Parameters:
*
* role - An indication of whether uucico is currently
* running in master or slave mode. M = master,
* S = slave.
*
* direction - Direction of file transfer. S = sending to
* remote, R = receiving from remote.
*/
void
pfStrtXfer(role, direction)
char role;
char direction;
{
register struct xferData * xptr = &Xfer;
LOGCHECK;
grabTimes(&xptr->xf_times[XT_BEGXFER]);
xptr->xf_role = role;
xptr->xf_direction = direction;
return;
}
/*
A protocol which both master and slave sides agree on
*/
void
pfPtcl(str)
char *str;
{
strcpy(Protocol,str);
return;
}
/*
* Function: openLog - Open the Log File
*
* If the log file is already open this function immediately returns
* success. Otherwise, an attempt is made to open the logfile in append
* mode.
*
* Parameters:
*
* logfile - file descripter
* logname - name of log file.
*
* Returns:
*
* SUCCESS - The log file is open.
* FAIL - Unable to open logfile.
*/
int
openLog (logfile,logname)
int *logfile;
char *logname;
{
register int fd; /* File descriptor of log file. */
int level; /* Level for debug message. */
char msgbuf[BUFSIZ];
/* See if file already open. */
if (*logfile != CLOSED)
return (SUCCESS);
/* Attempt to open the file. */
DEBUG(DB_TRACE, Msg_opening, logname);
do
{
fd = open(logname, O_WRONLY | O_APPEND);
} while ((fd < 0) && (errno == EINTR)); /* Retry if interrupted. */
if (fd < 0) { /* Error on open. */
(void) sprintf(msgbuf, Msg_badopen, logname);
if (errno == ENOENT)
level = DB_DETAIL; /* If the file is not there
* it will usually mean
* that the SA doesn't
* want to collect
* statisitcs. */
else
level = DB_IMPORTANT; /* Unexpected error */
DEBUG(level, msgbuf, errno); /* No log file. */
return FAIL;
} else {
*logfile = fd;
return SUCCESS;
}
}
#ifdef BSD4_2
#include <sys/time.h>
#include <sys/times.h>
#include <sys/resource.h>
static clock_t
scale60(tvp)
register struct timeval *tvp;
{
return (tvp->tv_sec * 60 + tvp->tv_usec / 16667);
}
clock_t
times(tmsp)
register struct tms *tmsp;
{
struct rusage ru;
struct timeval now;
static time_t epoch;
if (getrusage(RUSAGE_SELF, &ru) < 0)
return (clock_t)(-1);
tmsp->tms_utime = scale60(&ru.ru_utime);
tmsp->tms_stime = scale60(&ru.ru_stime);
if (getrusage(RUSAGE_CHILDREN, &ru) < 0)
return (clock_t)(-1);
tmsp->tms_cutime = scale60(&ru.ru_utime);
tmsp->tms_cstime = scale60(&ru.ru_stime);
if (gettimeofday(&now, (struct timezone *)0) < 0)
return (clock_t)(-1);
if (epoch == 0)
epoch = now.tv_sec;
now.tv_sec -= epoch;
return (scale60(&now));
}
#endif /* BSD4_2 */