/*
* 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>
-RCSID
- ("$Header$");
-
-#include <stdio.h>
-#include <sys/types.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 <roken.h>
-#include <afs/stds.h>
#include <afs/cmd.h>
#include <afs/afs_args.h>
#include <afs/icl.h>
#include <afs/afsutil.h>
+#include <rx/rx.h>
+#include <afs/vice.h>
+#include <afs/sys_prototypes.h>
#if defined(AFS_OSF_ENV) || defined(AFS_SGI61_ENV) || (defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL))
/* For SGI 6.2, this is changed to 1 if it's a 32 bit kernel. */
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
#endif /* AFS_SGI62_ENV */
#endif /* AFS_SGI61_ENV */
+int afs_syscall(long call, long parm0, long parm1, long parm2, long parm3,
+ long parm4, long parm5, long parm6);
+void dce1_error_inq_text(afs_uint32 status_to_convert,
+ char *error_text, int *status);
+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(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
/* make it big enough to snapshot everything at once, since
char dumpFileName[256] = "";
void
-RegisterIclDumpFileName(name)
- char *name;
+RegisterIclDumpFileName(char *name)
{
(void)sprintf(dumpFileName, "icl.%.250s", name);
}
/* given a type and an address, get the size of the thing
* in words.
*/
-static
-icl_GetSize(type, addr)
- afs_int32 type;
- char *addr;
+static int
+icl_GetSize(afs_int32 type, char *addr)
{
int rsize;
int tsize;
rsize = 0;
- ICL_SIZEHACK(type, addr);
+ ICL_SIZEHACK(type, addr, tsize, rsize);
return rsize;
}
*/
#if defined(AFS_SGI61_ENV) || (defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL))
static int
-CheckTypes(bufferp, typesp, typeCount, outMsgBuffer)
- char *bufferp;
- int *typesp;
- int typeCount;
- char *outMsgBuffer;
+CheckTypes(char *bufferp, int *typesp, int typeCount, char *outMsgBuffer)
{
- register char tc;
+ char tc;
int inPercent;
int tix;
/* not reached */
}
#else /* AFS_SGI61_ENV */
-static
-CheckTypes(bufferp, typesp, typeCount)
- char *bufferp;
- int *typesp;
- int typeCount;
+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(outFilep, alp, rsize)
- 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))
int pftix; /* index in printfTypes */
int status;
int printed; /* did we print the string yet? */
- afs_int32 *tlp;
time_t tmv;
/* decode parameters */
#endif
#include <nl_types.h>
-#if defined(AFS_OSF_ENV) && !defined(AFS_OSF20_ENV)
-#include <fcntl.h>
-static nl_catd catopen1();
-nl_catd NLcatopen();
-static nl_catd _do1_open();
-static nl_catd cat_already_open();
-static int make_sets();
-static FILE *open1catfile();
-static void add_open_cat();
-static void cat_hard_close();
-extern char *strchr();
-
-static int catpid[NL_MAXOPEN];
-static CATD *catsopen[NL_MAXOPEN];
-#define PATH_FORMAT "/usr/lib/nls/msg/%L/%N:/etc/nls/msg/%L/%N"
-#define DEFAULT_LANG "C"
-#define TOO_MANY_HOLES(num_holes, num_non_holes) \
- (((num_holes) > 100) && ((num_holes) > (num_non_holes)))
-
-char *
-rmalloc(n)
- int n;
-
- /*---- n: the number of bytes to be malloc'ed ----*/
-{
- char *t;
-
- t = (char *)malloc(n);
- if (!t)
- printf("Failed to get mem\n");
- return (t);
-}
-
-#ifdef notdef
-#endif
-nl_catd
-catopen1(cat, dummy)
- char *cat;
- int dummy;
- /*---- char *cat: the name of the cat to be opened ----*/
- /*---- int dummy: dummy variable ----*/
-
-{
- int errno_save;
- nl_catd _do_open(); /*---- routine that actually opens
- the catalog ---- */
- CATD *catd;
-
- errno_save = errno;
-
-/*
- if (catd = cat_already_open(cat)) {
- catd->_count = catd->_count + 1;
- return(catd);
- }
-*/
- catd = (CATD *) rmalloc(sizeof(CATD));
- if (catd == NULL)
- return (CATD_ERR);
- catd->_name = (char *)rmalloc(strlen(cat) + 1);
- if (catd->_name == NULL)
- return (CATD_ERR);
- strcpy(catd->_name, cat);
- catd->_fd = FALSE;
- catd->_magic = CAT_MAGIC;
- catd->_mem = FALSE;
-#ifndef AFS_OSF20_ENV
- catd->_pid = getpid();
-#endif
- catd->_count = 1;
- if (_do1_open(catd) != CATD_ERR)
- return (catd);
- else {
- free(catd->_name);
- free(catd);
- return (CATD_ERR);
- }
-}
-
-
-
-nl_catd
-_do1_open(catd)
- nl_catd catd;
-
- /*---- pointer to the partially set up cat descriptor ----*/
-
-{
- int make_sets(); /*---- routine to unpack the sets into
- fast acccess mode ----*/
- void add_open_cat(); /*---- routine to keep a list of
- opened cats ----*/
- /*long */ int magic;
- int i; /*---- Misc counter(s) used for loop */
- struct _catset cs;
- int errno_save;
- int num_holes;
-
- errno_save = errno;
-
- catd->_fd = open1catfile(catd->_name);
- if (!catd->_fd) {
- return (CATD_ERR);
- }
- fread((void *)&magic, (size_t) 4, (size_t) 1, catd->_fd);
- if (magic != CAT_MAGIC) {
- printf("Magic was %x instead of %x -> %x\n", magic, CAT_MAGIC,
- CATD_ERR);
-/*
- fclose(catd->_fd);
- catd->_fd = NULL;
- return( CATD_ERR );
-*/
- }
-/* if ((catd->_mem = shmat((int)fileno(catd->_fd), NULL, SHM_MAP | SHM_RDONLY))
- == (char * )ERR ) { */
-
- if (1) { /* disable the shmat, share memory segemnt */
-
-/*______________________________________________________________________
- If the file can not be mapped then simulate mapping for the index
- table so that make_sets cat set things up. (rmalloc an area big
- enough for the index table and read the whole thing in)
- ______________________________________________________________________*/
-
- /* reset the file pointer to the beginning of catalog */
- fseek(catd->_fd, (long)0, 0);
-
- /* malloc the header, if fails return error */
- catd->_hd = (struct _header *)rmalloc(sizeof(struct _header));
- if (catd->_hd == NULL)
- return (CATD_ERR);
-
- /* read in the whole header */
- fread((void *)catd->_hd, (size_t) sizeof(struct _header), (size_t) 1,
- catd->_fd);
-
- /* cs is a dummpy to hold a set temperorily. The purpose of */
- /* this for loop is to fread the whole catalog so that the */
- /* file pointer will be moved to the end of the catalog. */
- for (i = 0; i < catd->_hd->_n_sets; i++) {
- fread((void *)&cs, (size_t) 4, (size_t) 1, catd->_fd);
- fseek(catd->_fd, (long)(cs._n_msgs * sizeof(struct _msgptr)), 1);
- }
-
- /* after the for loop, ftell returns the byte offset of the */
- /* end of the catalog relative to the begining of the file. */
- /* i.e. i contains the byte offset of the whole catalog. */
- i = ftell(catd->_fd);
-
- /* malloc _mem as a temp pointer to hold the entire catalog. */
- catd->_mem = (char *)rmalloc(i);
- if (catd->_mem == NULL)
- return (CATD_ERR);
-
- /* reset the file pointer to the begining. */
- fseek(catd->_fd, (long)0, 0);
-
- /* read in the whole catalog into _mem */
- fread((void *)catd->_mem, (size_t) i, (size_t) 1, catd->_fd);
-
- /*
- * If there aren't many holes in the set numbers,
- * fully expand the compacted set array from the
- * catalog. Then in catgets(), we'll be able to use
- * the set number to index directly into the expanded
- * array.
- *
- * If there are a lot of holes, leave the set array
- * compacted. In catgets(), we'll search through it
- * for the requested set.
- */
-
- num_holes = catd->_hd->_setmax - catd->_hd->_n_sets;
- if (!TOO_MANY_HOLES(num_holes, catd->_hd->_n_sets)) {
- catd->_sets_expanded = TRUE;
- catd->_n_sets = catd->_hd->_setmax;
- } else {
- catd->_sets_expanded = FALSE;
- catd->_n_sets = catd->_hd->_n_sets - 1;
- }
-
- /* malloc one extra set more than the max. set index */
- catd->_set =
- (struct _catset *)rmalloc((catd->_n_sets + 1) *
- sizeof(struct _catset));
- if (catd->_set == NULL)
- return (CATD_ERR);
-
- /* save the max. set number in catd->_setmax */
- catd->_setmax = catd->_hd->_setmax;
- /* call make_set to malloc memory for every message */
- if (make_sets(catd) == -1)
- return (CATD_ERR);
- free(catd->_mem);
- catd->_mem = FALSE;
- add_open_cat(catd);
- return (catd);
- } else {
-
-/*______________________________________________________________________
- Normal mapping has occurred, set a few things up and call make_sets
- ______________________________________________________________________*/
-
- catd->_hd = (struct _header *)(catd->_mem);
- catd->_setmax = catd->_hd->_setmax;
- catd->_set =
- (struct _catset *)rmalloc((catd->_hd->_setmax + 1) *
- sizeof(struct _catset));
- if (catd->_set == NULL)
- return (CATD_ERR);
- if (make_sets(catd) == -1)
- return (CATD_ERR);
- add_open_cat(catd);
- return (catd);
- }
-}
-
-
-static void
-add_open_cat(catd)
- nl_catd catd;
- /*---- catd to be added to the list of catalogs ----*/
-
-{
- int i = 0; /*---- Misc counter(s) used for loops ----*/
- while (i < NL_MAXOPEN && catsopen[i]) {
- if (!strcmp(catd->_name, catsopen[i]->_name)
-#ifndef AFS_OSF20_ENV
- && getpid() == catsopen[i]->_pid)
-#else
- )
-#endif
- return; /*---- The catalog is already here ----*/
- i++;
- }
-
- if (i < NL_MAXOPEN) {
- catsopen[i] = catd;
- catpid[i] = getpid();
- }
-}
-
-
-/*
- *
- * NAME: make_sets
- *
- * FUNCTION: Expands the compacted version of the catalog index table into
- * the fast access memory version.
- *
- * EXECUTION ENVIRONMENT:
- *
- * Make_set executes under a process.
- *
- * RETURNS: int
- */
-
-
-static int
-make_sets(catd)
- nl_catd catd;
-{
- struct _catset *cset;
- char *base = catd->_mem;
- int n_sets = catd->_hd->_n_sets;
- int i; /*---- Misc counter(s) used for loops ----*/
- int j; /*---- Misc counter(s) used for loops ----*/
- int msgmax; /*---- The maximum number of _messages in a set ----*/
- char *cmpct_set_ptr; /*---- pointer into the index table ----*/
- struct _catset cs; /*---- used to look at the sets in the table -*/
- int num_holes;
-
- cmpct_set_ptr = base + sizeof(struct _header);
-
- for (i = 0; i < n_sets; i++) {
- /* loop through each compacted set */
-
- cs = *(struct _catset *)cmpct_set_ptr;
- /* set the _catset ptr to the base of the current
- * compacted set. */
-
- cs._mp =
- (struct _msgptr *)(cmpct_set_ptr + 2 * sizeof(unsigned short));
- /* set the ms array ptr to the base of
- * compacted array of _msgptr's */
-
- cset =
- (catd->_sets_expanded) ? &catd->_set[cs._setno] : &catd->_set[i];
-
- /*
- * If there aren't many holes in the message numbers,
- * fully expand the compacted message array from the
- * catalog. Then in catgets(), we'll be able to use
- * the message number to index directly into the
- * expanded array.
- *
- * If there are many holes, leave the message array
- * compacted. In catgets(), we'll search through it
- * for the requested message.
- */
-
- msgmax = cs._mp[cs._n_msgs - 1]._msgno;
- num_holes = msgmax - cs._n_msgs;
- if (!TOO_MANY_HOLES(num_holes, cs._n_msgs)) {
- cset->_msgs_expanded = TRUE;
- cset->_n_msgs = msgmax;
- } else {
- cset->_msgs_expanded = FALSE;
- cset->_n_msgs = cs._n_msgs - 1;
- }
-
- cset->_mp =
- (struct _msgptr *)rmalloc((1 + cset->_n_msgs) *
- sizeof(struct _msgptr));
- if (cset->_mp == NULL)
- return (-1);
-
- cset->_msgtxt =
- (char **)rmalloc((1 + cset->_n_msgs) * sizeof(char *));
- if (cset->_msgtxt == NULL)
- return (-1);
-
- if (cset->_msgs_expanded) {
- for (j = 0; j < cs._n_msgs; j++) {
- cset->_mp[cs._mp[j]._msgno] = cs._mp[j];
- }
- } else {
- for (j = 0; j < cs._n_msgs; j++) {
- cset->_mp[j] = cs._mp[j];
- }
- }
-
- cset->_setno = cs._setno;
- /* Superfluous but should have the correct data. Increment
- * the base of the set pointer. */
-
- cmpct_set_ptr +=
- 2 * sizeof(unsigned short) + cs._n_msgs * sizeof(struct _msgptr);
- }
- return (0);
-}
-
-
-
-/*
- *
- * NAME: opencatfile
- *
- * FUNCTION: Opens a catalog file, looking in the language path first (if
- * there is no slash) and returns a pointer to the file stream.
- *
- * EXECUTION ENVIRONMENT:
- *
- * Opencatfile executes under a process.
- *
- * RETURNS: Returns a pointer to the file stream, and a NULL pointer on
- * failure.
- */
-
-static FILE *
-open1catfile(file)
- char *file;
-{
- extern char *getenv();
- char fl[PATH_MAX]; /*---- place to hold full path ----*/
- char *nlspath; /*---- pointer to the nlspath val ----*/
- FILE *fp; /*---- file pointer ----*/
- char cpth[PATH_MAX]; /*---- current value of nlspath ----*/
- char *p, *np;
- char *fulllang; /* %L language value */
- char lang[PATH_MAX]; /* %l language value */
- char *territory; /* %t language value */
- char *codeset; /* %c language value */
- char *ptr; /* for decompose of $LANG */
- char *str;
- char *optr;
- int nchars;
- int lenstr;
- char outptr[PATH_MAX];
- int valid;
-
- if (strchr(file, '/')) {
- if ((fp = fopen(file, "r"))) {
- fcntl(fileno(fp), F_SETFD, 1);
- /* set the close-on-exec flag for
- * child process */
- return (fp);
- }
- } else {
- if (!(nlspath = getenv("NLSPATH")))
- nlspath = PATH_FORMAT;
- if (!(fulllang = getenv("LANG")))
- fulllang = DEFAULT_LANG;
- if (fulllang == DEFAULT_LANG)
- nlspath = PATH_FORMAT; /* if fullang is C, use the
- * the default nlspath: */
-
- /*
- ** LANG is a composite of three fields:
- ** language_territory.codeset
- ** and we're going to break it into those
- ** three fields.
- */
-
- strcpy(lang, fulllang);
-
- territory = "";
- codeset = "";
-
- ptr = strchr(lang, '_');
- if (ptr != NULL) {
- territory = ptr + 1;
- *ptr = '\0';
- ptr = strchr(territory, '.');
- if (ptr != NULL) {
- codeset = ptr + 1;
- *ptr = '\0';
- }
- } else {
- ptr = strchr(lang, '.');
- if (ptr != NULL) {
- codeset = ptr + 1;
- *ptr = '\0';
- }
- }
-
- np = nlspath;
- while (*np) {
- p = cpth;
- while (*np && *np != ':')
- *p++ = *np++;
- *p = '\0';
- if (*np) /*---- iff on a colon then advance --*/
- np++;
- valid = 0;
- if (strlen(cpth)) {
- ptr = cpth;
- optr = outptr;
-
- nchars = 0;
- while (*ptr != '\0') {
- while ((*ptr != '\0') && (*ptr != '%')
- && (nchars < PATH_MAX)) {
- *(optr++) = *(ptr++);
- nchars++;
- }
- if (*ptr == '%') {
- switch (*(++ptr)) {
- case '%':
- str = "%";
- break;
- case 'L':
- str = fulllang;
- break;
- case 'N':
- valid = 1;
- str = file;
- break;
- case 'l':
- str = lang;
- break;
- case 't':
- str = territory;
- break;
- case 'c':
- str = codeset;
- break;
- default:
- str = "";
- break;
- }
- lenstr = strlen(str);
- nchars += lenstr;
- if (nchars < PATH_MAX) {
- strcpy(optr, str);
- optr += lenstr;
- } else {
- break;
- }
- ptr++;
- } else {
- if (nchars >= PATH_MAX) {
- break;
- }
- }
- }
- *optr = '\0';
- strcpy(cpth, outptr);
- } else { /*---- iff leading | trailing |
- adjacent colons ... --*/
- valid = 1;
- strcpy(cpth, file);
- }
- if (valid == 1 && (fp = fopen(cpth, "r"))) {
- fcntl(fileno(fp), F_SETFD, 1);
- /* set the close-on-exec flag for
- * child process */
- return (fp);
- }
- }
- if (fp = fopen(file, "r")) {
- fcntl(fileno(fp), F_SETFD, 1);
- /* set the close-on-exec flag for
- * child process */
- return (fp);
- }
- }
- return (NULL);
-}
-
-
-
-
-
-/*
- *
- * NAME: cat_already_open
- *
- * FUNCTION: Checkes to see if a specific cat has already been opened.
- *
- * EXECUTION ENVIRONMENT:
- *
- * Cat_already_open executes under a process.
- *
- * RETURNS: Returns a pointer to the existing CATD if one exists, and
- * a NULL pointer if no CATD exists.
- */
-
-static nl_catd
-cat_already_open(cat)
- char *cat;
- /*---- name of the catalog to be opened ----*/
-
-{
- int i; /*---- Misc counter(s) used for loops ----*/
-
- for (i = 0; i < NL_MAXOPEN && catsopen[i]; i++) {
-#ifndef AFS_OSF20_ENV
- if (!strcmp(cat, catsopen[i]->_name) && getpid() == catsopen[i]->_pid) {
-#else
- if (!strcmp(cat, catsopen[i]->_name)) {
-#endif
- return (catsopen[i]);
- }
- }
- return (0);
-}
-
-
-int
-catclose1(catd) /*---- the catd to be closed ----*/
- nl_catd catd; /*---- the catd to be closed ----*/
-
-{
- int i;
-
-
- if (catd == CATD_ERR)
- return (-1);
- for (i = 0; i < NL_MAXOPEN && catsopen[i]; i++) {
-#ifndef AFS_OSF20_ENV
- if (catd == catsopen[i] && getpid() == catsopen[i]->_pid)
-#else
- if (catd == catsopen[i])
-#endif
- break;
- }
- if (i == NL_MAXOPEN || catsopen[i] == NULL)
- return (-1);
- if (catd->_fd == (FILE *) NULL)
- /*---- return if this is an extra open or
- a bad catalog discriptor ----*/
- return (-1);
- if (cat_already_open(catd->_name)) {
- if (catd->_count == 1) {
- cat_hard_close(catd);
- return (0); /*--- the last legal clsoe ---*/
- } else if (catd->_count > 1) {
- catd->_count = catd->_count - 1;
- return (0); /*--- a legal close ---*/
- } else
- return (-1); /*--- an extra illegal close ---*/
- } else {
- return (-1);
- }
-}
-
-static void
-cat_hard_close(catd)
- nl_catd catd;
- /*---- the catd to be closed ----*/
-
-{
- int i; /*---- Misc counter(s) used for loops ----*/
- int j; /*---- Misc counter ----*/
-
- if (catd == CATD_ERR)
- return;
-
-/*______________________________________________________________________
- remove any entry for the catalog in the catsopen array
- ______________________________________________________________________*/
-
- for (i = 0; i < NL_MAXOPEN && catsopen[i]; i++) {
- if (catd == catsopen[i]) {
- for (; i < NL_MAXOPEN - 1; i++) {
- catsopen[i] = catsopen[i + 1];
- catpid[i] = catpid[i + 1];
- }
- catsopen[i] = NULL;
- catpid[i] = 0;
- }
- }
-
-/*______________________________________________________________________
- close the cat and free up the memory
- ______________________________________________________________________*/
- if (catd->_mem == FALSE) {
- for (i = 0; i <= catd->_n_sets; i++) {
- if (catd->_set[i]._mp)
- free(catd->_set[i]._mp);
- /*---- free the _message pointer arrays ----*/
-
- if (catd->_set[i]._msgtxt) {
- for (j = 0; j <= catd->_set[i]._n_msgs; j++) {
- if (catd->_set[i]._msgtxt[j]) {
-/* free(catd->_set[i]._msgtxt[j]);*/
- }
- }
- if (catd->_set[i]._msgtxt)
- free(catd->_set[i]._msgtxt);
- }
- }
- }
-
- if (catd->_fd)
- fclose(catd->_fd); /*---- close the ctatlog ----*/
- if (catd->_set)
- free(catd->_set); /*---- free the sets ----*/
- if (catd->_name)
- free(catd->_name); /*---- free the name ----*/
- if (catd->_hd)
- free(catd->_hd); /*---- free the header ----*/
- if (catd)
- free(catd); /*---- free the catd ----*/
-}
-
-static char *
-_do1_read_msg(nl_catd catd, int setno, int msgno)
-
- /*---- catd: the catd of the catalog to be read from ----*/
- /*---- setno: the set number of the message ----*/
- /*---- msgno: the msgno of the message ----*/
-{
- nl_catd catd1; /*--- catd for different process ----*/
- char *_read1_msg();
-
-#ifndef AFS_OSF20_ENV
- if (getpid() == catd->_pid)
-#else
- if (1)
-#endif
- return (_read1_msg(catd, setno, msgno));
- else {
- /*
- * Since our pid is different from the one in
- * catd, catd must have come from a catopen()
- * in our parent. We need a catd of our own.
- * The first time through here, the call to
- * catopen() creates a new catd and we try to
- * open its message catalog. After that, the
- * catopen() just retrieves the catd.
- */
- if (((catd1 = catopen1(catd->_name, 0)) != CATD_ERR)
- && ((catd1->_fd == NL_FILE_CLOSED && _do1_open(catd1) != CATD_ERR)
- || (catd1->_fd != NL_FILE_UNUSED)))
- return (_read1_msg(catd1, setno, msgno));
- else
- return (NULL);
- }
-}
-
-
-struct _catset *_cat1_get_catset();
-static struct _msgptr *_cat1_get_msgptr();
-static char *
-_read1_msg(nl_catd catd, int setno, int msgno)
-{
- struct _catset *set; /*--- ptr to set's _catset structure ---*/
- struct _msgptr *msg; /*--- ptr to msg's _msgptr structure ---*/
- char **msgtxt; /*--- temporary pointer to the message text
- for speed. ----*/
-
- set = _cat1_get_catset(catd, setno);
- if (set) {
- msg = _cat1_get_msgptr(set, msgno);
- if (msg) {
- msgtxt = &set->_msgtxt[msg - set->_mp];
- if (1 /*!*msgtxt */ ) {
- *msgtxt = (char *)malloc(msg->_msglen + 1);
- if (!*msgtxt)
- return (NULL);
-
- fseek(catd->_fd, (long)msg->_offset, 0);
- if (fread
- ((void *)*msgtxt, (size_t) (msg->_msglen + 1), (size_t) 1,
- catd->_fd) != 1)
- return (NULL);
- }
-
- return (*msgtxt);
- }
- }
- return (NULL);
-}
-
-/*
- * NAME: compare_sets
- *
- * FUNCTION: Compare function used by bsearch() in _cat_get_catset().
- *
- * ARGUMENTS:
- * key - pointer to set number we're searching for
- * element - pointer to current _catset structure
- *
- * RETURNS: Returns -1, 0, or 1, depending on whether the set number
- * is less than, equal to, or greater than the set number of
- * the _catset structure.
- *
- */
-
-static int
-compare_sets(const void *key, const void *element)
-{
- int *setno = (int *)key;
- struct _catset *set = (struct _catset *)element;
-
- if (*setno < set->_setno)
- return -1;
- if (*setno > set->_setno)
- return 1;
-
- return 0;
-}
-
-
-/*
- * NAME: _cat_get_catset
- *
- * FUNCTION: Find a set in the catd->_set array. Assumes that the
- * sets in the array are sorted by increasing set number.
- *
- * ARGUMENTS:
- * catd - catalog descripter obtained from catopen()
- * setno - message catalogue set number
- *
- * RETURNS: Returns a pointer to the set on success.
- * On any error, returns NULL.
- *
- */
-
-struct _catset *
-_cat1_get_catset(nl_catd catd, int setno)
-{
- struct _catset *set;
-
- if ((catd == (nl_catd) NULL) || (catd == CATD_ERR))
- return (struct _catset *)NULL;
-
- if (catd->_sets_expanded) {
- if ((setno < 0) || (setno > catd->_n_sets))
- return (struct _catset *)NULL;
-
- set = &catd->_set[setno];
-
- /*
- * Catch empty elements in the array. They aren't
- * real sets.
- */
-
- if (set->_mp == (struct _msgptr *)NULL)
- return (struct _catset *)NULL;
- } else {
- set =
- (struct _catset *)bsearch((void *)&setno, catd->_set,
- catd->_n_sets + 1,
- sizeof(struct _catset), compare_sets);
-
- /*
- * Since the sets are compacted, there aren't any
- * empty elements in the array to check for.
- */
- }
-
- return set;
-}
-
-
-/*
- * NAME: compare_msgs
- *
- * FUNCTION: Compare function used by bsearch() in _cat_get_msgptr().
- *
- * ARGUMENTS:
- * key - pointer to message number we're searching for
- * element - pointer to current _msgptr structure
- *
- * RETURNS: Returns -1, 0, or 1, depending on whether the message
- * number is less than, equal to, or greater than the message
- * number of the _msgptr structure.
- *
- */
-
-static int
-compare_msgs(const void *key, const void *element)
-{
- int *msgno = (int *)key;
- struct _msgptr *msg = (struct _msgptr *)element;
-
- if (*msgno < msg->_msgno)
- return -1;
- if (*msgno > msg->_msgno)
- return 1;
-
- return 0;
-}
-
-/*
- * NAME: _cat1_get_msgptr
- *
- * FUNCTION: Find a message in a set's set->_mp array. Assumes that
- * the messages in the array are sorted by increasing
- * message number.
- *
- * ARGUMENTS:
- * set - ptr to _catset structure
- * msgno - message catalogue message number
- *
- * RETURNS: Returns a pointer to the message on success.
- * On any error, returns NULL.
- *
- */
-static struct _msgptr *
-_cat1_get_msgptr(struct _catset *set, int msgno)
-{
- struct _msgptr *msg;
-
- if (set == (struct _catset *)NULL)
- return (struct _msgptr *)NULL;
-
- if (set->_mp == (struct _msgptr *)NULL) /* empty set */
- return (struct _msgptr *)NULL;
-
- if (set->_msgs_expanded) {
- if ((msgno < 0) || (msgno > set->_n_msgs))
- return (struct _msgptr *)NULL;
-
- msg = &set->_mp[msgno];
-
- /*
- * Catch empty elements in the array. They aren't
- * real messages.
- */
-
- if (!msg->_offset)
- return (struct _msgptr *)NULL;
- } else {
- msg =
- (struct _msgptr *)bsearch((void *)&msgno, set->_mp,
- set->_n_msgs + 1,
- sizeof(struct _msgptr), compare_msgs);
-
- /*
- * Since the messages are compacted, there aren't any
- * empty elements in the array to check for.
- */
- }
-
- return msg;
-}
-
-char *
-catgets1(nl_catd catd, int setno, int msgno, char *def)
- /*---- catd: the catd to get the message from ----*/
- /*---- setno: the set number of the message ----*/
- /*---- msgno: the message number of the message ----*/
- /*---- def: the default string to be returned ----*/
-{
- int errno_save;
- char *_do_read_msg();
- char *m;
- errno_save = errno;
-
- if (catd == NULL || catd == CATD_ERR || catd->_magic != CAT_MAGIC
- || catd->_fd == NL_FILE_UNUSED) {
- return (def);
- }
- if (catd->_fd == NL_FILE_CLOSED) {
- catd = _do1_open(catd);
- if (catd == CATD_ERR)
- return (def);
- }
-
- if (catd->_mem) { /*---- for mapped files ----*/
- if (setno <= catd->_hd->_setmax) {
- if (msgno < catd->_set[setno]._n_msgs) {
- if (catd->_set[setno]._mp[msgno]._offset) {
- return (catd->_mem +
- catd->_set[setno]._mp[msgno]._offset);
- }
- }
- }
- return (def);
- } else { /*---- for unmapped files ----*/
- m = _do1_read_msg(catd, setno, msgno);
- if (m == NULL)
- return (def);
- else
- return (m);
- }
-}
-
-#endif
-
#define FACILITY_CODE_MASK 0xF0000000
#define FACILITY_CODE_SHIFT 28
#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
-
-dce1_error_inq_text(status_to_convert, error_text, status)
- afs_uint32 status_to_convert;
- unsigned char *error_text;
- int *status;
-
+void
+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_OSF_ENV)
-#if defined(AFS_OSF20_ENV)
- catd = (nl_catd) catopen(nls_filename, 0);
-#else
- catd = (nl_catd) catopen1(nls_filename, 0);
-#endif
-#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_OSF_ENV)
-#if defined(AFS_OSF20_ENV)
- catd = (nl_catd) catopen(alt_filename, 0);
-#else
- catd = (nl_catd) catopen1(alt_filename, 0);
-#endif
-#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
*/
-#if defined(AFS_OSF_ENV) && !defined(AFS_OSF20_ENV)
- message = (char *)catgets1(catd, 1, status_code, NO_MESSAGE);
-#else
message = (char *)catgets(catd, 1, status_code, NO_MESSAGE);
-#endif
/*
* if everything went well, return the resulting message
*/
*status = 0;
}
} else {
- if (!failed) {
- failed = 1;
-#if defined(AFS_OSF_ENV) && !defined(AFS_OSF20_ENV)
- catclose1(catd);
-#else
- catclose(catd);
-#endif
- goto tryagain;
- }
sprintf((char *)error_text, "status %08x (%s / %s)",
status_to_convert, facility_name, component_name);
}
-#if defined(AFS_OSF_ENV) && !defined(AFS_OSF20_ENV)
- catclose1(catd);
-#else
catclose(catd);
-#endif
-
}
-
-icl_DumpKernel(outFilep, setname)
- FILE *outFilep;
- char *setname;
+int
+icl_DumpKernel(FILE *outFilep, char *setname)
{
afs_int32 bufferSize = 0;
afs_int32 *bufferp;
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;
}
/* clear out log 'name' */
-icl_ClearLog(name)
- char *name;
+int
+icl_ClearLog(char *name)
{
afs_int32 code;
}
/* clear out set 'name' */
-icl_ClearSet(name)
- char *name;
+int
+icl_ClearSet(char *name)
{
afs_int32 code;
}
/* clear out all logs */
-icl_ClearAll()
+int
+icl_ClearAll(void)
{
afs_int32 code;
/* list out all available sets to outFileP */
int
-icl_ListSets(outFileP)
- FILE *outFileP;
+icl_ListSets(FILE *outFileP)
{
int i;
afs_int32 code = 0;
/* list out all available logs to outFileP */
int
-icl_ListLogs(outFileP, int32flg)
- FILE *outFileP;
- int int32flg;
+icl_ListLogs(FILE *outFileP, int int32flg)
{
int i;
int allocated;
/* list out all available logs to outFileP */
int
-icl_ListLogsBySet(outFileP, setname, int32flg)
- FILE *outFileP;
- char *setname;
- int int32flg;
+icl_ListLogsBySet(FILE *outFileP, char *setname, int int32flg)
{
int i;
afs_int32 code = 0;
/* activate/deactivate/free specified set */
int
-icl_ChangeSetState(name, op)
- char *name;
- afs_int32 op;
+icl_ChangeSetState(char *name, afs_int32 op)
{
afs_int32 code;
/* activate/deactivate/free all sets */
int
-icl_ChangeAllSetState(op)
- afs_int32 op;
+icl_ChangeAllSetState(afs_int32 op)
{
afs_int32 code;
/* set size if log */
int
-icl_ChangeLogSize(name, logSize)
- char *name;
- afs_int32 logSize;
+icl_ChangeLogSize(char *name, afs_int32 logSize)
{
afs_int32 code;
/* get logsize of specified log */
int
-icl_GetLogsize(logname, logSizeP, allocatedP)
- char *logname;
- afs_int32 *logSizeP;
- int *allocatedP;
+icl_GetLogsize(char *logname, afs_int32 *logSizeP, int *allocatedP)
{
afs_int32 code;
code =
/* get state of specified set */
int
-icl_GetSetState(setname, stateP)
- char *setname;
- afs_int32 *stateP;
+icl_GetSetState(char *setname, afs_int32 *stateP)
{
afs_int32 code;
code =
return code;
}
-icl_TailKernel(outFilep, logname, waitTime)
- FILE *outFilep;
- char *logname;
- afs_int32 waitTime;
+int
+icl_TailKernel(FILE *outFilep, char *logname, afs_int32 waitTime)
{
afs_int32 bufferSize = 0;
afs_int32 newBufferSize;
afs_int32 ix;
afs_int32 rlength;
int allocated;
- struct logInfo *lip;
/* get information about the specified log */
code =
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)
-afs_syscall(call, parm0, parm1, parm2, parm3, parm4, parm5, parm6)
- long call, parm0, parm1, parm2, parm3, parm4, parm5, parm6;
+int
+afs_syscall(long call, long parm0, long parm1, long parm2, long parm3,
+ long parm4, long parm5, long parm6)
{
int code, rval;
#ifdef AFS_LINUX20_ENV
#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_inited = 0;
/* init function, called once, under icl_lock */
-icl_Init()
+int
+icl_Init(void)
{
icl_inited = 1;
return 0;
}
-icl_CreateSet(name, baseLogp, fatalLogp, outSetpp)
- char *name;
- struct afs_icl_log *baseLogp;
- struct afs_icl_log *fatalLogp;
- struct afs_icl_set **outSetpp;
+int
+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,
outSetpp);
* addds references from the new icl_set. When the set is destroyed,
* those references will be released.
*/
-icl_CreateSetWithFlags(name, baseLogp, fatalLogp, flags, outSetpp)
- char *name;
- struct afs_icl_log *baseLogp;
- struct afs_icl_log *fatalLogp;
- afs_uint32 flags;
- struct afs_icl_set **outSetpp;
+int
+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 */
}
/* function to change event enabling information for a particular set */
-icl_SetEnable(setp, eventID, setValue)
- struct afs_icl_set *setp;
- afs_int32 eventID;
- int setValue;
+int
+icl_SetEnable(struct afs_icl_set *setp, afs_int32 eventID, int setValue)
{
char *tp;
* for tracing. If *getValuep is set to 0, the event is disabled,
* otherwise it is enabled. All events start out enabled by default.
*/
-icl_GetEnable(setp, eventID, getValuep)
- struct afs_icl_set *setp;
- afs_int32 eventID;
- int *getValuep;
+int
+icl_GetEnable(struct afs_icl_set *setp, afs_int32 eventID, int *getValuep)
{
if (!ICL_EVENTOK(setp, eventID)) {
return -1;
}
/* hold and release event sets */
-icl_SetHold(setp)
- register struct afs_icl_set *setp;
+int
+icl_SetHold(struct afs_icl_set *setp)
{
setp->refCount++;
return 0;
}
/* free a set. Called with icl_lock locked */
-icl_ZapSet(setp)
- register struct afs_icl_set *setp;
+int
+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) {
osi_Free(setp->name, 1 + strlen(setp->name));
osi_Free(setp->eventFlags, ICL_EVENTBYTES(setp->nevents));
for (i = 0; i < ICL_LOGSPERSET; i++) {
- if (tlp = setp->logs[i])
+ if ((tlp = setp->logs[i]))
icl_LogReleNL(tlp);
}
osi_Free(setp, sizeof(struct afs_icl_set));
}
/* do the release, watching for deleted entries */
-icl_SetRele(setp)
- register struct afs_icl_set *setp;
+int
+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 */
-icl_SetFree(setp)
- register struct afs_icl_set *setp;
+int
+icl_SetFree(struct afs_icl_set *setp)
{
setp->states |= ICL_SETF_DELETED;
icl_SetRele(setp);
/* find a set by name, returning it held */
struct afs_icl_set *
-icl_FindSet(name)
- char *name;
+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) {
}
/* zero out all the logs in the set */
-icl_ZeroSet(setp)
- struct afs_icl_set *setp;
+int
+icl_ZeroSet(struct afs_icl_set *setp)
{
- register int i;
+ int i;
int code = 0;
int tcode;
struct afs_icl_log *logp;
return code;
}
-icl_EnumerateSets(aproc, arock)
- int (*aproc) ();
- char *arock;
+int
+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) {
return code;
}
-icl_AddLogToSet(setp, newlogp)
- struct afs_icl_set *setp;
- struct afs_icl_log *newlogp;
+int
+icl_AddLogToSet(struct afs_icl_set *setp, struct afs_icl_log *newlogp)
{
- register int i;
+ int i;
int code = -1;
- struct afs_icl_log *logp;
for (i = 0; i < ICL_LOGSPERSET; i++) {
if (!setp->logs[i]) {
return code;
}
-icl_SetSetStat(setp, op)
- struct afs_icl_set *setp;
- int op;
+int
+icl_SetSetStat(struct afs_icl_set *setp, int op)
{
int i;
afs_int32 code;
break;
case ICL_OP_SS_FREE: /* deassert design for log */
- /*
+ /*
* if we are already in this state, do nothing; otherwise
* deassert desire for log
*/
struct afs_icl_log *afs_icl_allLogs = 0;
/* hold and release logs */
-icl_LogHold(logp)
- register struct afs_icl_log *logp;
+int
+icl_LogHold(struct afs_icl_log *logp)
{
logp->refCount++;
return 0;
}
/* hold and release logs, called with lock already held */
-icl_LogHoldNL(logp)
- register struct afs_icl_log *logp;
+int
+icl_LogHoldNL(struct afs_icl_log *logp)
{
logp->refCount++;
return 0;
}
/* keep track of how many sets believe the log itself is allocated */
-icl_LogUse(logp)
- register struct afs_icl_log *logp;
+int
+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 */
-icl_LogFreeUse(logp)
- register struct afs_icl_log *logp;
+int
+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' */
-icl_LogSetSize(logp, logSize)
- register struct afs_icl_log *logp;
- afs_int32 logSize;
+int
+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. */
-icl_ZapLog(logp)
- register struct afs_icl_log *logp;
+int
+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 */
-icl_LogRele(logp)
- register struct afs_icl_log *logp;
+int
+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 */
-icl_LogReleNL(logp)
- register struct afs_icl_log *logp;
+int
+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 */
-icl_LogFree(logp)
- register struct afs_icl_log *logp;
+int
+icl_LogFree(struct afs_icl_log *logp)
{
logp->states |= ICL_LOGF_DELETED;
icl_LogRele(logp);
int
icl_EnumerateLogs(int (*aproc)
- (char *name, char *arock, struct afs_icl_log * tp),
- char *arock)
+ (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;
+ afs_int32 code;
code = 0;
for (tp = afs_icl_allLogs; tp; tp = tp->nextp) {
afs_icl_bulkSetinfo_t *
-GetBulkSetInfo()
+GetBulkSetInfo(void)
{
unsigned int infoSize;
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;
}
afs_icl_bulkLoginfo_t *
-GetBulkLogInfo()
+GetBulkLogInfo(void)
{
unsigned int infoSize;
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;
}
afs_int32 code = 0;
afs_int32 tcode;
afs_int32 waitTime = 10 /* seconds */ ;
- int error = 0;
char *logname;
- char *filename;
FILE *outfp = stdout;
time_t startTime;
struct cmd_item *itemp;
}
static void
-SetUpDump()
+SetUpDump(void)
{
struct cmd_syndesc *dumpSyntax;
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;
}
static void
-SetUpShowLog()
+SetUpShowLog(void)
{
struct cmd_syndesc *showSyntax;
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;
}
static void
-SetUpShowSet()
+SetUpShowSet(void)
{
struct cmd_syndesc *showSyntax;
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;
}
static void
-SetUpClear()
+SetUpClear(void)
{
struct cmd_syndesc *clearSyntax;
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;
}
static void
-SetUpSet()
+SetUpSet(void)
{
struct cmd_syndesc *setSyntax;
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;
bufferSize = ICL_DEFAULT_LOGSIZE;
/* set the size of the specified logs */
- if (itemp = as->parms[0].items) {
+ if ((itemp = as->parms[0].items)) {
for (; itemp; itemp = itemp->next) {
code = icl_ChangeLogSize(itemp->data, bufferSize);
if (code) {
}
static void
-SetUpResize()
+SetUpResize(void)
{
struct cmd_syndesc *setsizeSyntax;
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"
-main(argc, argv)
- IN int argc;
- IN char *argv[];
+int
+main(int argc, char *argv[])
{
setlocale(LC_ALL, "");
#ifdef AFS_SGI62_ENV
return (cmd_Dispatch(argc, argv));
}
-#else
-#include "AFS_component_version_number.c"
-
-main()
-{
- printf("fstrace is NOT supported for this OS\n");
-}
-#endif
git://git.openafs.org / openafs.git / blobdiff