/*
* Copyright 2000, International Business Machines Corporation and others.
* All Rights Reserved.
- *
+ *
* This software has been released under the terms of the IBM Public
* License. For details, see the LICENSE file in the top-level source
* directory or online at http://www.openafs.org/dl/license10.html
*/
#include <afsconfig.h>
#include <afs/param.h>
+#include <afs/stds.h>
+#include <roken.h>
-#include <stdio.h>
-#include <sys/types.h>
-#include <unistd.h>
-#if !defined(AFS_SUN3_ENV) && !defined(sys_vax_ul43)
-#include <time.h>
-/*#ifdef AFS_AIX_ENV*/
-#include <sys/time.h>
-/*#endif*/
-#include <errno.h>
-#undef abs
-#include <stdlib.h>
-
-#include <string.h>
-
-#include <afs/stds.h>
#include <afs/cmd.h>
#include <afs/afs_args.h>
#include <afs/icl.h>
int afs_64bit_kernel = 1; /* Default for 6.2+, and always for 6.1 */
extern int afs_icl_sizeofLong; /* Used in ICL_SIZEHACK() */
#ifdef AFS_SGI62_ENV
-#include <unistd.h>
/* If _SC_KERN_POINTERS not in sysconf, then we can assume a 32 bit abi. */
void
int icl_CreateSetWithFlags(char *name, struct afs_icl_log *baseLogp,
struct afs_icl_log *fatalLogp, afs_uint32 flags,
struct afs_icl_set **outSetpp);
-int icl_LogHold(register struct afs_icl_log *logp);
-int icl_LogUse(register struct afs_icl_log *logp);
-int icl_LogReleNL(register struct afs_icl_log *logp);
-int icl_LogRele(register struct afs_icl_log *logp);
-int icl_ZeroLog(register struct afs_icl_log *logp);
-int icl_LogFreeUse(register struct afs_icl_log *logp);
+int icl_LogHold(struct afs_icl_log *logp);
+int icl_LogUse(struct afs_icl_log *logp);
+int icl_LogReleNL(struct afs_icl_log *logp);
+int icl_LogRele(struct afs_icl_log *logp);
+int icl_ZeroLog(struct afs_icl_log *logp);
+int icl_LogFreeUse(struct afs_icl_log *logp);
#define BUFFER_MULTIPLIER 1024
int tsize;
rsize = 0;
- ICL_SIZEHACK(type, addr);
+ ICL_SIZEHACK(type, addr, tsize, rsize);
return rsize;
}
static int
CheckTypes(char *bufferp, int *typesp, int typeCount, char *outMsgBuffer)
{
- register char tc;
+ char tc;
int inPercent;
int tix;
* check the type descriptor.
*/
inPercent = 0;
- if (tix > typeCount)
+ if (tix >= typeCount)
return 0; /* no more type descriptors left */
if (tc == 's') {
if (typesp[tix] != 1) /* not a string descriptor */
static int
CheckTypes(char *bufferp, int *typesp, int typeCount)
{
- register char tc;
+ char tc;
int inPercent;
int tix;
#define uint64_t long long
#endif
static void
-DisplayRecord(FILE *outFilep, register afs_int32 *alp, afs_int32 rsize)
+DisplayRecord(FILE *outFilep, afs_int32 *alp, afs_int32 rsize)
{
char msgBuffer[1024];
#if defined(AFS_SGI61_ENV) || (defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL))
#define NO_MESSAGE "THIS IS NOT A MESSAGE"
/*
- * The system-dependant location for the catalog files is defined in sysconf.h
- * RPC_DEFAULT_NLSPATH should be defined in sysconf.h. Otherwise we use
- * /usr/afs/etc/C/%s.cat
+ * We use NLS message catalog functions to convert numbers to human-readable
+ * strings. The message catalog will be in AFSDIR_DATA_DIR, which is
+ * ${datadir}/openafs with normal paths and /usr/vice/etc (for historical
+ * compatibility) for Transarc paths.
*/
-#ifndef RPC_NLS_FORMAT
-#define RPC_NLS_FORMAT "%s.cat"
-#endif
-
void
-dce1_error_inq_text(afs_uint32 status_to_convert,
+dce1_error_inq_text(afs_uint32 status_to_convert,
char *error_text, int *status)
{
unsigned short facility_code;
unsigned short component_code;
unsigned short status_code;
- unsigned short i, failed = 0;
+ unsigned short i;
nl_catd catd;
char component_name[4];
char *facility_name;
char filename_prefix[7];
- char nls_filename[11];
- char alt_filename[80];
+ char nls_filename[80];
char *message;
-#if defined(AFS_64BITPOINTER_ENV)
- long J;
-#else
- int J;
-#endif
static char *facility_names[] = {
"xxx",
"afs"
component_name[i] += (component_name[i] <= 26) ? 'a' : ('0' - 27);
}
sprintf(filename_prefix, "%3s%3s", facility_name, component_name);
- sprintf(nls_filename, RPC_NLS_FORMAT, filename_prefix);
/*
- * Open the message file
+ * We do not use the normal NLS message catalog search path since our use
+ * message catalogs isn't a typical use. It wouldn't make sense to
+ * install this special message catalog in with internationalization
+ * catalogs.
*/
-#if defined(AFS_OSF20_ENV)
- catd = (nl_catd) catopen(nls_filename, 0);
-#else
-#if defined(AFS_64BITPOINTER_ENV)
- J = (long)catopen(nls_filename, 0);
-#else
- J = (int)catopen(nls_filename, 0);
-#endif
- catd = (nl_catd) J;
-#endif
- if (catd == (nl_catd) - 1) {
- /*
- * If we did not succeed in opening message file using NLSPATH,
- * try to open the message file in a well-known default area
- */
- tryagain:
-#ifndef RPC_DEFAULT_NLSPATH
- sprintf(alt_filename, "%s/C/%s.cat", AFSDIR_CLIENT_ETC_DIRPATH,
- filename_prefix);
-#else
- sprintf(alt_filename, RPC_DEFAULT_NLSPATH, filename_prefix);
-#endif
+ snprintf(nls_filename, sizeof(nls_filename), "%s/C/%s.cat",
+ AFSDIR_CLIENT_DATA_DIRPATH, filename_prefix);
-#if defined(AFS_OSF20_ENV)
- catd = (nl_catd) catopen(alt_filename, 0);
-#else
-#if defined(AFS_64BITPOINTER_ENV)
- J = (long)catopen(alt_filename, 0);
-#else
- J = (int)catopen(alt_filename, 0);
-#endif
- catd = (nl_catd) J;
-#endif
- if (catd == (nl_catd) - 1) {
- sprintf((char *)error_text, "status %08x (%s / %s)",
- status_to_convert, facility_name, component_name);
- return;
- }
+ catd = catopen(nls_filename, 0);
+ if (catd == (nl_catd) -1) {
+ sprintf((char *)error_text, "status %08x (%s / %s)",
+ status_to_convert, facility_name, component_name);
+ return;
}
/*
* try to get the specified message from the file
*status = 0;
}
} else {
- if (!failed) {
- failed = 1;
- catclose(catd);
- goto tryagain;
- }
sprintf((char *)error_text, "status %08x (%s / %s)",
status_to_convert, facility_name, component_name);
}
i, (long)tname, sizeof(tname), 0, 0);
if (code) {
if (errno == EBADF) {
- code = 0;
continue; /* missing slot, nothing to worry about */
}
break;
found++;
if (dummy > bufferSize) /* find biggest log */
bufferSize = dummy;
- lip = (struct logInfo *)malloc(sizeof(struct logInfo));
- memset((char *)lip, 0, sizeof(*lip));
+ lip = calloc(1, sizeof(struct logInfo));
lip->nextp = allInfo;
allInfo = lip;
- lip->name = (char *)malloc(strlen(tname) + 1);
- strcpy(lip->name, tname);
+ lip->name = strdup(tname);
}
i = found;
} else {
break;
if (dummy > bufferSize) /* find biggest log */
bufferSize = dummy;
- lip = (struct logInfo *)malloc(sizeof(struct logInfo));
- memset((char *)lip, 0, sizeof(*lip));
+ lip = calloc(1, sizeof(struct logInfo));
lip->nextp = allInfo;
allInfo = lip;
- lip->name = (char *)malloc(strlen(tname) + 1);
- strcpy(lip->name, tname);
+ lip->name = strdup(tname);
}
}
if (bufferSize == 0)
return -1;
- bufferp = (afs_int32 *) malloc(sizeof(afs_int32) * bufferSize);
+ bufferp = malloc(sizeof(afs_int32) * bufferSize);
if (!bufferp)
return -1;
if (bufferSize == 0)
return -1;
- bufferp = (afs_int32 *) malloc(sizeof(afs_int32) * bufferSize);
+ bufferp = malloc(sizeof(afs_int32) * bufferSize);
if (!bufferp) {
(void)fprintf(stderr, "cannot allocate %d words for buffer\n",
bufferSize);
/* have to reallocate a buffer */
bufferSize = newBufferSize;
free(bufferp);
- bufferp = (afs_int32 *) malloc(sizeof(afs_int32) * bufferSize);
+ bufferp = malloc(sizeof(afs_int32) * bufferSize);
if (!bufferp) {
(void)fprintf(stderr, "cannot allocate %d words for buffer\n",
bufferSize);
#if !defined(AFS_SGI_ENV)
int
-afs_syscall(long call, long parm0, long parm1, long parm2, long parm3,
+afs_syscall(long call, long parm0, long parm1, long parm2, long parm3,
long parm4, long parm5, long parm6)
{
- int code, rval;
+ int code;
+#if defined(AFS_DARWIN80_ENV) || defined(AFS_LINUX20_ENV)
+ int rval;
+#endif
#ifdef AFS_LINUX20_ENV
#if defined AFS_LINUX_64BIT_KERNEL
long long eparm[4];
#endif
/* Linux can only handle 5 arguments in the actual syscall. */
if (call == AFSCALL_ICL) {
- rval = proc_afs_syscall(call, parm0, parm1, parm2, eparm, &code);
+ rval = proc_afs_syscall(call, parm0, parm1, parm2, (long)eparm, &code);
if (rval)
code = syscall(AFS_SYSCALL, call, parm0, parm1, parm2, eparm);
} else {
}
int
-icl_CreateSet(char *name, struct afs_icl_log *baseLogp,
+icl_CreateSet(char *name, struct afs_icl_log *baseLogp,
struct afs_icl_log *fatalLogp, struct afs_icl_set **outSetpp)
{
return icl_CreateSetWithFlags(name, baseLogp, fatalLogp, /*flags */ 0,
* those references will be released.
*/
int
-icl_CreateSetWithFlags(char *name, struct afs_icl_log *baseLogp,
- struct afs_icl_log *fatalLogp, afs_uint32 flags,
+icl_CreateSetWithFlags(char *name, struct afs_icl_log *baseLogp,
+ struct afs_icl_log *fatalLogp, afs_uint32 flags,
struct afs_icl_set **outSetpp)
{
- register struct afs_icl_set *setp;
- register int i;
+ struct afs_icl_set *setp;
+ int i;
afs_int32 states = ICL_DEFAULT_SET_STATES;
if (!icl_inited)
if (flags & ICL_CRSET_FLAG_PERSISTENT)
states |= ICL_SETF_PERSISTENT;
- setp = (struct afs_icl_set *)osi_Alloc(sizeof(struct afs_icl_set));
+ setp = osi_Alloc(sizeof(struct afs_icl_set));
memset((caddr_t) setp, 0, sizeof(*setp));
setp->refCount = 1;
if (states & ICL_SETF_FREED)
states &= ~ICL_SETF_ACTIVE; /* if freed, can't be active */
setp->states = states;
- setp->name = (char *)osi_Alloc(strlen(name) + 1);
+ setp->name = osi_Alloc(strlen(name) + 1);
strcpy(setp->name, name);
setp->nevents = ICL_DEFAULTEVENTS;
- setp->eventFlags = (char *)osi_Alloc(ICL_DEFAULTEVENTS);
+ setp->eventFlags = osi_Alloc(ICL_DEFAULTEVENTS);
for (i = 0; i < ICL_DEFAULTEVENTS; i++)
setp->eventFlags[i] = 0xff; /* default to enabled */
/* hold and release event sets */
int
-icl_SetHold(register struct afs_icl_set *setp)
+icl_SetHold(struct afs_icl_set *setp)
{
setp->refCount++;
return 0;
/* free a set. Called with icl_lock locked */
int
-icl_ZapSet(register struct afs_icl_set *setp)
+icl_ZapSet(struct afs_icl_set *setp)
{
- register struct afs_icl_set **lpp, *tp;
+ struct afs_icl_set **lpp, *tp;
int i;
- register struct afs_icl_log *tlp;
+ struct afs_icl_log *tlp;
for (lpp = &icl_allSets, tp = *lpp; tp; lpp = &tp->nextp, tp = *lpp) {
if (tp == setp) {
/* do the release, watching for deleted entries */
int
-icl_SetRele(register struct afs_icl_set *setp)
+icl_SetRele(struct afs_icl_set *setp)
{
if (--setp->refCount == 0 && (setp->states & ICL_SETF_DELETED)) {
icl_ZapSet(setp); /* destroys setp's lock! */
/* free a set entry, dropping its reference count */
int
-icl_SetFree(register struct afs_icl_set *setp)
+icl_SetFree(struct afs_icl_set *setp)
{
setp->states |= ICL_SETF_DELETED;
icl_SetRele(setp);
struct afs_icl_set *
icl_FindSet(char *name)
{
- register struct afs_icl_set *tp;
+ struct afs_icl_set *tp;
for (tp = icl_allSets; tp; tp = tp->nextp) {
if (strcmp(tp->name, name) == 0) {
int
icl_ZeroSet(struct afs_icl_set *setp)
{
- register int i;
+ int i;
int code = 0;
int tcode;
struct afs_icl_log *logp;
}
int
-icl_EnumerateSets(int (*aproc) (char *, void *, struct afs_icl_set *),
+icl_EnumerateSets(int (*aproc) (char *, void *, struct afs_icl_set *),
void *arock)
{
- register struct afs_icl_set *tp, *np;
- register afs_int32 code;
+ struct afs_icl_set *tp, *np;
+ afs_int32 code;
code = 0;
for (tp = icl_allSets; tp; tp = np) {
int
icl_AddLogToSet(struct afs_icl_set *setp, struct afs_icl_log *newlogp)
{
- register int i;
+ int i;
int code = -1;
for (i = 0; i < ICL_LOGSPERSET; i++) {
break;
case ICL_OP_SS_FREE: /* deassert design for log */
- /*
+ /*
* if we are already in this state, do nothing; otherwise
* deassert desire for log
*/
/* hold and release logs */
int
-icl_LogHold(register struct afs_icl_log *logp)
+icl_LogHold(struct afs_icl_log *logp)
{
logp->refCount++;
return 0;
/* hold and release logs, called with lock already held */
int
-icl_LogHoldNL(register struct afs_icl_log *logp)
+icl_LogHoldNL(struct afs_icl_log *logp)
{
logp->refCount++;
return 0;
/* keep track of how many sets believe the log itself is allocated */
int
-icl_LogUse(register struct afs_icl_log *logp)
+icl_LogUse(struct afs_icl_log *logp)
{
if (logp->setCount == 0) {
/* this is the first set actually using the log -- allocate it */
/* we weren't passed in a hint and it wasn't set */
logp->logSize = ICL_DEFAULT_LOGSIZE;
}
- logp->datap =
- (afs_int32 *) osi_Alloc(sizeof(afs_int32) * logp->logSize);
+ logp->datap = osi_Alloc(sizeof(afs_int32) * logp->logSize);
}
logp->setCount++;
return 0;
/* decrement the number of real users of the log, free if possible */
int
-icl_LogFreeUse(register struct afs_icl_log *logp)
+icl_LogFreeUse(struct afs_icl_log *logp)
{
if (--logp->setCount == 0) {
/* no more users -- free it (but keep log structure around) */
/* set the size of the log to 'logSize' */
int
-icl_LogSetSize(register struct afs_icl_log *logp, afs_int32 logSize)
+icl_LogSetSize(struct afs_icl_log *logp, afs_int32 logSize)
{
if (!logp->datap) {
/* nothing to worry about since it's not allocated */
/* free and allocate a new one */
osi_Free(logp->datap, sizeof(afs_int32) * logp->logSize);
- logp->datap = (afs_int32 *) osi_Alloc(sizeof(afs_int32) * logSize);
+ logp->datap = osi_Alloc(sizeof(afs_int32) * logSize);
logp->logSize = logSize;
}
/* free a log. Called with icl_lock locked. */
int
-icl_ZapLog(register struct afs_icl_log *logp)
+icl_ZapLog(struct afs_icl_log *logp)
{
- register struct afs_icl_log **lpp, *tp;
+ struct afs_icl_log **lpp, *tp;
for (lpp = &afs_icl_allLogs, tp = *lpp; tp; lpp = &tp->nextp, tp = *lpp) {
if (tp == logp) {
/* do the release, watching for deleted entries */
int
-icl_LogRele(register struct afs_icl_log *logp)
+icl_LogRele(struct afs_icl_log *logp)
{
if (--logp->refCount == 0 && (logp->states & ICL_LOGF_DELETED)) {
icl_ZapLog(logp); /* destroys logp's lock! */
/* do the release, watching for deleted entries, log already held */
int
-icl_LogReleNL(register struct afs_icl_log *logp)
+icl_LogReleNL(struct afs_icl_log *logp)
{
if (--logp->refCount == 0 && (logp->states & ICL_LOGF_DELETED)) {
icl_ZapLog(logp); /* destroys logp's lock! */
/* zero out the log */
int
-icl_ZeroLog(register struct afs_icl_log *logp)
+icl_ZeroLog(struct afs_icl_log *logp)
{
logp->firstUsed = logp->firstFree = 0;
logp->logElements = 0;
/* free a log entry, and drop its reference count */
int
-icl_LogFree(register struct afs_icl_log *logp)
+icl_LogFree(struct afs_icl_log *logp)
{
logp->states |= ICL_LOGF_DELETED;
icl_LogRele(logp);
(char *name, void *arock, struct afs_icl_log * tp),
void *arock)
{
- register struct afs_icl_log *tp;
- register afs_int32 code;
+ struct afs_icl_log *tp, *np;
+ afs_int32 code;
code = 0;
- for (tp = afs_icl_allLogs; tp; tp = tp->nextp) {
+ for (tp = afs_icl_allLogs; tp; tp = np) {
tp->refCount++; /* hold this guy */
+ np = tp->nextp;
code = (*aproc) (tp->name, arock, tp);
if (--tp->refCount == 0)
icl_ZapLog(tp);
sizeof(afs_icl_bulkSetinfo_t) + (ICL_RPC_MAX_SETS -
1) * sizeof(afs_icl_setinfo_t);
if (!setInfo) {
- setInfo = (afs_icl_bulkSetinfo_t *) malloc(infoSize);
+ setInfo = calloc(1, infoSize);
if (!setInfo) {
(void)fprintf(stderr,
"Could not allocate the memory for bulk set info structure\n");
exit(1);
}
}
- memset((char *)setInfo, 0, infoSize);
return setInfo;
}
sizeof(afs_icl_bulkLoginfo_t) + (ICL_RPC_MAX_LOGS -
1) * sizeof(afs_icl_loginfo_t);
if (!logInfo) {
- logInfo = (afs_icl_bulkLoginfo_t *) malloc(infoSize);
+ logInfo = calloc(1, infoSize);
if (!logInfo) {
(void)fprintf(stderr,
"Could not allocate the memory for bulk log info structure\n");
}
}
- memset((char *)logInfo, 0, infoSize);
return logInfo;
}
dumpSyntax =
cmd_CreateSyntax("dump", DoDump, NULL, "dump AFS trace logs");
- (void)cmd_AddParm(dumpSyntax, "-set", CMD_LIST, CMD_OPTIONAL, "set_name");
+ (void)cmd_AddParm(dumpSyntax, "-set", CMD_LIST, CMD_OPTIONAL,
+ "event set name");
(void)cmd_AddParm(dumpSyntax, "-follow", CMD_SINGLE, CMD_OPTIONAL,
- "log_name");
+ "trace log name");
(void)cmd_AddParm(dumpSyntax, "-file", CMD_SINGLE, CMD_OPTIONAL,
- "output_filename");
+ "path to trace log file for writing");
(void)cmd_AddParm(dumpSyntax, "-sleep", CMD_SINGLE, CMD_OPTIONAL,
- "seconds_between_reads");
+ "interval (secs) for writes when using -follow");
}
+
static int
-DoShowLog(register struct cmd_syndesc *as, void *arock)
+DoShowLog(struct cmd_syndesc *as, void *arock)
{
afs_int32 retVal = 0;
afs_int32 code = 0;
showSyntax =
cmd_CreateSyntax("lslog", DoShowLog, NULL,
"list available logs");
- (void)cmd_AddParm(showSyntax, "-set", CMD_LIST, CMD_OPTIONAL, "set_name");
- (void)cmd_AddParm(showSyntax, "-log", CMD_LIST, CMD_OPTIONAL, "log_name");
- (void)cmd_AddParm(showSyntax, "-long", CMD_FLAG, CMD_OPTIONAL, "");
+ (void)cmd_AddParm(showSyntax, "-set", CMD_LIST, CMD_OPTIONAL,
+ "event set name");
+ (void)cmd_AddParm(showSyntax, "-log", CMD_LIST, CMD_OPTIONAL,
+ "trace log name");
+ (void)cmd_AddParm(showSyntax, "-long", CMD_FLAG, CMD_OPTIONAL,
+ "show defined log size in kbytes & if it is allocated in kernel mem");
}
static int
-DoShowSet(register struct cmd_syndesc *as, void *arock)
+DoShowSet(struct cmd_syndesc *as, void *arock)
{
afs_int32 retVal = 0;
afs_int32 code = 0;
showSyntax =
cmd_CreateSyntax("lsset", DoShowSet, NULL,
"list available event sets");
- (void)cmd_AddParm(showSyntax, "-set", CMD_LIST, CMD_OPTIONAL, "set_name");
+ (void)cmd_AddParm(showSyntax, "-set", CMD_LIST, CMD_OPTIONAL,
+ "event set name");
}
static int
-DoClear(register struct cmd_syndesc *as, void *arock)
+DoClear(struct cmd_syndesc *as, void *arock)
{
afs_int32 retVal = 0;
afs_int32 code = 0;
cmd_CreateSyntax("clear", DoClear, NULL,
"clear logs by logname or by event set");
(void)cmd_AddParm(clearSyntax, "-set", CMD_LIST, CMD_OPTIONAL,
- "set_name");
+ "event set name");
(void)cmd_AddParm(clearSyntax, "-log", CMD_LIST, CMD_OPTIONAL,
- "log_name");
+ "trace log name");
}
static int
-DoSet(register struct cmd_syndesc *as, void *arock)
+DoSet(struct cmd_syndesc *as, void *arock)
{
afs_int32 retVal = 0;
afs_int32 code = 0;
setSyntax =
cmd_CreateSyntax("setset", DoSet, NULL,
"set state of event sets");
- (void)cmd_AddParm(setSyntax, "-set", CMD_LIST, CMD_OPTIONAL, "set_name");
- (void)cmd_AddParm(setSyntax, "-active", CMD_FLAG, CMD_OPTIONAL, "");
- (void)cmd_AddParm(setSyntax, "-inactive", CMD_FLAG, CMD_OPTIONAL, "");
- (void)cmd_AddParm(setSyntax, "-dormant", CMD_FLAG, CMD_OPTIONAL, "");
+ (void)cmd_AddParm(setSyntax, "-set", CMD_LIST, CMD_OPTIONAL,
+ "event set name");
+ (void)cmd_AddParm(setSyntax, "-active", CMD_FLAG, CMD_OPTIONAL,
+ "enable tracing for event set & allocate kernel memory");
+ (void)cmd_AddParm(setSyntax, "-inactive", CMD_FLAG, CMD_OPTIONAL,
+ "disables tracing for event set, keep kernel memory");
+ (void)cmd_AddParm(setSyntax, "-dormant", CMD_FLAG, CMD_OPTIONAL,
+ "disable tracing for event set & free kernel memory");
}
static int
-DoResize(register struct cmd_syndesc *as, void *arock)
+DoResize(struct cmd_syndesc *as, void *arock)
{
afs_int32 retVal = 0;
afs_int32 code = 0;
cmd_CreateSyntax("setlog", DoResize, NULL,
"set the size of a log");
(void)cmd_AddParm(setsizeSyntax, "-log", CMD_LIST, CMD_OPTIONAL,
- "log_name");
+ "trace log name");
(void)cmd_AddParm(setsizeSyntax, "-buffersize", CMD_SINGLE, CMD_REQUIRED,
- "1-kilobyte_units");
+ "# of 1-kbyte blocks to allocate for log");
}
#include "AFS_component_version_number.c"
return (cmd_Dispatch(argc, argv));
}
-#else
-#include "AFS_component_version_number.c"
-
-int
-main(int argc, char *argv[])
-{
- printf("fstrace is NOT supported for this OS\n");
-}
-#endif