src/venus/fstrace.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 /*
  11  * All Rights Reserved
  12  */
  13 #include <afsconfig.h>
  14 #include <afs/param.h>
  15 #include <afs/stds.h>
  16
  17 #include <roken.h>
  18
  19 #include <afs/cmd.h>
  20 #include <afs/afs_args.h>
  21 #include <afs/icl.h>
  22 #include <afs/afsutil.h>
  23 #include <rx/rx.h>
  24 #include <afs/vice.h>
  25 #include <afs/sys_prototypes.h>
  26
  27 #if defined(AFS_OSF_ENV) || defined(AFS_SGI61_ENV) || (defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL))
  28 /* For SGI 6.2, this is changed to 1 if it's a 32 bit kernel. */
  29 int afs_icl_sizeofLong = 2;
  30 #else
  31 int afs_icl_sizeofLong = 1;
  32 #endif
  33
  34 #if defined(AFS_SGI61_ENV) || (defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL))
  35 int afs_64bit_kernel = 1;       /* Default for 6.2+, and always for 6.1 */
  36 extern int afs_icl_sizeofLong;  /* Used in ICL_SIZEHACK() */
  37 #ifdef AFS_SGI62_ENV
  38
  39 /* If _SC_KERN_POINTERS not in sysconf, then we can assume a 32 bit abi. */
  40 void
  41 set_kernel_sizeof_long(void)
  42 {
  43     int retval;
  44
  45
  46     retval = sysconf(_SC_KERN_POINTERS);
  47     if (retval == 64) {
  48         afs_64bit_kernel = 1;
  49         afs_icl_sizeofLong = 2;
  50     } else {
  51         afs_64bit_kernel = 0;
  52         afs_icl_sizeofLong = 1;
  53     }
  54 }
  55
  56 #endif /* AFS_SGI62_ENV */
  57 #endif /* AFS_SGI61_ENV */
  58
  59 int afs_syscall(long call, long parm0, long parm1, long parm2, long parm3,
  60                 long parm4, long parm5, long parm6);
  61 void dce1_error_inq_text(afs_uint32 status_to_convert,
  62                          char *error_text, int *status);
  63 int icl_CreateSetWithFlags(char *name, struct afs_icl_log *baseLogp,
  64                            struct afs_icl_log *fatalLogp, afs_uint32 flags,
  65                            struct afs_icl_set **outSetpp);
  66 int icl_LogHold(struct afs_icl_log *logp);
  67 int icl_LogUse(struct afs_icl_log *logp);
  68 int icl_LogReleNL(struct afs_icl_log *logp);
  69 int icl_LogRele(struct afs_icl_log *logp);
  70 int icl_ZeroLog(struct afs_icl_log *logp);
  71 int icl_LogFreeUse(struct afs_icl_log *logp);
  72
  73 #define BUFFER_MULTIPLIER     1024
  74
  75 /* make it big enough to snapshot everything at once, since
  76  * decoding takes so long.
  77  */
  78 #define IBSIZE          100000  /* default size */
  79
  80 struct logInfo {
  81     struct logInfo *nextp;
  82     char *name;
  83 } *allInfo = 0;
  84
  85 char dumpFileName[256] = "";
  86 void
  87 RegisterIclDumpFileName(char *name)
  88 {
  89     (void)sprintf(dumpFileName, "icl.%.250s", name);
  90 }
  91
  92 /* define globals to use for bulk info */
  93 afs_icl_bulkSetinfo_t *setInfo = (afs_icl_bulkSetinfo_t *) 0;
  94 afs_icl_bulkLoginfo_t *logInfo = (afs_icl_bulkLoginfo_t *) 0;
  95
  96 struct afs_icl_set *icl_allSets = 0;
  97
  98
  99 char *name;
 100 /* given a type and an address, get the size of the thing
 101  * in words.
 102  */
 103 static int
 104 icl_GetSize(afs_int32 type, char *addr)
 105 {
 106     int rsize;
 107     int tsize;
 108
 109     rsize = 0;
 110     ICL_SIZEHACK(type, addr, tsize, rsize);
 111     return rsize;
 112 }
 113
 114 /* Check types in printf string "bufferp", making sure that each
 115  * is compatible with the corresponding parameter type described
 116  * by typesp.  Also watch for prematurely running out of parameters
 117  * before the string is gone.
 118  */
 119 #if defined(AFS_SGI61_ENV) || (defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL))
 120 static int
 121 CheckTypes(char *bufferp, int *typesp, int typeCount, char *outMsgBuffer)
 122 {
 123     char tc;
 124     int inPercent;
 125     int tix;
 126
 127     inPercent = 0;
 128     tix = 0;
 129     for (tc = *bufferp;; outMsgBuffer++, tc = *(++bufferp)) {
 130         *outMsgBuffer = tc;
 131         if (tc == 0) {
 132             /* hit end of string.  We win as long as we aren't
 133              * in a '%'.
 134              */
 135             if (inPercent)
 136                 return 0;
 137             else
 138                 return 1;
 139         }
 140         if (tc == '%') {
 141             inPercent = 1 - inPercent;
 142             continue;
 143         }
 144         if (inPercent) {
 145             if (tc >= '0' && tc <= '9') {
 146                 /* skip digits in % string */
 147                 outMsgBuffer--;
 148                 continue;
 149             }
 150             if (tc == 'l') {
 151                 /* 'l' is a type modifier. */
 152                 outMsgBuffer--;
 153                 continue;
 154             }
 155             /* otherwise, we've finally gotten to the type-describing
 156              * character.  Make sure there's a type descriptor, and then
 157              * check the type descriptor.
 158              */
 159             inPercent = 0;
 160             if (tix >= typeCount)
 161                 return 0;       /* no more type descriptors left */
 162             if (tc == 's') {
 163                 if (typesp[tix] != 1)   /* not a string descriptor */
 164                     return 0;
 165                 outMsgBuffer--;
 166                 *outMsgBuffer = (char)1;
 167             }
 168             if (tc == 'u' || tc == 'x' || tc == 'd' || tc == 'o') {
 169                 if (typesp[tix] != 0)
 170                     return 0;   /* not an integer descriptor */
 171                 outMsgBuffer--;
 172                 switch (tc) {
 173                 case 'd':
 174                     *outMsgBuffer = (char)2;
 175                     break;
 176                 case 'u':
 177                     *outMsgBuffer = (char)3;
 178                     break;
 179                 case 'o':
 180                     *outMsgBuffer = (char)4;
 181                     break;
 182                 case 'x':
 183                 default:
 184                     *outMsgBuffer = (char)5;
 185                     break;
 186                 }
 187             }
 188             /* otherwise we're fine, so eat this descriptor */
 189             tix++;
 190         }
 191     }
 192     /* not reached */
 193 }
 194 #else /* AFS_SGI61_ENV */
 195 static int
 196 CheckTypes(char *bufferp, int *typesp, int typeCount)
 197 {
 198     char tc;
 199     int inPercent;
 200     int tix;
 201
 202     inPercent = 0;
 203     tix = 0;
 204     for (tc = *bufferp;; tc = *(++bufferp)) {
 205         if (tc == 0) {
 206             /* hit end of string.  We win as long as we aren't
 207              * in a '%'.
 208              */
 209             if (inPercent)
 210                 return 0;
 211             else
 212                 return 1;
 213         }
 214         if (tc == '%') {
 215             inPercent = 1 - inPercent;
 216             continue;
 217         }
 218         if (inPercent) {
 219             if (tc >= '0' && tc <= '9')
 220                 continue;       /* skip digits in % string */
 221             /* otherwise, we've finally gotten to the type-describing
 222              * character.  Make sure there's a type descriptor, and then
 223              * check the type descriptor.
 224              */
 225             inPercent = 0;
 226             if (tix >= typeCount)
 227                 return 0;       /* no more type descriptors left */
 228             if (tc == 's' && typesp[tix] != 1)  /* not a string descriptor */
 229                 return 0;
 230             if ((tc == 'u' || tc == 'l' || tc == 'x' || tc == 'd')
 231                 && (typesp[tix] != 0))
 232                 return 0;       /* not an integer descriptor */
 233             /* otherwise we're fine, so eat this descriptor */
 234             tix++;
 235         }
 236     }
 237     /* not reached */
 238 }
 239 #endif /* AFS_SGI61_ENV */
 240
 241 /* display a single record.
 242  * alp points at the first word in the array to be interpreted
 243  * rsize gives the # of words in the array
 244  */
 245 #if defined(AFS_SGI61_ENV) && !defined(AFS_SGI62_ENV)
 246 #define uint64_t long long
 247 #endif
 248 static void
 249 DisplayRecord(FILE *outFilep, afs_int32 *alp, afs_int32 rsize)
 250 {
 251     char msgBuffer[1024];
 252 #if defined(AFS_SGI61_ENV) || (defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL))
 253     char outMsgBuffer[1024];
 254     uint64_t tempParam;
 255     uint64_t printfParms[ICL_MAXEXPANSION * /* max parms */ 4];
 256     char *printfStrings[ICL_MAXEXPANSION * /* max parms */ 4];
 257 #else /* AFS_SGI61_ENV */
 258     long printfParms[ICL_MAXEXPANSION * /* max parms */ 4];
 259 #endif /* AFS_SGI61_ENV */
 260     int printfTypes[ICL_MAXEXPANSION * 4];
 261     int i;
 262     afs_int32 done = 0;
 263     afs_int32 temp;
 264     int j;
 265     int type;
 266     int pix;                    /* index in alp */
 267     int pfpix;                  /* index in printfParms */
 268     int pftix;                  /* index in printfTypes */
 269     int status;
 270     int printed;                /* did we print the string yet? */
 271     time_t tmv;
 272
 273     /* decode parameters */
 274     temp = alp[0];              /* type encoded in low-order 24 bits, t0 high */
 275     pix = 4;
 276     pfpix = 0;
 277     pftix = 0;
 278     /* init things */
 279
 280     for (i = 0; i < 4 * ICL_MAXEXPANSION; i++)
 281         printfParms[i] = 0;
 282     /* decode each parameter, getting addrs for afs_hyper_t and strings */
 283     for (i = 0; !done && i < 4; i++) {
 284         type = (temp >> (18 - i * 6)) & 0x3f;
 285         switch (type) {
 286         case ICL_TYPE_NONE:
 287             done = 1;
 288             break;
 289         case ICL_TYPE_LONG:
 290         case ICL_TYPE_POINTER:
 291             printfTypes[pftix++] = 0;
 292 #if defined(AFS_SGI61_ENV) || (defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL))
 293             printfParms[pfpix] = alp[pix];
 294             printfParms[pfpix] &= 0xffffffff;
 295             if (afs_64bit_kernel) {
 296                 printfParms[pfpix] <<= 32;
 297                 printfParms[pfpix] |= alp[pix + 1];
 298             }
 299 #elif defined(AFS_OSF_ENV)
 300             printfParms[pfpix] = alp[pix + 1];
 301             printfParms[pfpix] |= (alp[pix] <<= 32);
 302 #else /* !AFS_OSF_ENV && !AFS_SGI61_ENV */
 303             printfParms[pfpix] = alp[pix];
 304 #endif
 305             pfpix++;
 306             break;
 307         case ICL_TYPE_INT32:
 308             printfTypes[pftix++] = 0;
 309             printfParms[pfpix++] = alp[pix];
 310             break;
 311         case ICL_TYPE_HYPER:
 312         case ICL_TYPE_INT64:
 313             printfTypes[pftix++] = 0;
 314             printfParms[pfpix++] = alp[pix];
 315             printfTypes[pftix++] = 0;
 316             printfParms[pfpix++] = alp[pix + 1];
 317             break;
 318         case ICL_TYPE_FID:
 319             printfTypes[pftix++] = 0;
 320             printfParms[pfpix++] = alp[pix];
 321             printfTypes[pftix++] = 0;
 322             printfParms[pfpix++] = alp[pix + 1];
 323             printfTypes[pftix++] = 0;
 324             printfParms[pfpix++] = alp[pix + 2];
 325             printfTypes[pftix++] = 0;
 326             printfParms[pfpix++] = alp[pix + 3];
 327             break;
 328         case ICL_TYPE_STRING:
 329             printfTypes[pftix++] = 1;
 330 #ifdef AFS_SGI64_ENV
 331             printfStrings[pfpix++] = (char *)&alp[pix];
 332 #else /* AFS_SGI64_ENV */
 333 #if defined(AFS_SGI61_ENV) || (defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL))
 334             printfStrings[pfpix++] = (char *)&alp[pix];
 335 #else /* AFS_SGI61_ENV */
 336             printfParms[pfpix++] = (long)&alp[pix];
 337 #endif /* AFS_SGI61_ENV */
 338 #endif /* AFS_SGI64_ENV */
 339             break;
 340         case ICL_TYPE_UNIXDATE:
 341             tmv = alp[pix];
 342             printfParms[pfpix++] = (long)ctime(&tmv);
 343             break;
 344         default:
 345             printf("DisplayRecord: Bad type %d in decode switch.\n", type);
 346             done = 1;
 347             break;
 348         }
 349         if (done)
 350             break;
 351
 352         pix += icl_GetSize(type, (char *)&alp[pix]);
 353     }
 354
 355     /* next, try to decode the opcode into a printf string */
 356     dce1_error_inq_text(alp[1], msgBuffer, &status);
 357
 358     /* if we got a string back, and it is compatible with the
 359      * parms we've got, then print it.
 360      */
 361     printed = 0;
 362     if (status == 0) {
 363 #if defined(AFS_SGI61_ENV) || (defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL))
 364         if (CheckTypes(msgBuffer, printfTypes, pftix, outMsgBuffer)) {
 365             /* we have a string to use, but it ends "(dfs / zcm)",
 366              * so we remove the extra gunk.
 367              */
 368             j = strlen(outMsgBuffer);
 369             if (j > 12) {
 370                 outMsgBuffer[j - 11] = 0;
 371                 j -= 11;
 372             }
 373             pfpix = 0;
 374             fprintf(outFilep, "time %d.%06d, pid %u: ", alp[3] / 1000000,
 375                     alp[3] % 1000000, alp[2]);
 376             for (i = 0; i < j; i++) {
 377                 if ((int)outMsgBuffer[i] > 5)
 378                     fputc(outMsgBuffer[i], outFilep);
 379                 else {
 380                     switch (outMsgBuffer[i]) {
 381                     case 0:     /* done */
 382                         break;
 383                     case 1:     /* string */
 384                         fprintf(outFilep, "%s", printfStrings[pfpix++]);
 385                         break;
 386                     case 2:     /* signed integer */
 387                         fprintf(outFilep, "%" AFS_INT64_FMT, printfParms[pfpix++]);
 388                         break;
 389                     case 3:     /* unsigned integer */
 390                         fprintf(outFilep, "%llu", printfParms[pfpix++]);
 391                         break;
 392                     case 4:     /* octal integer */
 393                         fprintf(outFilep, "%llo", printfParms[pfpix++]);
 394                         break;
 395                     case 5:     /* hex integer */
 396                         fprintf(outFilep, "%llx", printfParms[pfpix++]);
 397                         break;
 398                     default:
 399                         fprintf(outFilep,
 400                                 "fstrace: Bad char %d in outMsgBuffer for parm %d\n",
 401                                 outMsgBuffer[i], pfpix);
 402                         fprintf(outFilep, "fstrace: msgBuffer='%s'\n",
 403                                 msgBuffer);
 404                         break;
 405                     }
 406                 }
 407             }
 408             fprintf(outFilep, "\n");
 409             printed = 1;
 410         }
 411 #else /* AFS_SGI61_ENV */
 412         if (CheckTypes(msgBuffer, printfTypes, pftix)) {
 413             /* we have a string to use, but it ends "(dfs / zcm)",
 414              * so we remove the extra gunk.
 415              */
 416             j = strlen(msgBuffer);
 417             if (j > 12)
 418                 msgBuffer[j - 11] = 0;
 419             fprintf(outFilep, "time %d.%06d, pid %u: ", alp[3] / 1000000,
 420                     alp[3] % 1000000, alp[2]);
 421             fprintf(outFilep, msgBuffer, printfParms[0], printfParms[1],
 422                     printfParms[2], printfParms[3], printfParms[4],
 423                     printfParms[5], printfParms[6], printfParms[7],
 424                     printfParms[8], printfParms[9], printfParms[10],
 425                     printfParms[11], printfParms[12], printfParms[13],
 426                     printfParms[14], printfParms[15]);
 427             fprintf(outFilep, "\n");
 428             printed = 1;
 429         }
 430 #endif /* AFS_SGI61_ENV */
 431         else {
 432             fprintf(outFilep, "Type mismatch, using raw print.\n");
 433             fprintf(outFilep, "%s", msgBuffer);
 434         }
 435     }
 436     if (!printed) {
 437         if (alp[1] == ICL_INFO_TIMESTAMP) {
 438             tmv = alp[4];
 439             fprintf(outFilep, "time %d.%06d, pid %u: %s\n", alp[3] / 1000000,
 440                     alp[3] % 1000000, alp[2], ctime(&tmv));
 441         } else {
 442             fprintf(outFilep, "raw op %d, time %d.%06d, pid %u\n", alp[1],
 443                     alp[3] / 1000000, alp[3] % 1000000, alp[2]);
 444             /* now decode each parameter and print it */
 445             pix = 4;
 446             done = 0;
 447             for (i = 0; !done && i < 4; i++) {
 448                 type = (temp >> (18 - i * 6)) & 0x3f;
 449                 switch (type) {
 450                 case ICL_TYPE_NONE:
 451                     done = 1;
 452                     break;
 453                 case ICL_TYPE_INT32:
 454                     fprintf(outFilep, "p%d:%d ", i, alp[pix]);
 455                     break;
 456                 case ICL_TYPE_LONG:
 457 #ifdef AFS_SGI61_ENV
 458                     tempParam = alp[pix];
 459                     tempParam <<= 32;
 460                     tempParam |= alp[pix + 1];
 461                     fprintf(outFilep, "p%d:%" AFS_INT64_FMT " ", i, tempParam);
 462 #else /* AFS_SGI61_ENV */
 463                     fprintf(outFilep, "p%d:%d ", i, alp[pix]);
 464 #endif /* AFS_SGI61_ENV */
 465                     break;
 466                 case ICL_TYPE_POINTER:
 467 #ifdef AFS_SGI61_ENV
 468                     tempParam = alp[pix];
 469                     tempParam <<= 32;
 470                     tempParam |= alp[pix + 1];
 471                     fprintf(outFilep, "p%d:0x%llx ", i, tempParam);
 472 #else /* AFS_SGI61_ENV */
 473                     fprintf(outFilep, "p%d:0x%x ", i, alp[pix]);
 474 #endif /* AFS_SGI61_ENV */
 475                     break;
 476                 case ICL_TYPE_HYPER:
 477                 case ICL_TYPE_INT64:
 478                     fprintf(outFilep, "p%d:%x.%x ", i, alp[pix],
 479                             alp[pix + 1]);
 480                     break;
 481                 case ICL_TYPE_FID:
 482                     fprintf(outFilep, "p%d:%d.%d.%d.%d ", i, alp[pix],
 483                             alp[pix + 1], alp[pix + 2], alp[pix + 3]);
 484                     break;
 485                 case ICL_TYPE_STRING:
 486                     fprintf(outFilep, "p%d:%s ", i, (char *)&alp[pix]);
 487                     break;
 488                 case ICL_TYPE_UNIXDATE:
 489                     tmv = alp[pix];
 490                     fprintf(outFilep, "p%d:%s ", i,
 491                             ctime(&tmv));
 492                     break;
 493                 default:
 494                     printf
 495                         ("DisplayRecord: Bad type %d in raw print switch.\n",
 496                          type);
 497                     done = 1;
 498                     break;
 499                 }
 500                 if (done)
 501                     break;
 502
 503                 pix += icl_GetSize(type, (char *)&alp[pix]);
 504             }
 505         }
 506         fprintf(outFilep, "\n");        /* done with line */
 507     }
 508 }
 509
 510
 511
 512 #include <locale.h>
 513 #ifdef  AFS_OSF_ENV
 514 #include <limits.h>
 515 #endif
 516 #include <nl_types.h>
 517
 518 #define FACILITY_CODE_MASK          0xF0000000
 519 #define FACILITY_CODE_SHIFT         28
 520
 521 #define COMPONENT_CODE_MASK         0x0FFFF000
 522 #define COMPONENT_CODE_SHIFT        12
 523
 524 #define STATUS_CODE_MASK            0x00000FFF
 525 #define STATUS_CODE_SHIFT           0
 526
 527 #define NO_MESSAGE                  "THIS IS NOT A MESSAGE"
 528
 529 /*
 530  * We use NLS message catalog functions to convert numbers to human-readable
 531  * strings.  The message catalog will be in AFSDIR_DATA_DIR, which is
 532  * ${datadir}/openafs with normal paths and /usr/vice/etc (for historical
 533  * compatibility) for Transarc paths.
 534  */
 535
 536 void
 537 dce1_error_inq_text(afs_uint32 status_to_convert,
 538                    char *error_text, int *status)
 539 {
 540     unsigned short facility_code;
 541     unsigned short component_code;
 542     unsigned short status_code;
 543     unsigned short i;
 544     nl_catd catd;
 545     char component_name[4];
 546     char *facility_name;
 547     char filename_prefix[7];
 548     char nls_filename[80];
 549     char *message;
 550     static char *facility_names[] = {
 551         "xxx",
 552         "afs"
 553     };
 554
 555     /*
 556      * set up output status for future error returns
 557      */
 558     if (status != NULL) {
 559         *status = -1;
 560     }
 561     /*
 562      * check for ok input status
 563      */
 564     if (status_to_convert == 0) {
 565         if (status != NULL) {
 566             *status = 0;
 567         }
 568         strcpy((char *)error_text, "successful completion");
 569         return;
 570     }
 571
 572     /*
 573      * extract the component, facility and status codes
 574      */
 575     facility_code =
 576         (status_to_convert & FACILITY_CODE_MASK) >> FACILITY_CODE_SHIFT;
 577     component_code =
 578         (status_to_convert & COMPONENT_CODE_MASK) >> COMPONENT_CODE_SHIFT;
 579     status_code = (status_to_convert & STATUS_CODE_MASK) >> STATUS_CODE_SHIFT;
 580
 581     /*
 582      * see if this is a recognized facility
 583      */
 584     if (facility_code == 0
 585         || facility_code > sizeof(facility_names) / sizeof(char *)) {
 586         sprintf((char *)error_text, "status %08x (unknown facility)",
 587                 status_to_convert);
 588         return;
 589     }
 590     facility_name = facility_names[facility_code - 1];
 591     /*
 592      * Convert component name from RAD-50 component code.  (Mapping is:
 593      * 0 => 'a', ..., 25 => 'z', 26 => '{', 27 => '0', ..., 36 => '9'.)
 594      */
 595     component_name[3] = 0;
 596     component_name[2] = component_code % 40;
 597     component_code /= 40;
 598     component_name[1] = component_code % 40;
 599     component_name[0] = component_code / 40;
 600     for (i = 0; i < 3; i++) {
 601         component_name[i] += (component_name[i] <= 26) ? 'a' : ('0' - 27);
 602     }
 603     sprintf(filename_prefix, "%3s%3s", facility_name, component_name);
 604
 605     /*
 606      * We do not use the normal NLS message catalog search path since our use
 607      * message catalogs isn't a typical use.  It wouldn't make sense to
 608      * install this special message catalog in with internationalization
 609      * catalogs.
 610      */
 611     snprintf(nls_filename, sizeof(nls_filename), "%s/C/%s.cat",
 612              AFSDIR_CLIENT_DATA_DIRPATH, filename_prefix);
 613
 614     catd = catopen(nls_filename, 0);
 615     if (catd == (nl_catd) -1) {
 616         sprintf((char *)error_text, "status %08x (%s / %s)",
 617                 status_to_convert, facility_name, component_name);
 618         return;
 619     }
 620     /*
 621      * try to get the specified message from the file
 622      */
 623     message = (char *)catgets(catd, 1, status_code, NO_MESSAGE);
 624     /*
 625      * if everything went well, return the resulting message
 626      */
 627     if (strcmp(message, NO_MESSAGE) != 0) {
 628         sprintf((char *)error_text, "%s (%s / %s)", message, facility_name,
 629                 component_name);
 630         if (status != NULL) {
 631             *status = 0;
 632         }
 633     } else {
 634         sprintf((char *)error_text, "status %08x (%s / %s)",
 635                 status_to_convert, facility_name, component_name);
 636     }
 637     catclose(catd);
 638 }
 639
 640 int
 641 icl_DumpKernel(FILE *outFilep, char *setname)
 642 {
 643     afs_int32 bufferSize = 0;
 644     afs_int32 *bufferp;
 645     afs_int32 i;
 646     afs_int32 code, retVal = 0;
 647     char tname[64];
 648     afs_int32 nwords;
 649     afs_int32 ix;
 650     afs_int32 rlength;
 651     afs_int32 dummy, dummy2;
 652     struct logInfo *lip;
 653
 654     /* first, enumerate the logs we're interested in */
 655     if (setname) {
 656         int found = 0;
 657         /* dump logs for a particular set */
 658         for (i = 0; i < ICL_LOGSPERSET; i++) {
 659             code =
 660                 afs_syscall(AFSCALL_ICL, ICL_OP_ENUMLOGSBYSET, (long)setname,
 661                             i, (long)tname, sizeof(tname), 0, 0);
 662             if (code) {
 663                 if (errno == EBADF) {
 664                     continue;   /* missing slot, nothing to worry about */
 665                 }
 666                 break;
 667             }
 668             code =
 669                 afs_syscall(AFSCALL_ICL, ICL_OP_GETLOGINFO, (long)tname,
 670                             (long)&dummy, (long)&dummy2, 0, 0, 0);
 671             if (code)
 672                 break;
 673             found++;
 674             if (dummy > bufferSize)     /* find biggest log */
 675                 bufferSize = dummy;
 676             lip = calloc(1, sizeof(struct logInfo));
 677             lip->nextp = allInfo;
 678             allInfo = lip;
 679             lip->name = strdup(tname);
 680         }
 681         i = found;
 682     } else {
 683         /* dump all logs */
 684         for (i = 0; i < 1000; i++) {
 685             code =
 686                 afs_syscall(AFSCALL_ICL, ICL_OP_ENUMLOGS, i, (long)tname,
 687                             sizeof(tname), (long)&dummy, 0, 0);
 688             if (code)
 689                 break;
 690             if (dummy > bufferSize)     /* find biggest log */
 691                 bufferSize = dummy;
 692             lip = calloc(1, sizeof(struct logInfo));
 693             lip->nextp = allInfo;
 694             allInfo = lip;
 695             lip->name = strdup(tname);
 696         }
 697     }
 698
 699     if (bufferSize == 0)
 700         return -1;
 701     bufferp = malloc(sizeof(afs_int32) * bufferSize);
 702     if (!bufferp)
 703         return -1;
 704
 705     fprintf(outFilep, "Found %d logs.\n", i);
 706
 707     /* now print out the contents of each log */
 708     for (lip = allInfo; lip; lip = lip->nextp) {
 709         fprintf(outFilep, "\nContents of log %s:\n", lip->name);
 710         /* read out everything first; gets a more consistent
 711          * snapshot.
 712          */
 713         nwords = 0;             /* total words copied out */
 714         for (i = 0;;) {
 715             /* display all the entries in the log */
 716             if (bufferSize - nwords <= 0)
 717                 break;          /* filled whole buffer */
 718             code =
 719                 afs_syscall(AFSCALL_ICL, ICL_OP_COPYOUT, (long)lip->name,
 720                             (long)(bufferp + nwords), bufferSize - nwords,
 721                             (long)&i, 0, 0);
 722             if (code < 0) {
 723                 /* otherwise we've got an error */
 724                 fprintf(outFilep, "Returned error %d dumping log.\n", errno);
 725                 break;
 726             }
 727             /* otherwise, we have flags in the high order byte, and
 728              * a length (in words) in the remainder.
 729              */
 730             if ((code >> 24) & ICL_COPYOUTF_MISSEDSOME)
 731                 fprintf(outFilep, "Log wrapped; data missing.\n");
 732             code &= 0xffffff;
 733             if (code == 0) {
 734                 /* we're done */
 735                 break;
 736             }
 737             nwords += code;
 738             i += code;
 739         }                       /* for loop over all cookies */
 740
 741         /* otherwise we should display all of the log entries here.
 742          * Note that a record may end in the middle, in which case
 743          * we should start over with the cookie value of the start
 744          * of that record.
 745          */
 746         for (ix = 0; ix < nwords;) {
 747             /* start of a record */
 748             rlength = (bufferp[ix] >> 24) & 0xff;
 749             if (rlength <= 0) {
 750                 fprintf(outFilep, "Internal error: 0 length record\n");
 751                 retVal = -1;
 752                 goto done;
 753             }
 754             /* ensure that entire record fits */
 755             if (ix + rlength > nwords) {
 756                 /* doesn't fit, adjust cookie and break */
 757                 break;
 758             }
 759             /* print the record */
 760             DisplayRecord(outFilep, &bufferp[ix], rlength);
 761             ix += rlength;
 762 #ifdef notdef
 763             /* obsolete: read entire buffer first */
 764             i += rlength;       /* update cookie value, too */
 765 #endif
 766         }                       /* for loop displaying buffer */
 767     }                           /* for loop over all logs */
 768
 769   done:
 770     free(bufferp);
 771     return (retVal);
 772 }
 773
 774 /* clear out log 'name' */
 775 int
 776 icl_ClearLog(char *name)
 777 {
 778     afs_int32 code;
 779
 780     code = afs_syscall(AFSCALL_ICL, ICL_OP_CLRLOG, (long)name, 0, 0, 0, 0, 0);
 781     return code;
 782 }
 783
 784 /* clear out set 'name' */
 785 int
 786 icl_ClearSet(char *name)
 787 {
 788     afs_int32 code;
 789
 790     code = afs_syscall(AFSCALL_ICL, ICL_OP_CLRSET, (long)name, 0, 0, 0, 0, 0);
 791     return code;
 792 }
 793
 794 /* clear out all logs */
 795 int
 796 icl_ClearAll(void)
 797 {
 798     afs_int32 code;
 799
 800     code = afs_syscall(AFSCALL_ICL, ICL_OP_CLRALL, 0, 0, 0, 0, 0, 0);
 801     return code;
 802 }
 803
 804 /* list out all available sets to outFileP */
 805 int
 806 icl_ListSets(FILE *outFileP)
 807 {
 808     int i;
 809     afs_int32 code = 0;
 810     afs_int32 states;
 811     char tname[64];
 812
 813     for (i = 0; i < 1000; i++) {
 814         code =
 815             afs_syscall(AFSCALL_ICL, ICL_OP_ENUMSETS, i, (long)tname,
 816                         sizeof(tname), (long)&states, 0, 0);
 817         if (code)
 818             break;
 819         (void)fprintf(outFileP, "%s %s%s%s\n", tname,
 820                       (states & ICL_SETF_ACTIVE) ? "active" : "inactive",
 821                       (states & ICL_SETF_FREED) ? " (dormant)" : "",
 822                       (states & ICL_SETF_PERSISTENT) ? " persistent" : "");
 823     }
 824
 825     return 0;
 826 }
 827
 828 /* list out all available logs to outFileP */
 829 int
 830 icl_ListLogs(FILE *outFileP, int int32flg)
 831 {
 832     int i;
 833     int allocated;
 834     afs_int32 code = 0;
 835     afs_int32 logSize;
 836     char tname[64];
 837
 838     for (i = 0; i < 1000; i++) {
 839         code =
 840             afs_syscall(AFSCALL_ICL, ICL_OP_ENUMLOGS, i, (long)tname,
 841                         sizeof(tname), (long)&logSize, 0, 0);
 842         if (code)
 843             break;
 844         if (int32flg) {
 845             /* get more information on the log */
 846             code =
 847                 afs_syscall(AFSCALL_ICL, ICL_OP_GETLOGINFO, (long)tname,
 848                             (long)&logSize, (long)&allocated, 0, 0, 0);
 849             if (code)
 850                 break;
 851             (void)fprintf(outFileP, "%s : %d kbytes (%s)\n", tname,
 852                           logSize / 1024,
 853                           allocated ? "allocated" : "unallocated");
 854         } else
 855             (void)fprintf(outFileP, "%s\n", tname);
 856     }
 857
 858     return 0;
 859 }
 860
 861 /* list out all available logs to outFileP */
 862 int
 863 icl_ListLogsBySet(FILE *outFileP, char *setname, int int32flg)
 864 {
 865     int i;
 866     afs_int32 code = 0;
 867     afs_int32 logSize;
 868     int allocated;
 869     char tname[64];
 870
 871     for (i = 0; i < ICL_LOGSPERSET; i++) {
 872         code =
 873             afs_syscall(AFSCALL_ICL, ICL_OP_ENUMLOGSBYSET, (long)setname, i,
 874                         (long)tname, sizeof(tname), 0, 0);
 875         if (code) {
 876             if (errno == EBADF) {
 877                 code = 0;
 878                 continue;       /* missing */
 879             }
 880             break;
 881         }
 882         if (int32flg) {
 883             /* get more information on the log */
 884             code =
 885                 afs_syscall(AFSCALL_ICL, ICL_OP_GETLOGINFO, (long)tname,
 886                             (long)&logSize, (long)&allocated, 0, 0, 0);
 887             if (code)
 888                 break;
 889             (void)fprintf(outFileP, "%s : %d kbytes (%s)\n", tname,
 890                           logSize / 1024,
 891                           allocated ? "allocated" : "unallocated");
 892         } else
 893             (void)fprintf(outFileP, "%s\n", tname);
 894     }
 895
 896     return code;
 897 }
 898
 899 /* activate/deactivate/free specified set */
 900 int
 901 icl_ChangeSetState(char *name, afs_int32 op)
 902 {
 903     afs_int32 code;
 904
 905     code = afs_syscall(AFSCALL_ICL, ICL_OP_SETSTAT, (long)name, op, 0, 0, 0, 0);
 906     return code;
 907 }
 908
 909 /* activate/deactivate/free all sets */
 910 int
 911 icl_ChangeAllSetState(afs_int32 op)
 912 {
 913     afs_int32 code;
 914
 915     code = afs_syscall(AFSCALL_ICL, ICL_OP_SETSTATALL, op, 0, 0, 0, 0, 0);
 916     return code;
 917 }
 918
 919 /* set size if log */
 920 int
 921 icl_ChangeLogSize(char *name, afs_int32 logSize)
 922 {
 923     afs_int32 code;
 924
 925     code =
 926         afs_syscall(AFSCALL_ICL, ICL_OP_SETLOGSIZE, (long)name, logSize, 0,
 927                     0, 0, 0);
 928     return code;
 929 }
 930
 931 /* get logsize of specified log */
 932 int
 933 icl_GetLogsize(char *logname, afs_int32 *logSizeP, int *allocatedP)
 934 {
 935     afs_int32 code;
 936     code =
 937         afs_syscall(AFSCALL_ICL, ICL_OP_GETLOGINFO, (long)logname,
 938                     (long)logSizeP, (long)allocatedP, 0, 0, 0);
 939     return code;
 940 }
 941
 942 /* get state of specified set */
 943 int
 944 icl_GetSetState(char *setname, afs_int32 *stateP)
 945 {
 946     afs_int32 code;
 947     code =
 948         afs_syscall(AFSCALL_ICL, ICL_OP_GETSETINFO, (long)setname,
 949                     (long)stateP, 0, 0, 0, 0);
 950     return code;
 951 }
 952
 953 int
 954 icl_TailKernel(FILE *outFilep, char *logname, afs_int32 waitTime)
 955 {
 956     afs_int32 bufferSize = 0;
 957     afs_int32 newBufferSize;
 958     afs_int32 *bufferp;
 959     afs_int32 i;
 960     afs_int32 code, retVal = 0;
 961     afs_int32 nwords;
 962     afs_int32 ix;
 963     afs_int32 rlength;
 964     int allocated;
 965
 966     /* get information about the specified log */
 967     code =
 968         afs_syscall(AFSCALL_ICL, ICL_OP_GETLOGINFO, (long)logname,
 969                     (long)&bufferSize, (long)&allocated, 0, 0, 0);
 970     if (code) {
 971         if (errno == ENOENT)
 972             (void)fprintf(stderr, "'%s' not found\n", logname);
 973         else
 974             (void)fprintf(stderr,
 975                           "cannot get information on log '%s' (errno = %d)\n",
 976                           logname, errno);
 977         return -1;
 978     }
 979
 980     if (!allocated) {
 981         (void)fprintf(stderr, "'%s' not allocated\n", logname);
 982         return 0;
 983     }
 984
 985     if (bufferSize == 0)
 986         return -1;
 987     bufferp = malloc(sizeof(afs_int32) * bufferSize);
 988     if (!bufferp) {
 989         (void)fprintf(stderr, "cannot allocate %d words for buffer\n",
 990                       bufferSize);
 991         return -1;
 992     }
 993
 994     /* start "infinite" loop */
 995     for (;;) {
 996         /* read out all that's currently there */
 997         nwords = 0;             /* total words copied out */
 998         i = 0;                  /* initialize cookie */
 999         for (;;) {
1000             /* display all the entries in the log */
1001             if (bufferSize - nwords <= 0)
1002                 break;          /* filled whole buffer, clear when done */
1003             code =
1004                 afs_syscall(AFSCALL_ICL, ICL_OP_COPYOUTCLR, (long)logname,
1005                             (long)(bufferp + nwords), bufferSize - nwords,
1006                             (long)&i, 0, 0);
1007             if (code < 0) {
1008                 /* otherwise we've got an error */
1009                 fprintf(stderr, "returned error %d dumping log.\n", errno);
1010                 retVal = -1;
1011                 goto tail_done;
1012             }
1013             /* otherwise, we have flags in the high order byte, and
1014              * a length (in words) in the remainder.
1015              */
1016             code &= 0xffffff;
1017             if (code == 0) {
1018                 /* we're done */
1019                 break;
1020             }
1021             nwords += code;
1022             i += code;
1023         }                       /* for loop over all cookies */
1024
1025         /* otherwise we should display all of the log entries here.
1026          * Note that a record may end in the middle, in which case
1027          * we should start over with the cookie value of the start
1028          * of that record.
1029          */
1030         for (ix = 0; ix < nwords;) {
1031             /* start of a record */
1032             rlength = (bufferp[ix] >> 24) & 0xff;
1033             /* ensure that entire record fits */
1034             if (ix + rlength > nwords) {
1035                 /* doesn't fit, adjust cookie and break */
1036                 if (rlength <= 0) {
1037                     fprintf(stderr, "BOGUS: 0 length record\n");
1038                     retVal = -1;
1039                     goto tail_done;
1040                 }
1041                 break;
1042             }
1043             /* print the record */
1044             DisplayRecord(outFilep, &bufferp[ix], rlength);
1045             ix += rlength;
1046         }                       /* for loop displaying buffer */
1047
1048         if (waitTime)
1049             sleep(waitTime);
1050
1051         /* see if things have changed */
1052         code =
1053             afs_syscall(AFSCALL_ICL, ICL_OP_GETLOGINFO, (long)logname,
1054                         (long)&newBufferSize, (long)&allocated, 0, 0, 0);
1055         if (code) {
1056             if (errno == ENOENT)
1057                 (void)fprintf(stderr, "'%s' not found\n", logname);
1058             else
1059                 (void)fprintf(stderr,
1060                               "cannot get information on log '%s' (errno = %d)\n",
1061                               logname, errno);
1062             retVal = -1;
1063             goto tail_done;
1064         }
1065
1066         if (!allocated) {
1067             (void)fprintf(stderr, "'%s' no int32er allocated\n", logname);
1068             retVal = -1;
1069             goto tail_done;
1070         }
1071
1072         if (bufferSize == 0) {
1073             (void)fprintf(stderr, "buffer size has become 0\n");
1074             retVal = -1;
1075             goto tail_done;
1076         }
1077         if (bufferSize != newBufferSize) {
1078             /* have to reallocate a buffer */
1079             bufferSize = newBufferSize;
1080             free(bufferp);
1081             bufferp = malloc(sizeof(afs_int32) * bufferSize);
1082             if (!bufferp) {
1083                 (void)fprintf(stderr, "cannot allocate %d words for buffer\n",
1084                               bufferSize);
1085                 retVal = -1;
1086                 goto tail_done;
1087             }
1088         }
1089     }                           /* infinite loop */
1090
1091   tail_done:
1092     free(bufferp);
1093     return (retVal);
1094 }
1095
1096 #if !defined(AFS_SGI_ENV)
1097 int
1098 afs_syscall(long call, long parm0, long parm1, long parm2, long parm3,
1099             long parm4, long parm5, long parm6)
1100 {
1101     int code;
1102 #if defined(AFS_DARWIN80_ENV) || defined(AFS_LINUX20_ENV)
1103     int rval;
1104 #endif
1105 #ifdef AFS_LINUX20_ENV
1106 #if defined AFS_LINUX_64BIT_KERNEL
1107     long long eparm[4];
1108     /* don't want to sign extend it to 64bit, so using ulong */
1109     eparm[0] = (unsigned long)parm3;
1110     eparm[1] = (unsigned long)parm4;
1111     eparm[2] = (unsigned long)parm5;
1112     eparm[3] = (unsigned long)parm6;
1113 #else
1114     int eparm[4];
1115     eparm[0] = parm3;
1116     eparm[1] = parm4;
1117     eparm[2] = parm5;
1118     eparm[3] = parm6;
1119 #endif
1120     /* Linux can only handle 5 arguments in the actual syscall. */
1121     if (call == AFSCALL_ICL) {
1122         rval = proc_afs_syscall(call, parm0, parm1, parm2, (long)eparm, &code);
1123         if (rval) {
1124 #ifdef AFS_SYSCALL
1125             code = syscall(AFS_SYSCALL, call, parm0, parm1, parm2, eparm);
1126 #else
1127             code = -1;
1128 #endif
1129         }
1130     } else {
1131         rval = proc_afs_syscall(call, parm0, parm1, parm2, parm3, &code);
1132         if (rval) {
1133 #ifdef AFS_SYSCALL
1134             code = syscall(AFS_SYSCALL, call, parm0, parm1, parm2, parm3);
1135 #else
1136             code = -1;
1137 #endif
1138         }
1139     }
1140 #if defined(AFS_SPARC64_LINUX20_ENV) || defined(AFS_SPARC_LINUX20_ENV)
1141     /* on sparc this function returns none value, so do it myself */
1142     __asm__ __volatile__("mov   %o0, %i0; ret; restore");
1143 #endif
1144 #else
1145 #ifdef AFS_DARWIN80_ENV
1146     code = ioctl_afs_syscall(call, parm0, parm1, parm2, parm3, parm4, parm5, &rval);
1147     if (!code) code = rval;
1148 #else
1149 #if !defined(AFS_SGI_ENV) && !defined(AFS_AIX32_ENV)
1150 # if defined(AFS_SYSCALL)
1151     code = syscall(AFS_SYSCALL, call, parm0, parm1, parm2, parm3, parm4);
1152 # else
1153     code = -1;
1154 # endif
1155 #else
1156 #if defined(AFS_SGI_ENV)
1157     code = syscall(AFS_ICL, call, parm0, parm1, parm2, parm3, parm4);   /* XXX */
1158 #else
1159     code = syscall(AFSCALL_ICL, parm0, parm1, parm2, parm3, parm4);
1160 #endif
1161 #endif
1162 #endif
1163 #endif /* AFS_LINUX20_ENV */
1164     return code;
1165 }
1166 #endif
1167
1168
1169 int icl_inited = 0;
1170
1171 /* init function, called once, under icl_lock */
1172 int
1173 icl_Init(void)
1174 {
1175     icl_inited = 1;
1176
1177 #ifndef KERNEL
1178     /* setup signal handler, in user space */
1179 #endif /* KERNEL */
1180
1181     return 0;
1182 }
1183
1184 int
1185 icl_CreateSet(char *name, struct afs_icl_log *baseLogp,
1186               struct afs_icl_log *fatalLogp, struct afs_icl_set **outSetpp)
1187 {
1188     return icl_CreateSetWithFlags(name, baseLogp, fatalLogp, /*flags */ 0,
1189                                   outSetpp);
1190 }
1191
1192 /* create a set, given pointers to base and fatal logs, if any.
1193  * Logs are unlocked, but referenced, and *outSetpp is returned
1194  * referenced.  Function bumps reference count on logs, since it
1195  * addds references from the new icl_set.  When the set is destroyed,
1196  * those references will be released.
1197  */
1198 int
1199 icl_CreateSetWithFlags(char *name, struct afs_icl_log *baseLogp,
1200                        struct afs_icl_log *fatalLogp, afs_uint32 flags,
1201                        struct afs_icl_set **outSetpp)
1202 {
1203     struct afs_icl_set *setp;
1204     int i;
1205     afs_int32 states = ICL_DEFAULT_SET_STATES;
1206
1207     if (!icl_inited)
1208         icl_Init();
1209
1210     for (setp = icl_allSets; setp; setp = setp->nextp) {
1211         if (strcmp(setp->name, name) == 0) {
1212             setp->refCount++;
1213             *outSetpp = setp;
1214             if (flags & ICL_CRSET_FLAG_PERSISTENT) {
1215                 setp->states |= ICL_SETF_PERSISTENT;
1216             }
1217             return 0;
1218         }
1219     }
1220
1221     /* determine initial state */
1222     if (flags & ICL_CRSET_FLAG_DEFAULT_ON)
1223         states = ICL_SETF_ACTIVE;
1224     else if (flags & ICL_CRSET_FLAG_DEFAULT_OFF)
1225         states = ICL_SETF_FREED;
1226     if (flags & ICL_CRSET_FLAG_PERSISTENT)
1227         states |= ICL_SETF_PERSISTENT;
1228
1229     setp = osi_Alloc(sizeof(struct afs_icl_set));
1230     memset((caddr_t) setp, 0, sizeof(*setp));
1231     setp->refCount = 1;
1232     if (states & ICL_SETF_FREED)
1233         states &= ~ICL_SETF_ACTIVE;     /* if freed, can't be active */
1234     setp->states = states;
1235
1236     setp->name = osi_Alloc(strlen(name) + 1);
1237     strcpy(setp->name, name);
1238     setp->nevents = ICL_DEFAULTEVENTS;
1239     setp->eventFlags = osi_Alloc(ICL_DEFAULTEVENTS);
1240     for (i = 0; i < ICL_DEFAULTEVENTS; i++)
1241         setp->eventFlags[i] = 0xff;     /* default to enabled */
1242
1243     /* update this global info under the icl_lock */
1244     setp->nextp = icl_allSets;
1245     icl_allSets = setp;
1246
1247     /* set's basic lock is still held, so we can finish init */
1248     if (baseLogp) {
1249         setp->logs[0] = baseLogp;
1250         icl_LogHold(baseLogp);
1251         if (!(setp->states & ICL_SETF_FREED))
1252             icl_LogUse(baseLogp);       /* log is actually being used */
1253     }
1254     if (fatalLogp) {
1255         setp->logs[1] = fatalLogp;
1256         icl_LogHold(fatalLogp);
1257         if (!(setp->states & ICL_SETF_FREED))
1258             icl_LogUse(fatalLogp);      /* log is actually being used */
1259     }
1260
1261     *outSetpp = setp;
1262     return 0;
1263 }
1264
1265 /* function to change event enabling information for a particular set */
1266 int
1267 icl_SetEnable(struct afs_icl_set *setp, afs_int32 eventID, int setValue)
1268 {
1269     char *tp;
1270
1271     if (!ICL_EVENTOK(setp, eventID)) {
1272         return -1;
1273     }
1274     tp = &setp->eventFlags[ICL_EVENTBYTE(eventID)];
1275     if (setValue)
1276         *tp |= ICL_EVENTMASK(eventID);
1277     else
1278         *tp &= ~(ICL_EVENTMASK(eventID));
1279     return 0;
1280 }
1281
1282 /* return indication of whether a particular event ID is enabled
1283  * for tracing.  If *getValuep is set to 0, the event is disabled,
1284  * otherwise it is enabled.  All events start out enabled by default.
1285  */
1286 int
1287 icl_GetEnable(struct afs_icl_set *setp, afs_int32 eventID, int *getValuep)
1288 {
1289     if (!ICL_EVENTOK(setp, eventID)) {
1290         return -1;
1291     }
1292     if (setp->eventFlags[ICL_EVENTBYTE(eventID)] & ICL_EVENTMASK(eventID))
1293         *getValuep = 1;
1294     else
1295         *getValuep = 0;
1296     return 0;
1297 }
1298
1299 /* hold and release event sets */
1300 int
1301 icl_SetHold(struct afs_icl_set *setp)
1302 {
1303     setp->refCount++;
1304     return 0;
1305 }
1306
1307 /* free a set.  Called with icl_lock locked */
1308 int
1309 icl_ZapSet(struct afs_icl_set *setp)
1310 {
1311     struct afs_icl_set **lpp, *tp;
1312     int i;
1313     struct afs_icl_log *tlp;
1314
1315     for (lpp = &icl_allSets, tp = *lpp; tp; lpp = &tp->nextp, tp = *lpp) {
1316         if (tp == setp) {
1317             /* found the dude we want to remove */
1318             *lpp = setp->nextp;
1319             osi_Free(setp->name, 1 + strlen(setp->name));
1320             osi_Free(setp->eventFlags, ICL_EVENTBYTES(setp->nevents));
1321             for (i = 0; i < ICL_LOGSPERSET; i++) {
1322                 if ((tlp = setp->logs[i]))
1323                     icl_LogReleNL(tlp);
1324             }
1325             osi_Free(setp, sizeof(struct afs_icl_set));
1326             break;              /* won't find it twice */
1327         }
1328     }
1329     return 0;
1330 }
1331
1332 /* do the release, watching for deleted entries */
1333 int
1334 icl_SetRele(struct afs_icl_set *setp)
1335 {
1336     if (--setp->refCount == 0 && (setp->states & ICL_SETF_DELETED)) {
1337         icl_ZapSet(setp);       /* destroys setp's lock! */
1338     }
1339     return 0;
1340 }
1341
1342 /* free a set entry, dropping its reference count */
1343 int
1344 icl_SetFree(struct afs_icl_set *setp)
1345 {
1346     setp->states |= ICL_SETF_DELETED;
1347     icl_SetRele(setp);
1348     return 0;
1349 }
1350
1351 /* find a set by name, returning it held */
1352 struct afs_icl_set *
1353 icl_FindSet(char *name)
1354 {
1355     struct afs_icl_set *tp;
1356
1357     for (tp = icl_allSets; tp; tp = tp->nextp) {
1358         if (strcmp(tp->name, name) == 0) {
1359             /* this is the dude we want */
1360             tp->refCount++;
1361             break;
1362         }
1363     }
1364     return tp;
1365 }
1366
1367 /* zero out all the logs in the set */
1368 int
1369 icl_ZeroSet(struct afs_icl_set *setp)
1370 {
1371     int i;
1372     int code = 0;
1373     int tcode;
1374     struct afs_icl_log *logp;
1375
1376     for (i = 0; i < ICL_LOGSPERSET; i++) {
1377         logp = setp->logs[i];
1378         if (logp) {
1379             icl_LogHold(logp);
1380             tcode = icl_ZeroLog(logp);
1381             if (tcode != 0)
1382                 code = tcode;   /* save the last bad one */
1383             icl_LogRele(logp);
1384         }
1385     }
1386     return code;
1387 }
1388
1389 int
1390 icl_EnumerateSets(int (*aproc) (char *, void *, struct afs_icl_set *),
1391                   void *arock)
1392 {
1393     struct afs_icl_set *tp, *np;
1394     afs_int32 code;
1395
1396     code = 0;
1397     for (tp = icl_allSets; tp; tp = np) {
1398         tp->refCount++;         /* hold this guy */
1399         code = (*aproc) (tp->name, arock, tp);
1400         np = tp->nextp;         /* tp may disappear next, but not np */
1401         if (--tp->refCount == 0 && (tp->states & ICL_SETF_DELETED))
1402             icl_ZapSet(tp);
1403         if (code)
1404             break;
1405     }
1406     return code;
1407 }
1408
1409 int
1410 icl_AddLogToSet(struct afs_icl_set *setp, struct afs_icl_log *newlogp)
1411 {
1412     int i;
1413     int code = -1;
1414
1415     for (i = 0; i < ICL_LOGSPERSET; i++) {
1416         if (!setp->logs[i]) {
1417             setp->logs[i] = newlogp;
1418             code = i;
1419             icl_LogHold(newlogp);
1420             if (!(setp->states & ICL_SETF_FREED)) {
1421                 /* bump up the number of sets using the log */
1422                 icl_LogUse(newlogp);
1423             }
1424             break;
1425         }
1426     }
1427     return code;
1428 }
1429
1430 int
1431 icl_SetSetStat(struct afs_icl_set *setp, int op)
1432 {
1433     int i;
1434     afs_int32 code;
1435     struct afs_icl_log *logp;
1436
1437     switch (op) {
1438     case ICL_OP_SS_ACTIVATE:    /* activate a log */
1439         /*
1440          * If we are not already active, see if we have released
1441          * our demand that the log be allocated (FREED set).  If
1442          * we have, reassert our desire.
1443          */
1444         if (!(setp->states & ICL_SETF_ACTIVE)) {
1445             if (setp->states & ICL_SETF_FREED) {
1446                 /* have to reassert desire for logs */
1447                 for (i = 0; i < ICL_LOGSPERSET; i++) {
1448                     logp = setp->logs[i];
1449                     if (logp) {
1450                         icl_LogHold(logp);
1451                         icl_LogUse(logp);
1452                         icl_LogRele(logp);
1453                     }
1454                 }
1455                 setp->states &= ~ICL_SETF_FREED;
1456             }
1457             setp->states |= ICL_SETF_ACTIVE;
1458         }
1459         code = 0;
1460         break;
1461
1462     case ICL_OP_SS_DEACTIVATE:  /* deactivate a log */
1463         /* this doesn't require anything beyond clearing the ACTIVE flag */
1464         setp->states &= ~ICL_SETF_ACTIVE;
1465         code = 0;
1466         break;
1467
1468     case ICL_OP_SS_FREE:        /* deassert design for log */
1469         /*
1470          * if we are already in this state, do nothing; otherwise
1471          * deassert desire for log
1472          */
1473         if (setp->states & ICL_SETF_ACTIVE)
1474             code = EINVAL;
1475         else {
1476             if (!(setp->states & ICL_SETF_FREED)) {
1477                 for (i = 0; i < ICL_LOGSPERSET; i++) {
1478                     logp = setp->logs[i];
1479                     if (logp) {
1480                         icl_LogHold(logp);
1481                         icl_LogFreeUse(logp);
1482                         icl_LogRele(logp);
1483                     }
1484                 }
1485                 setp->states |= ICL_SETF_FREED;
1486             }
1487             code = 0;
1488         }
1489         break;
1490
1491     default:
1492         code = EINVAL;
1493     }
1494
1495     return code;
1496 }
1497
1498 struct afs_icl_log *afs_icl_allLogs = 0;
1499
1500 /* hold and release logs */
1501 int
1502 icl_LogHold(struct afs_icl_log *logp)
1503 {
1504     logp->refCount++;
1505     return 0;
1506 }
1507
1508 /* hold and release logs, called with lock already held */
1509 int
1510 icl_LogHoldNL(struct afs_icl_log *logp)
1511 {
1512     logp->refCount++;
1513     return 0;
1514 }
1515
1516 /* keep track of how many sets believe the log itself is allocated */
1517 int
1518 icl_LogUse(struct afs_icl_log *logp)
1519 {
1520     if (logp->setCount == 0) {
1521         /* this is the first set actually using the log -- allocate it */
1522         if (logp->logSize == 0) {
1523             /* we weren't passed in a hint and it wasn't set */
1524             logp->logSize = ICL_DEFAULT_LOGSIZE;
1525         }
1526         logp->datap = osi_Alloc(sizeof(afs_int32) * logp->logSize);
1527     }
1528     logp->setCount++;
1529     return 0;
1530 }
1531
1532 /* decrement the number of real users of the log, free if possible */
1533 int
1534 icl_LogFreeUse(struct afs_icl_log *logp)
1535 {
1536     if (--logp->setCount == 0) {
1537         /* no more users -- free it (but keep log structure around) */
1538         osi_Free(logp->datap, sizeof(afs_int32) * logp->logSize);
1539         logp->firstUsed = logp->firstFree = 0;
1540         logp->logElements = 0;
1541         logp->datap = NULL;
1542     }
1543     return 0;
1544 }
1545
1546 /* set the size of the log to 'logSize' */
1547 int
1548 icl_LogSetSize(struct afs_icl_log *logp, afs_int32 logSize)
1549 {
1550     if (!logp->datap) {
1551         /* nothing to worry about since it's not allocated */
1552         logp->logSize = logSize;
1553     } else {
1554         /* reset log */
1555         logp->firstUsed = logp->firstFree = 0;
1556         logp->logElements = 0;
1557
1558         /* free and allocate a new one */
1559         osi_Free(logp->datap, sizeof(afs_int32) * logp->logSize);
1560         logp->datap = osi_Alloc(sizeof(afs_int32) * logSize);
1561         logp->logSize = logSize;
1562     }
1563
1564     return 0;
1565 }
1566
1567 /* free a log.  Called with icl_lock locked. */
1568 int
1569 icl_ZapLog(struct afs_icl_log *logp)
1570 {
1571     struct afs_icl_log **lpp, *tp;
1572
1573     for (lpp = &afs_icl_allLogs, tp = *lpp; tp; lpp = &tp->nextp, tp = *lpp) {
1574         if (tp == logp) {
1575             /* found the dude we want to remove */
1576             *lpp = logp->nextp;
1577             osi_Free(logp->name, 1 + strlen(logp->name));
1578             osi_Free(logp->datap, logp->logSize * sizeof(afs_int32));
1579             osi_Free(logp, sizeof(struct icl_log));
1580             break;              /* won't find it twice */
1581         }
1582     }
1583     return 0;
1584 }
1585
1586 /* do the release, watching for deleted entries */
1587 int
1588 icl_LogRele(struct afs_icl_log *logp)
1589 {
1590     if (--logp->refCount == 0 && (logp->states & ICL_LOGF_DELETED)) {
1591         icl_ZapLog(logp);       /* destroys logp's lock! */
1592     }
1593     return 0;
1594 }
1595
1596 /* do the release, watching for deleted entries, log already held */
1597 int
1598 icl_LogReleNL(struct afs_icl_log *logp)
1599 {
1600     if (--logp->refCount == 0 && (logp->states & ICL_LOGF_DELETED)) {
1601         icl_ZapLog(logp);       /* destroys logp's lock! */
1602     }
1603     return 0;
1604 }
1605
1606 /* zero out the log */
1607 int
1608 icl_ZeroLog(struct afs_icl_log *logp)
1609 {
1610     logp->firstUsed = logp->firstFree = 0;
1611     logp->logElements = 0;
1612     return 0;
1613 }
1614
1615 /* free a log entry, and drop its reference count */
1616 int
1617 icl_LogFree(struct afs_icl_log *logp)
1618 {
1619     logp->states |= ICL_LOGF_DELETED;
1620     icl_LogRele(logp);
1621     return 0;
1622 }
1623
1624
1625 int
1626 icl_EnumerateLogs(int (*aproc)
1627                     (char *name, void *arock, struct afs_icl_log * tp),
1628                   void *arock)
1629 {
1630     struct afs_icl_log *tp, *np;
1631     afs_int32 code;
1632
1633     code = 0;
1634     for (tp = afs_icl_allLogs; tp; tp = np) {
1635         tp->refCount++;         /* hold this guy */
1636         np = tp->nextp;
1637         code = (*aproc) (tp->name, arock, tp);
1638         if (--tp->refCount == 0)
1639             icl_ZapLog(tp);
1640         if (code)
1641             break;
1642     }
1643     return code;
1644 }
1645
1646
1647 afs_icl_bulkSetinfo_t *
1648 GetBulkSetInfo(void)
1649 {
1650     unsigned int infoSize;
1651
1652     infoSize =
1653         sizeof(afs_icl_bulkSetinfo_t) + (ICL_RPC_MAX_SETS -
1654                                          1) * sizeof(afs_icl_setinfo_t);
1655     if (!setInfo) {
1656         setInfo = calloc(1, infoSize);
1657         if (!setInfo) {
1658             (void)fprintf(stderr,
1659                           "Could not allocate the memory for bulk set info structure\n");
1660             exit(1);
1661         }
1662     }
1663
1664     return setInfo;
1665 }
1666
1667 afs_icl_bulkLoginfo_t *
1668 GetBulkLogInfo(void)
1669 {
1670     unsigned int infoSize;
1671
1672     infoSize =
1673         sizeof(afs_icl_bulkLoginfo_t) + (ICL_RPC_MAX_LOGS -
1674                                          1) * sizeof(afs_icl_loginfo_t);
1675     if (!logInfo) {
1676         logInfo = calloc(1, infoSize);
1677         if (!logInfo) {
1678             (void)fprintf(stderr,
1679                           "Could not allocate the memory for bulk log info structure\n");
1680             exit(1);
1681         }
1682     }
1683
1684     return logInfo;
1685 }
1686
1687
1688 static int
1689 DoDump(struct cmd_syndesc *as, void *arock)
1690 {
1691     afs_int32 code = 0;
1692     afs_int32 tcode;
1693     afs_int32 waitTime = 10 /* seconds */ ;
1694     char *logname;
1695     FILE *outfp = stdout;
1696     time_t startTime;
1697     struct cmd_item *itemp;
1698
1699     if (geteuid() != 0) {
1700         printf("fstrace must be run as root\n");
1701         exit(1);
1702     }
1703
1704     if (as->parms[3].items) {
1705         if (!as->parms[1].items) {
1706             (void)fprintf(stderr, "-sleep can only be used with -follow\n");
1707             return 1;
1708         }
1709         waitTime = strtol(as->parms[3].items->data, NULL, 0);
1710     }
1711
1712     if (as->parms[2].items) {
1713         /* try to open the specified output file */
1714         if ((outfp = fopen(as->parms[2].items->data, "w")) == NULL) {
1715             (void)fprintf(stderr, "Cannot open file '%s' for writing\n",
1716                           as->parms[2].items->data);
1717             return 1;
1718         }
1719     }
1720 #ifdef AFS_SGI64_ENV
1721     startTime = time((time_t *) 0);
1722 #else
1723     startTime = time(0);
1724 #endif
1725     (void)fprintf(outfp, "AFS Trace Dump -\n\n   Date: %s\n",
1726                   ctime(&startTime));
1727
1728     if (as->parms[0].items) {
1729         for (itemp = as->parms[0].items; itemp; itemp = itemp->next) {
1730             tcode = icl_DumpKernel(outfp, itemp->data);
1731             if (tcode) {
1732                 (void)fprintf(stderr, "Unable to dump set %s (errno = %d)\n",
1733                               itemp->data, errno);
1734                 code = tcode;
1735             }
1736         }
1737     } else if (as->parms[1].items) {
1738         logname = as->parms[1].items->data;
1739         code = icl_TailKernel(outfp, logname, waitTime);
1740         if (code) {
1741             (void)fprintf(stderr,
1742                           "Error tailing kernel log '%s' (errno = %d)\n",
1743                           logname, errno);
1744         }
1745     } else
1746         code = icl_DumpKernel(outfp, NULL);
1747
1748     (void)fprintf(outfp, "\nAFS Trace Dump - %s\n",
1749                   code ? "FAILED" : "Completed");
1750
1751     if (outfp != stdout)
1752         (void)fclose(outfp);
1753
1754     return code;
1755 }
1756
1757 static void
1758 SetUpDump(void)
1759 {
1760     struct cmd_syndesc *dumpSyntax;
1761
1762     dumpSyntax =
1763         cmd_CreateSyntax("dump", DoDump, NULL, 0, "dump AFS trace logs");
1764     (void)cmd_AddParm(dumpSyntax, "-set", CMD_LIST, CMD_OPTIONAL,
1765                       "event set name");
1766     (void)cmd_AddParm(dumpSyntax, "-follow", CMD_SINGLE, CMD_OPTIONAL,
1767                       "trace log name");
1768     (void)cmd_AddParm(dumpSyntax, "-file", CMD_SINGLE, CMD_OPTIONAL,
1769                       "path to trace log file for writing");
1770     (void)cmd_AddParm(dumpSyntax, "-sleep", CMD_SINGLE, CMD_OPTIONAL,
1771                       "interval (secs) for writes when using -follow");
1772 }
1773
1774
1775 static int
1776 DoShowLog(struct cmd_syndesc *as, void *arock)
1777 {
1778     afs_int32 retVal = 0;
1779     afs_int32 code = 0;
1780     afs_int32 logSize;
1781     int allocated;
1782     int int32flg = 0;
1783     struct cmd_item *itemp;
1784
1785     if (geteuid() != 0) {
1786         printf("fstrace must be run as root\n");
1787         exit(1);
1788     }
1789     if (as->parms[2].items)
1790         int32flg = 1;
1791
1792     if (as->parms[0].items) {
1793         /* enumerate logs for the specified sets */
1794         for (itemp = as->parms[0].items; itemp; itemp = itemp->next) {
1795             (void)fprintf(stdout, "Logs for set '%s':\n", itemp->data);
1796             code = icl_ListLogsBySet(stdout, itemp->data, int32flg);
1797             if (code) {
1798                 (void)fprintf(stderr,
1799                               "Error in enumerating set %s (errno = %d)\n",
1800                               itemp->data, errno);
1801                 retVal = code;
1802             }
1803         }
1804     } else if (as->parms[1].items) {
1805         /* print out log information */
1806         for (itemp = as->parms[1].items; itemp; itemp = itemp->next) {
1807             code = icl_GetLogsize(itemp->data, &logSize, &allocated);
1808             if (!code)
1809                 (void)fprintf(stdout, "%s : %d kbytes (%s)\n", itemp->data,
1810                               logSize / 1024,
1811                               allocated ? "allocated" : "unallocated");
1812             else {
1813                 (void)fprintf(stderr,
1814                               "Could not find log '%s' (errno = %d)\n",
1815                               itemp->data, errno);
1816                 retVal = code;
1817             }
1818         }
1819     } else {
1820         /* show all logs */
1821         (void)fprintf(stdout, "Available logs:\n");
1822         code = icl_ListLogs(stdout, int32flg);
1823         if (code) {
1824             (void)fprintf(stderr, "Error in listing logs (errno = %d)\n",
1825                           errno);
1826             retVal = code;
1827         }
1828     }
1829
1830     return retVal;
1831 }
1832
1833 static void
1834 SetUpShowLog(void)
1835 {
1836     struct cmd_syndesc *showSyntax;
1837
1838     showSyntax =
1839         cmd_CreateSyntax("lslog", DoShowLog, NULL, 0,
1840                          "list available logs");
1841     (void)cmd_AddParm(showSyntax, "-set", CMD_LIST, CMD_OPTIONAL,
1842                       "event set name");
1843     (void)cmd_AddParm(showSyntax, "-log", CMD_LIST, CMD_OPTIONAL,
1844                       "trace log name");
1845     (void)cmd_AddParm(showSyntax, "-long", CMD_FLAG, CMD_OPTIONAL,
1846                       "show defined log size in kbytes & if it is allocated in kernel mem");
1847 }
1848
1849 static int
1850 DoShowSet(struct cmd_syndesc *as, void *arock)
1851 {
1852     afs_int32 retVal = 0;
1853     afs_int32 code = 0;
1854     afs_int32 state;
1855     struct cmd_item *itemp;
1856
1857     if (geteuid() != 0) {
1858         printf("fstrace must be run as root\n");
1859         exit(1);
1860     }
1861     if (as->parms[0].items) {
1862         /* print information on the specified sets */
1863         for (itemp = as->parms[0].items; itemp; itemp = itemp->next) {
1864             code = icl_GetSetState(itemp->data, &state);
1865             if (code) {
1866                 (void)fprintf(stderr,
1867                               "Error getting status on set %s (errno = %d)\n",
1868                               itemp->data, errno);
1869                 retVal = code;
1870             } else
1871                 (void)fprintf(stdout, "Set %s: %s%s%s\n", itemp->data,
1872                               (state & ICL_SETF_ACTIVE) ? "active" :
1873                               "inactive",
1874                               (state & ICL_SETF_FREED) ? " (dormant)" : "",
1875                               (state & ICL_SETF_PERSISTENT) ? " persistent" :
1876                               "");
1877         }
1878     } else {
1879         /* show all sets */
1880         (void)fprintf(stdout, "Available sets:\n");
1881         code = icl_ListSets(stdout);
1882         if (code) {
1883             (void)fprintf(stderr, "Error in listing sets (errno = %d)\n",
1884                           errno);
1885             retVal = code;
1886         }
1887     }
1888
1889     return retVal;
1890 }
1891
1892 static void
1893 SetUpShowSet(void)
1894 {
1895     struct cmd_syndesc *showSyntax;
1896
1897     showSyntax =
1898         cmd_CreateSyntax("lsset", DoShowSet, NULL, 0,
1899                          "list available event sets");
1900     (void)cmd_AddParm(showSyntax, "-set", CMD_LIST, CMD_OPTIONAL,
1901                       "event set name");
1902 }
1903
1904 static int
1905 DoClear(struct cmd_syndesc *as, void *arock)
1906 {
1907     afs_int32 retVal = 0;
1908     afs_int32 code = 0;
1909     struct cmd_item *itemp;
1910
1911     if (geteuid() != 0) {
1912         printf("fstrace must be run as root\n");
1913         exit(1);
1914     }
1915     if (as->parms[0].items) {
1916         /* clear logs for the specified sets */
1917         for (itemp = as->parms[0].items; itemp; itemp = itemp->next) {
1918             code = icl_ClearSet(itemp->data);
1919             if (code) {
1920                 (void)fprintf(stderr,
1921                               "Error in clearing set %s (errno = %d)\n",
1922                               itemp->data, errno);
1923                 retVal = code;
1924             }
1925         }
1926     } else if (as->parms[1].items) {
1927         /* clear specified log */
1928         for (itemp = as->parms[0].items; itemp; itemp = itemp->next) {
1929             code = icl_ClearLog(itemp->data);
1930             if (code) {
1931                 (void)fprintf(stderr,
1932                               "Error in clearing log %s (errno = %d)\n",
1933                               itemp->data, errno);
1934                 retVal = code;
1935             }
1936         }
1937     } else {
1938         /* clear all logs */
1939         code = icl_ClearAll();
1940         if (code) {
1941             (void)fprintf(stderr, "Error in clearing logs (errno = %d)\n",
1942                           errno);
1943             retVal = code;
1944         }
1945     }
1946
1947     return retVal;
1948 }
1949
1950 static void
1951 SetUpClear(void)
1952 {
1953     struct cmd_syndesc *clearSyntax;
1954
1955     clearSyntax =
1956         cmd_CreateSyntax("clear", DoClear, NULL, 0,
1957                          "clear logs by logname or by event set");
1958     (void)cmd_AddParm(clearSyntax, "-set", CMD_LIST, CMD_OPTIONAL,
1959                       "event set name");
1960     (void)cmd_AddParm(clearSyntax, "-log", CMD_LIST, CMD_OPTIONAL,
1961                       "trace log name");
1962 }
1963
1964 static int
1965 DoSet(struct cmd_syndesc *as, void *arock)
1966 {
1967     afs_int32 retVal = 0;
1968     afs_int32 code = 0;
1969     int op;
1970     int doFree = 0;
1971     char *operation;
1972     struct cmd_item *itemp;
1973
1974     if (geteuid() != 0) {
1975         printf("fstrace must be run as root\n");
1976         exit(1);
1977     }
1978     if (as->parms[1].items) {
1979         op = ICL_OP_SS_ACTIVATE;
1980         operation = "active";
1981     } else if (as->parms[2].items) {
1982         op = ICL_OP_SS_DEACTIVATE;
1983         operation = "inactive";
1984     } else if (as->parms[3].items) {
1985         op = ICL_OP_SS_DEACTIVATE;
1986         operation = "inactive";
1987         doFree = 1;
1988     } else {
1989         /* assume active" */
1990         op = ICL_OP_SS_ACTIVATE;
1991         operation = "active";
1992     }
1993
1994     if (as->parms[0].items) {
1995         /* activate specified sets */
1996         for (itemp = as->parms[0].items; itemp; itemp = itemp->next) {
1997             code = icl_ChangeSetState(itemp->data, op);
1998             if (code) {
1999                 (void)fprintf(stderr,
2000                               "cannot set state of %s to %s (errno = %d)\n",
2001                               itemp->data, operation, errno);
2002                 retVal = code;
2003             } else if (doFree) {
2004                 /* try to make it dormant as well */
2005                 code = icl_ChangeSetState(itemp->data, ICL_OP_SS_FREE);
2006                 if (code) {
2007                     (void)fprintf(stderr,
2008                                   "cannot set state of %s to dormant (errno = %d)\n",
2009                                   itemp->data, errno);
2010                     retVal = code;
2011                 }
2012             }
2013         }
2014     } else {
2015         /* show all sets */
2016         code = icl_ChangeAllSetState(op);
2017         if (code) {
2018             (void)fprintf(stderr,
2019                           "cannot set the state of all sets to %s (errno = %d)\n",
2020                           operation, errno);
2021             retVal = code;
2022         } else if (doFree) {
2023             /* try to make it dormant as well */
2024             code = icl_ChangeAllSetState(ICL_OP_SS_FREE);
2025             if (code) {
2026                 (void)fprintf(stderr,
2027                               "cannot set the state of all sets to dormant (errno = %d)\n",
2028                               errno);
2029                 retVal = code;
2030             }
2031         }
2032     }
2033
2034     return retVal;
2035 }
2036
2037 static void
2038 SetUpSet(void)
2039 {
2040     struct cmd_syndesc *setSyntax;
2041
2042     setSyntax =
2043         cmd_CreateSyntax("setset", DoSet, NULL, 0,
2044                          "set state of event sets");
2045     (void)cmd_AddParm(setSyntax, "-set", CMD_LIST, CMD_OPTIONAL,
2046                       "event set name");
2047     (void)cmd_AddParm(setSyntax, "-active", CMD_FLAG, CMD_OPTIONAL,
2048                       "enable tracing for event set & allocate kernel memory");
2049     (void)cmd_AddParm(setSyntax, "-inactive", CMD_FLAG, CMD_OPTIONAL,
2050                       "disables tracing for event set, keep kernel memory");
2051     (void)cmd_AddParm(setSyntax, "-dormant", CMD_FLAG, CMD_OPTIONAL,
2052                       "disable tracing for event set & free kernel memory");
2053 }
2054
2055 static int
2056 DoResize(struct cmd_syndesc *as, void *arock)
2057 {
2058     afs_int32 retVal = 0;
2059     afs_int32 code = 0;
2060     afs_int32 bufferSize;
2061     struct cmd_item *itemp;
2062
2063     if (geteuid() != 0) {
2064         printf("fstrace must be run as root\n");
2065         exit(1);
2066     }
2067     /* get buffer size */
2068     bufferSize = atoi(as->parms[1].items->data);
2069     bufferSize *= BUFFER_MULTIPLIER;
2070     if (bufferSize == 0)
2071         bufferSize = ICL_DEFAULT_LOGSIZE;
2072
2073     /* set the size of the specified logs */
2074     if ((itemp = as->parms[0].items)) {
2075         for (; itemp; itemp = itemp->next) {
2076             code = icl_ChangeLogSize(itemp->data, bufferSize);
2077             if (code) {
2078                 (void)fprintf(stderr,
2079                               "Error in changing log %s buffer size (errno = %d)\n",
2080                               itemp->data, errno);
2081                 retVal = code;
2082             }
2083         }
2084     } else {
2085         /* Use the only current support log, "cmfx" */
2086         code = icl_ChangeLogSize("cmfx", bufferSize);
2087         if (code) {
2088             (void)fprintf(stderr,
2089                           "Error in changing log cmfx buffer size (errno = %d)\n",
2090                           errno);
2091             retVal = code;
2092         }
2093     }
2094
2095     return retVal;
2096 }
2097
2098 static void
2099 SetUpResize(void)
2100 {
2101     struct cmd_syndesc *setsizeSyntax;
2102
2103     setsizeSyntax =
2104         cmd_CreateSyntax("setlog", DoResize, NULL, 0,
2105                          "set the size of a log");
2106     (void)cmd_AddParm(setsizeSyntax, "-log", CMD_LIST, CMD_OPTIONAL,
2107                       "trace log name");
2108     (void)cmd_AddParm(setsizeSyntax, "-buffersize", CMD_SINGLE, CMD_REQUIRED,
2109                       "# of 1-kbyte blocks to allocate for log");
2110 }
2111
2112 #include "AFS_component_version_number.c"
2113
2114 int
2115 main(int argc, char *argv[])
2116 {
2117     setlocale(LC_ALL, "");
2118 #ifdef AFS_SGI62_ENV
2119     set_kernel_sizeof_long();
2120 #endif
2121
2122     /* set up user interface then dispatch */
2123     SetUpDump();
2124     SetUpShowLog();
2125     SetUpShowSet();
2126     SetUpClear();
2127     SetUpSet();
2128     SetUpResize();
2129
2130     return (cmd_Dispatch(argc, argv));
2131 }