static int mailq_histogram(char *option) { struct timeval tv; char *errmsg; char *q; int sts; q = strtok(option, ","); while (q != NULL) { if ((sts = pmParseInterval((const char *)q, &tv, &errmsg)) < 0) { pmprintf("%s: bad historgram bins argument:\n%s\n", pmProgname, errmsg); free(errmsg); return -EINVAL; } numhisto++; histo = (histo_t *)realloc(histo, numhisto * sizeof(histo[0])); if (histo == NULL) __pmNoMem("histo", numhisto * sizeof(histo[0]), PM_FATAL_ERR); histo[numhisto-1].delay = tv.tv_sec; q = strtok(NULL, ","); } return 0; }
static int parseargs(int argc, char *argv[]) { int c; int sts; char *endnum; char *msg; struct timeval interval; while ((c = pmgetopt_r(argc, argv, &opts)) != EOF) { switch (c) { case 'A': /* output time alignment */ Aarg = opts.optarg; break; case 'D': /* debug flag */ sts = __pmParseDebug(opts.optarg); if (sts < 0) { pmprintf("%s: unrecognized debug flag specification (%s)\n", pmProgname, opts.optarg); opts.errors++; } else pmDebug |= sts; break; case 's': /* number of samples to write out */ sarg = (int)strtol(opts.optarg, &endnum, 10); if (*endnum != '\0' || sarg < 0) { pmprintf("%s: -s requires numeric argument\n", pmProgname); opts.errors++; } break; case 'S': /* start time for reduction */ Sarg = opts.optarg; break; case 'T': /* end time for reduction */ Targ = opts.optarg; break; case 't': /* output sample interval */ if (pmParseInterval(opts.optarg, &interval, &msg) < 0) { pmprintf("%s", msg); free(msg); opts.errors++; } else targ = tv2double(&interval); break; case 'v': /* number of samples per volume */ varg = (int)strtol(opts.optarg, &endnum, 10); if (*endnum != '\0' || varg < 0) { pmprintf("%s: -v requires numeric argument\n", pmProgname); opts.errors++; } break; case 'Z': /* use timezone from command line */ if (zarg) { pmprintf("%s: at most one of -Z and/or -z allowed\n", pmProgname); opts.errors++; } tz = opts.optarg; break; case 'z': /* use timezone from archive */ if (tz != NULL) { pmprintf("%s: at most one of -Z and/or -z allowed\n", pmProgname); opts.errors++; } zarg++; break; case '?': default: opts.errors++; break; } } if (opts.errors == 0 && opts.optind > argc-2) { pmprintf("%s: Error: insufficient arguments\n", pmProgname); opts.errors++; } return -opts.errors; }
int main(int argc, char **argv) { static char helppath[MAXPATHLEN]; char *endnum; pmdaInterface desc; long minmem; int c, err = 0, sep = __pmPathSeparator(); __pmSetProgname(argv[0]); __pmGetUsername(&username); minmem = getpagesize(); maxmem = (minmem > DEFAULT_MAXMEM) ? minmem : DEFAULT_MAXMEM; snprintf(helppath, sizeof(helppath), "%s%c" "logger" "%c" "help", pmGetConfig("PCP_PMDAS_DIR"), sep, sep); pmdaDaemon(&desc, PMDA_INTERFACE_5, pmProgname, LOGGER, "logger.log", helppath); while ((c = pmdaGetOpt(argc, argv, "D:d:l:m:s:U:?", &desc, &err)) != EOF) { switch (c) { case 'm': maxmem = strtol(optarg, &endnum, 10); if (*endnum != '\0') convertUnits(&endnum, &maxmem); if (*endnum != '\0' || maxmem < minmem) { fprintf(stderr, "%s: invalid max memory '%s' (min=%ld)\n", pmProgname, optarg, minmem); err++; } break; case 's': if (pmParseInterval(optarg, &interval, &endnum) < 0) { fprintf(stderr, "%s: -s requires a time interval: %s\n", pmProgname, endnum); free(endnum); err++; } break; case 'U': username = optarg; break; default: err++; break; } } if (err || optind != argc -1) usage(); pmdaOpenLog(&desc); logger_init(&desc, argv[optind]); pmdaConnect(&desc); loggerMain(&desc); event_shutdown(); exit(0); }
int main(int argc, char **argv) { int c; int sts; int sep = __pmPathSeparator(); int use_localtime = 0; int isdaemon = 0; char *pmnsfile = PM_NS_DEFAULT; char *username; char *logfile = "pmlogger.log"; /* default log (not archive) file name */ char *endnum; int i; task_t *tp; optcost_t ocp; __pmFdSet readyfds; char *p; char *runtime = NULL; int ctx; /* handle corresponding to ctxp below */ __pmContext *ctxp; /* pmlogger has just this one context */ int niter; pid_t target_pid = 0; __pmGetUsername(&username); /* * Warning: * If any of the pmlogger options change, make sure the * corresponding changes are made to pmnewlog when pmlogger * options are passed through from the control file */ while ((c = pmgetopt_r(argc, argv, &opts)) != EOF) { switch (c) { case 'c': /* config file */ if (access(opts.optarg, F_OK) == 0) configfile = opts.optarg; else { /* does not exist as given, try the standard place */ char *sysconf = pmGetConfig("PCP_VAR_DIR"); int sz = strlen(sysconf)+strlen("/config/pmlogger/")+strlen(opts.optarg)+1; if ((configfile = (char *)malloc(sz)) == NULL) __pmNoMem("config file name", sz, PM_FATAL_ERR); snprintf(configfile, sz, "%s%c" "config%c" "pmlogger%c" "%s", sysconf, sep, sep, sep, opts.optarg); if (access(configfile, F_OK) != 0) { /* still no good, error handling happens below */ free(configfile); configfile = opts.optarg; } } break; case 'D': /* debug flag */ sts = __pmParseDebug(opts.optarg); if (sts < 0) { pmprintf("%s: unrecognized debug flag specification (%s)\n", pmProgname, opts.optarg); opts.errors++; } else pmDebug |= sts; break; case 'h': /* hostname for PMCD to contact */ pmcd_host_conn = opts.optarg; break; case 'l': /* log file name */ logfile = opts.optarg; break; case 'L': /* linger if not primary logger */ linger = 1; break; case 'm': /* note for port map file */ note = opts.optarg; isdaemon = ((strcmp(note, "pmlogger_check") == 0) || (strcmp(note, "pmlogger_daily") == 0)); break; case 'n': /* alternative name space file */ pmnsfile = opts.optarg; break; case 'p': target_pid = (int)strtol(opts.optarg, &endnum, 10); if (*endnum != '\0') { pmprintf("%s: invalid process identifier (%s)\n", pmProgname, opts.optarg); opts.errors++; } else if (!__pmProcessExists(target_pid)) { pmprintf("%s: PID error - no such process (%d)\n", pmProgname, target_pid); opts.errors++; } break; case 'P': /* this is the primary pmlogger */ primary = 1; isdaemon = 1; break; case 'r': /* report sizes of pmResult records */ rflag = 1; break; case 's': /* exit size */ sts = ParseSize(opts.optarg, &exit_samples, &exit_bytes, &exit_time); if (sts < 0) { pmprintf("%s: illegal size argument '%s' for exit size\n", pmProgname, opts.optarg); opts.errors++; } else if (exit_time.tv_sec > 0) { __pmAFregister(&exit_time, NULL, run_done_callback); } break; case 'T': /* end time */ runtime = opts.optarg; break; case 't': /* change default logging interval */ if (pmParseInterval(opts.optarg, &delta, &p) < 0) { pmprintf("%s: illegal -t argument\n%s", pmProgname, p); free(p); opts.errors++; } break; case 'U': /* run as named user */ username = opts.optarg; isdaemon = 1; break; case 'u': /* flush output buffers after each fetch */ /* * all archive write I/O is unbuffered now, so maintain -u * for backwards compatibility only */ break; case 'v': /* volume switch after given size */ sts = ParseSize(opts.optarg, &vol_switch_samples, &vol_switch_bytes, &vol_switch_time); if (sts < 0) { pmprintf("%s: illegal size argument '%s' for volume size\n", pmProgname, opts.optarg); opts.errors++; } else if (vol_switch_time.tv_sec > 0) { vol_switch_afid = __pmAFregister(&vol_switch_time, NULL, vol_switch_callback); } break; case 'V': archive_version = (int)strtol(opts.optarg, &endnum, 10); if (*endnum != '\0' || archive_version != PM_LOG_VERS02) { pmprintf("%s: -V requires a version number of %d\n", pmProgname, PM_LOG_VERS02); opts.errors++; } break; case 'x': /* recording session control fd */ rsc_fd = (int)strtol(opts.optarg, &endnum, 10); if (*endnum != '\0' || rsc_fd < 0) { pmprintf("%s: -x requires a non-negative numeric argument\n", pmProgname); opts.errors++; } else { time(&rsc_start); } break; case 'y': use_localtime = 1; break; case '?': default: opts.errors++; break; } } if (primary && pmcd_host != NULL) { pmprintf( "%s: -P and -h are mutually exclusive; use -P only when running\n" "%s on the same (local) host as the PMCD to which it connects.\n", pmProgname, pmProgname); opts.errors++; } if (!opts.errors && opts.optind != argc - 1) { pmprintf("%s: insufficient arguments\n", pmProgname); opts.errors++; } if (opts.errors) { pmUsageMessage(&opts); exit(1); } if (rsc_fd != -1 && note == NULL) { /* add default note to indicate running with -x */ static char xnote[10]; snprintf(xnote, sizeof(xnote), "-x %d", rsc_fd); note = xnote; } /* if we are running as a daemon, change user early */ if (isdaemon) __pmSetProcessIdentity(username); __pmOpenLog("pmlogger", logfile, stderr, &sts); if (sts != 1) { fprintf(stderr, "%s: Warning: log file (%s) creation failed\n", pmProgname, logfile); /* continue on ... writing to stderr */ } /* base name for archive is here ... */ archBase = argv[opts.optind]; if (pmcd_host_conn == NULL) pmcd_host_conn = "local:"; /* initialise access control */ if (__pmAccAddOp(PM_OP_LOG_ADV) < 0 || __pmAccAddOp(PM_OP_LOG_MAND) < 0 || __pmAccAddOp(PM_OP_LOG_ENQ) < 0) { fprintf(stderr, "%s: access control initialisation failed\n", pmProgname); exit(1); } if (pmnsfile != PM_NS_DEFAULT) { if ((sts = pmLoadASCIINameSpace(pmnsfile, 1)) < 0) { fprintf(stderr, "%s: Cannot load namespace from \"%s\": %s\n", pmProgname, pmnsfile, pmErrStr(sts)); exit(1); } } if ((ctx = pmNewContext(PM_CONTEXT_HOST, pmcd_host_conn)) < 0) { fprintf(stderr, "%s: Cannot connect to PMCD on host \"%s\": %s\n", pmProgname, pmcd_host_conn, pmErrStr(ctx)); exit(1); } pmcd_host = (char *)pmGetContextHostName(ctx); if (strlen(pmcd_host) == 0) { fprintf(stderr, "%s: pmGetContextHostName(%d) failed\n", pmProgname, ctx); exit(1); } if (rsc_fd == -1) { /* no -x, so register client id with pmcd */ __pmSetClientIdArgv(argc, argv); } /* * discover fd for comms channel to PMCD ... */ if ((ctxp = __pmHandleToPtr(ctx)) == NULL) { fprintf(stderr, "%s: botch: __pmHandleToPtr(%d) returns NULL!\n", pmProgname, ctx); exit(1); } pmcdfd = ctxp->c_pmcd->pc_fd; PM_UNLOCK(ctxp->c_lock); if (configfile != NULL) { if ((yyin = fopen(configfile, "r")) == NULL) { fprintf(stderr, "%s: Cannot open config file \"%s\": %s\n", pmProgname, configfile, osstrerror()); exit(1); } } else { /* **ANY** Lex would read from stdin automagically */ configfile = "<stdin>"; } __pmOptFetchGetParams(&ocp); ocp.c_scope = 1; __pmOptFetchPutParams(&ocp); /* prevent early timer events ... */ __pmAFblock(); if (yyparse() != 0) exit(1); if (configfile != NULL) fclose(yyin); yyend(); #ifdef PCP_DEBUG fprintf(stderr, "Config parsed\n"); #endif fprintf(stderr, "Starting %slogger for host \"%s\" via \"%s\"\n", primary ? "primary " : "", pmcd_host, pmcd_host_conn); #ifdef PCP_DEBUG if (pmDebug & DBG_TRACE_LOG) { fprintf(stderr, "optFetch Cost Parameters: pmid=%d indom=%d fetch=%d scope=%d\n", ocp.c_pmid, ocp.c_indom, ocp.c_fetch, ocp.c_scope); fprintf(stderr, "\nAfter loading config ...\n"); for (tp = tasklist; tp != NULL; tp = tp->t_next) { if (tp->t_numvalid == 0) continue; fprintf(stderr, " state: %sin log, %savail, %s, %s", PMLC_GET_INLOG(tp->t_state) ? "" : "not ", PMLC_GET_AVAIL(tp->t_state) ? "" : "un", PMLC_GET_MAND(tp->t_state) ? "mand" : "adv", PMLC_GET_ON(tp->t_state) ? "on" : "off"); fprintf(stderr, " delta: %ld usec", (long)1000 * tp->t_delta.tv_sec + tp->t_delta.tv_usec); fprintf(stderr, " numpmid: %d\n", tp->t_numpmid); for (i = 0; i < tp->t_numpmid; i++) { fprintf(stderr, " %s (%s):\n", pmIDStr(tp->t_pmidlist[i]), tp->t_namelist[i]); } __pmOptFetchDump(stderr, tp->t_fetch); } } #endif if (!primary && tasklist == NULL && !linger) { fprintf(stderr, "Nothing to log, and not the primary logger instance ... good-bye\n"); exit(1); } if ((sts = __pmLogCreate(pmcd_host, archBase, archive_version, &logctl)) < 0) { fprintf(stderr, "__pmLogCreate: %s\n", pmErrStr(sts)); exit(1); } else { /* * try and establish $TZ from the remote PMCD ... * Note the label record has been set up, but not written yet */ char *name = "pmcd.timezone"; pmID pmid; pmResult *resp; __pmtimevalNow(&epoch); sts = pmUseContext(ctx); if (sts >= 0) sts = pmLookupName(1, &name, &pmid); if (sts >= 0) sts = pmFetch(1, &pmid, &resp); if (sts >= 0) { if (resp->vset[0]->numval > 0) { /* pmcd.timezone present */ strcpy(logctl.l_label.ill_tz, resp->vset[0]->vlist[0].value.pval->vbuf); /* prefer to use remote time to avoid clock drift problems */ epoch = resp->timestamp; /* struct assignment */ if (! use_localtime) pmNewZone(logctl.l_label.ill_tz); } #ifdef PCP_DEBUG else if (pmDebug & DBG_TRACE_LOG) { fprintf(stderr, "main: Could not get timezone from host %s\n", pmcd_host); } #endif pmFreeResult(resp); } } /* do ParseTimeWindow stuff for -T */ if (runtime) { struct timeval res_end; /* time window end */ struct timeval start; struct timeval end; struct timeval last_delta; char *err_msg; /* parsing error message */ time_t now; struct timeval now_tv; time(&now); now_tv.tv_sec = now; now_tv.tv_usec = 0; start = now_tv; end.tv_sec = INT_MAX; end.tv_usec = INT_MAX; sts = __pmParseTime(runtime, &start, &end, &res_end, &err_msg); if (sts < 0) { fprintf(stderr, "%s: illegal -T argument\n%s", pmProgname, err_msg); exit(1); } last_delta = res_end; tsub(&last_delta, &now_tv); __pmAFregister(&last_delta, NULL, run_done_callback); last_stamp = res_end; } fprintf(stderr, "Archive basename: %s\n", archBase); #ifndef IS_MINGW /* detach yourself from the launching process */ if (isdaemon) setpgid(getpid(), 0); #endif /* set up control port */ init_ports(); __pmFD_ZERO(&fds); for (i = 0; i < CFD_NUM; ++i) { if (ctlfds[i] >= 0) __pmFD_SET(ctlfds[i], &fds); } #ifndef IS_MINGW __pmFD_SET(pmcdfd, &fds); #endif if (rsc_fd != -1) __pmFD_SET(rsc_fd, &fds); numfds = maxfd() + 1; if ((sts = do_preamble()) < 0) fprintf(stderr, "Warning: problem writing archive preamble: %s\n", pmErrStr(sts)); sts = 0; /* default exit status */ parse_done = 1; /* enable callback processing */ __pmAFunblock(); for ( ; ; ) { int nready; #ifdef PCP_DEBUG if ((pmDebug & DBG_TRACE_APPL2) && (pmDebug & DBG_TRACE_DESPERATE)) { fprintf(stderr, "before __pmSelectRead(%d,...): run_done_alarm=%d vol_switch_alarm=%d log_alarm=%d\n", numfds, run_done_alarm, vol_switch_alarm, log_alarm); } #endif niter = 0; while (log_alarm && niter++ < 10) { __pmAFblock(); log_alarm = 0; #ifdef PCP_DEBUG if (pmDebug & DBG_TRACE_APPL2) fprintf(stderr, "delayed callback: log_alarm\n"); #endif for (tp = tasklist; tp != NULL; tp = tp->t_next) { if (tp->t_alarm) { tp->t_alarm = 0; do_work(tp); } } __pmAFunblock(); } if (vol_switch_alarm) { __pmAFblock(); vol_switch_alarm = 0; #ifdef PCP_DEBUG if (pmDebug & DBG_TRACE_APPL2) fprintf(stderr, "delayed callback: vol_switch_alarm\n"); #endif newvolume(VOL_SW_TIME); __pmAFunblock(); } if (run_done_alarm) { #ifdef PCP_DEBUG if (pmDebug & DBG_TRACE_APPL2) fprintf(stderr, "delayed callback: run_done_alarm\n"); #endif run_done(0, NULL); /*NOTREACHED*/ } __pmFD_COPY(&readyfds, &fds); nready = __pmSelectRead(numfds, &readyfds, NULL); #ifdef PCP_DEBUG if ((pmDebug & DBG_TRACE_APPL2) && (pmDebug & DBG_TRACE_DESPERATE)) { fprintf(stderr, "__pmSelectRead(%d,...) done: nready=%d run_done_alarm=%d vol_switch_alarm=%d log_alarm=%d\n", numfds, nready, run_done_alarm, vol_switch_alarm, log_alarm); } #endif __pmAFblock(); if (nready > 0) { /* handle request on control port */ for (i = 0; i < CFD_NUM; ++i) { if (ctlfds[i] >= 0 && __pmFD_ISSET(ctlfds[i], &readyfds)) { if (control_req(ctlfds[i])) { /* new client has connected */ __pmFD_SET(clientfd, &fds); if (clientfd >= numfds) numfds = clientfd + 1; } } } if (clientfd >= 0 && __pmFD_ISSET(clientfd, &readyfds)) { /* process request from client, save clientfd in case client * closes connection, resetting clientfd to -1 */ int fd = clientfd; if (client_req()) { /* client closed connection */ __pmFD_CLR(fd, &fds); __pmCloseSocket(clientfd); clientfd = -1; numfds = maxfd() + 1; qa_case = 0; } } #ifndef IS_MINGW if (pmcdfd >= 0 && __pmFD_ISSET(pmcdfd, &readyfds)) { /* * do not expect this, given synchronous commumication with the * pmcd ... either pmcd has terminated, or bogus PDU ... or its * Win32 and we are operating under the different conditions of * our AF.c implementation there, which has to deal with a lack * of signal support on Windows - race condition exists between * this check and the async event timer callback. */ __pmPDU *pb; __pmPDUHdr *php; sts = __pmGetPDU(pmcdfd, ANY_SIZE, TIMEOUT_NEVER, &pb); if (sts <= 0) { if (sts < 0) fprintf(stderr, "Error: __pmGetPDU: %s\n", pmErrStr(sts)); disconnect(sts); } else { php = (__pmPDUHdr *)pb; fprintf(stderr, "Error: Unsolicited %s PDU from PMCD\n", __pmPDUTypeStr(php->type)); disconnect(PM_ERR_IPC); } if (sts > 0) __pmUnpinPDUBuf(pb); } #endif if (rsc_fd >= 0 && __pmFD_ISSET(rsc_fd, &readyfds)) { /* * some action on the recording session control fd * end-of-file means launcher has quit, otherwise we * expect one of these commands * V<number>\n - version * F<folio>\n - folio name * P<name>\n - launcher's name * R\n - launcher can replay * D\n - detach from launcher * Q\n - quit pmlogger */ char rsc_buf[MAXPATHLEN]; char *rp = rsc_buf; char myc; int fake_x = 0; for (rp = rsc_buf; ; rp++) { if (read(rsc_fd, &myc, 1) <= 0) { #ifdef PCP_DEBUG if (pmDebug & DBG_TRACE_APPL2) fprintf(stderr, "recording session control: eof\n"); #endif if (rp != rsc_buf) { *rp = '\0'; fprintf(stderr, "Error: incomplete recording session control message: \"%s\"\n", rsc_buf); } fake_x = 1; break; } if (rp >= &rsc_buf[MAXPATHLEN]) { fprintf(stderr, "Error: absurd recording session control message: \"%100.100s ...\"\n", rsc_buf); fake_x = 1; break; } if (myc == '\n') { *rp = '\0'; break; } *rp = myc; } #ifdef PCP_DEBUG if (pmDebug & DBG_TRACE_APPL2) { if (fake_x == 0) fprintf(stderr, "recording session control: \"%s\"\n", rsc_buf); } #endif if (fake_x) do_dialog('X'); else if (strcmp(rsc_buf, "Q") == 0 || strcmp(rsc_buf, "D") == 0 || strcmp(rsc_buf, "?") == 0) do_dialog(rsc_buf[0]); else if (rsc_buf[0] == 'F') folio_name = strdup(&rsc_buf[1]); else if (rsc_buf[0] == 'P') rsc_prog = strdup(&rsc_buf[1]); else if (strcmp(rsc_buf, "R") == 0) rsc_replay = 1; else if (rsc_buf[0] == 'V' && rsc_buf[1] == '0') { /* * version 0 of the recording session control ... * this is all we grok at the moment */ ; } else { fprintf(stderr, "Error: illegal recording session control message: \"%s\"\n", rsc_buf); do_dialog('X'); } } } else if (vol_switch_flag) { newvolume(VOL_SW_SIGHUP); vol_switch_flag = 0; } else if (nready < 0 && neterror() != EINTR) fprintf(stderr, "Error: select: %s\n", netstrerror()); __pmAFunblock(); if (target_pid && !__pmProcessExists(target_pid)) exit(EXIT_SUCCESS); if (exit_code) break; } exit(exit_code); }
/* * ParseSize - parse a size argument given in a command option * * The size can be in one of the following forms: * "40" = sample counter of 40 * "40b" = byte size of 40 * "40Kb" = byte size of 40*1024 bytes = 40 kilobytes * "40Mb" = byte size of 40*1024*1024 bytes = 40 megabytes * time-format = time delta in seconds * */ static int ParseSize(char *size_arg, int *sample_counter, __int64_t *byte_size, struct timeval *time_delta) { long x = 0; /* the size number */ char *ptr = NULL; char *interval_err; *sample_counter = -1; *byte_size = -1; time_delta->tv_sec = -1; time_delta->tv_usec = -1; x = strtol(size_arg, &ptr, 10); /* must be positive */ if (x <= 0) return -1; if (*ptr == '\0') { /* we have consumed entire string as a long */ /* => we have a sample counter */ *sample_counter = x; return 1; } /* we have a number followed by something else */ if (ptr != size_arg) { int len; tolower_str(ptr); /* chomp off plurals */ len = strlen(ptr); if (ptr[len-1] == 's') ptr[len-1] = '\0'; /* if bytes */ if (strcmp(ptr, "b") == 0 || strcmp(ptr, "byte") == 0) { *byte_size = x; return 1; } /* if kilobytes */ if (strcmp(ptr, "k") == 0 || strcmp(ptr, "kb") == 0 || strcmp(ptr, "kbyte") == 0 || strcmp(ptr, "kilobyte") == 0) { *byte_size = x*1024; return 1; } /* if megabytes */ if (strcmp(ptr, "m") == 0 || strcmp(ptr, "mb") == 0 || strcmp(ptr, "mbyte") == 0 || strcmp(ptr, "megabyte") == 0) { *byte_size = x*1024*1024; return 1; } /* if gigabytes */ if (strcmp(ptr, "g") == 0 || strcmp(ptr, "gb") == 0 || strcmp(ptr, "gbyte") == 0 || strcmp(ptr, "gigabyte") == 0) { *byte_size = ((__int64_t)x)*1024*1024*1024; return 1; } } /* Doesn't fit pattern above, try a time interval */ if (pmParseInterval(size_arg, time_delta, &interval_err) >= 0) return 1; /* error message not used here */ free(interval_err); /* Doesn't match anything, return an error */ return -1; }
int QedApp::getopts(const char *options) { int unknown = 0; int c, sts, errflg = 0; char *endnum, *msg; do { switch ((c = getopt(my.argc, my.argv, options))) { case 'A': /* sample alignment */ my.Aflag = optarg; continue; case 'a': my.archives.append(optarg); break; case 'D': sts = __pmParseDebug(optarg); if (sts < 0) { pmprintf("%s: unrecognized debug flag specification (%s)\n", pmProgname, optarg); errflg++; } else pmDebug |= sts; break; case 'h': my.hosts.append(optarg); break; case 'L': /* local context */ my.Lflag = 1; break; case 'n': /* alternative PMNS */ my.pmnsfile = optarg; break; case 'O': /* sample offset */ my.Oflag = optarg; break; case 'p': /* existing pmtime port */ my.port = (int)strtol(optarg, &endnum, 10); if (*endnum != '\0' || c < 0) { pmprintf("%s: -p requires a numeric argument\n", pmProgname); errflg++; } break; case 'S': /* start run time */ my.Sflag = optarg; break; case 't': /* sampling interval */ if (pmParseInterval(optarg, &my.delta, &msg) < 0) { pmprintf("%s: cannot parse interval\n%s", pmProgname, msg); free(msg); errflg++; } continue; case 'T': /* run time */ my.Tflag = optarg; break; case 'V': /* version */ printf("%s %s\n", pmProgname, pmGetConfig("PCP_VERSION")); exit(0); case 'z': /* timezone from host */ if (my.tz != NULL) { pmprintf("%s: at most one of -Z and/or -z allowed\n", pmProgname); errflg++; } my.zflag++; break; case 'Z': /* $TZ timezone */ if (my.zflag) { pmprintf("%s: at most one of -Z and/or -z allowed\n", pmProgname); errflg++; } my.tz = optarg; break; default: unknown = 1; break; } } while (!unknown); return c; }
int main(int argc, char **argv) { static char helppath[MAXPATHLEN]; char *endnum; pmdaInterface desc; long minmem; int c, err = 0, sep = __pmPathSeparator(); minmem = getpagesize(); maxmem = (minmem > DEFAULT_MAXMEM) ? minmem : DEFAULT_MAXMEM; __pmSetProgname(argv[0]); snprintf(helppath, sizeof(helppath), "%s%c" "systemd" "%c" "help", pmGetConfig("PCP_PMDAS_DIR"), sep, sep); pmdaDaemon(&desc, PMDA_INTERFACE_6, pmProgname, SYSTEMD, "systemd.log", helppath); while ((c = pmdaGetOpt(argc, argv, "D:d:l:m:s:U:f?", &desc, &err)) != EOF) { switch (c) { case 'm': maxmem = strtol(optarg, &endnum, 10); if (*endnum != '\0') convertUnits(&endnum, &maxmem); if (*endnum != '\0' || maxmem < minmem) { fprintf(stderr, "%s: invalid max memory '%s' (min=%ld)\n", pmProgname, optarg, minmem); err++; } break; case 's': if (pmParseInterval(optarg, &interval, &endnum) < 0) { fprintf(stderr, "%s: -s requires a time interval: %s\n", pmProgname, endnum); free(endnum); err++; } break; case 'U': username = optarg; break; case 'f': uid_gid_filter_p = 0; break; default: err++; break; } } if (err) usage(); FD_ZERO (&fds); pmdaOpenLog(&desc); /* The systemwide journal may be accessed by the adm user (group); root access is not necessary. */ __pmSetProcessIdentity(username); desc.comm.flags |= PDU_FLAG_AUTH; pmdaConnect(&desc); // After this point, systemd_init is allowed to take some extra time. systemd_init(&desc); // sets some fds systemdMain(&desc); // sets some more fds systemd_shutdown(); exit(0); }
int main(int argc, char *argv[]) { register int i; int c; char *p; char path[MAXPATHLEN]; pmOptions opts = { .short_options = allflags, .flags = PM_OPTFLAG_BOUNDARIES, }; /* ** preserve command arguments to allow restart of other version */ argvp = argv; /* ** read defaults-files /etc/atoprc en $HOME/.atoprc (if any) */ readrc("/etc/atoprc", 1); if ( (p = getenv("HOME")) ) { snprintf(path, sizeof(path), "%s/.atoprc", p); path[sizeof(path)-1] = '\0'; readrc(path, 0); } /* ** check if we are supposed to behave as 'atopsar' ** i.e. system statistics only */ __pmSetProgname(argv[0]); if (strcmp(pmProgname, "pcp-atopsar") == 0) return atopsar(argc, argv); __pmStartOptions(&opts); if (opts.narchives > 0) rawreadflag++; /* ** interpret command-line arguments & flags */ if (argc > 1) { /* ** gather all flags for visualization-functions ** ** generic flags will be handled here; ** unrecognized flags are passed to the print-routines */ i = 0; while (i < MAXFL-1 && (c = pmgetopt_r(argc, argv, &opts)) != EOF) { switch (c) { case '?': /* usage wanted ? */ prusage(pmProgname); break; case 'V': /* version wanted ? */ printf("%s\n", getstrvers()); exit(0); case 'w': /* writing of raw data ? */ rawname = opts.optarg; rawwriteflag++; break; case 'r': /* reading of raw data ? */ rawarchive(&opts, opts.optarg); rawreadflag++; break; case 'S': /* midnight limit ? */ midnightflag++; break; case 'a': /* all processes per sample ? */ deviatonly = 0; break; case 'R': /* all processes per sample ? */ calcpss = 1; break; case 'b': /* begin time ? */ opts.start_optarg = abstime(opts.optarg); break; case 'e': /* end time ? */ opts.finish_optarg = abstime(opts.optarg); break; case 'P': /* parseable output? */ if ( !parsedef(opts.optarg) ) prusage(pmProgname); vis.show_samp = parseout; break; case 'L': /* line length */ if ( !numeric(opts.optarg) ) prusage(pmProgname); linelen = atoi(opts.optarg); break; default: /* gather other flags */ flaglist[i++] = c; } } /* ** get optional interval-value and optional number of samples */ if (opts.optind < argc && opts.optind < MAXFL) { char *endnum, *arg; arg = argv[opts.optind++]; if (pmParseInterval(arg, &opts.interval, &endnum) < 0) { pmprintf( "%s: %s option not in pmParseInterval(3) format:\n%s\n", pmProgname, arg, endnum); free(endnum); opts.errors++; } else interval = opts.interval; if (opts.optind < argc) { arg = argv[opts.optind]; if (!numeric(arg)) prusage(pmProgname); if ((opts.samples = atoi(arg)) < 1) prusage(pmProgname); nsamples = opts.samples; } } } __pmEndOptions(&opts); if (opts.errors) prusage(pmProgname); /* ** find local host details (no privileged access required) */ setup_globals(&opts); /* ** check if we are in data recording mode */ if (rawwriteflag) { rawwrite(&opts, rawname, &interval, nsamples, midnightflag); cleanstop(0); } /* ** catch signals for proper close-down */ signal(SIGHUP, cleanstop); signal(SIGTERM, cleanstop); /* ** switch-on the process-accounting mechanism to register the ** (remaining) resource-usage by processes which have finished */ acctreason = acctswon(); /* ** determine properties (like speed) of all interfaces */ initifprop(); /* ** open socket to the IP layer to issue getsockopt() calls later on */ netatop_ipopen(); /* ** start the engine now ..... */ engine(); cleanstop(0); return 0; /* never reached */ }
int QedApp::getopts(const char *options) { int unknown = 0; int c, errflg = 0; char *endnum, *msg; /* TODO: this code should all be removed (convert tool to pmGetOptions) */ do { switch ((c = getopt(my.argc, my.argv, options))) { case 'A': /* sample alignment */ my.Aflag = optarg; continue; case 'a': my.archives.append(optarg); break; case 'h': my.hosts.append(optarg); break; case 'L': /* local context */ my.Lflag = 1; break; case 'n': /* alternative PMNS */ my.pmnsfile = optarg; break; case 'O': /* sample offset */ my.Oflag = optarg; break; case 'p': /* existing pmtime port */ my.port = (int)strtol(optarg, &endnum, 10); if (*endnum != '\0' || c < 0) { pmprintf("%s: -p requires a numeric argument\n", pmGetProgname()); errflg++; } break; case 'S': /* start run time */ my.Sflag = optarg; break; case 't': /* sampling interval */ if (pmParseInterval(optarg, &my.delta, &msg) < 0) { pmprintf("%s: cannot parse interval\n%s", pmGetProgname(), msg); free(msg); errflg++; } continue; case 'T': /* run time */ my.Tflag = optarg; break; case 'V': /* version */ printf("%s %s\n", pmGetProgname(), pmGetConfig("PCP_VERSION")); exit(0); /*NOTREACHED*/ break; case 'z': /* timezone from host */ if (my.tz != NULL) { pmprintf("%s: at most one of -Z and/or -z allowed\n", pmGetProgname()); errflg++; } my.zflag++; break; case 'Z': /* $TZ timezone */ if (my.zflag) { pmprintf("%s: at most one of -Z and/or -z allowed\n", pmGetProgname()); errflg++; } my.tz = optarg; break; default: unknown = 1; break; } } while (!unknown); return c; }
/* * probe IRIX autofsd(1M) */ int main(int argc, char **argv) { struct timeval tv = { 10, 0 }; CLIENT *clnt; enum clnt_stat stat; int c; char *p; char *host = "local:"; int errflag = 0; __pmSetProgname(argv[0]); while ((c = getopt(argc, argv, "h:t:?")) != EOF) { switch (c) { case 'h': /* contact autofsd on this hostname */ host = optarg; break; case 't': /* change timeout interval */ if (pmParseInterval(optarg, &tv, &p) < 0) { fprintf(stderr, "%s: illegal -t argument\n", pmProgname); fputs(p, stderr); free(p); errflag++; } break; case '?': default: fprintf(stderr, "Usage: %s [-h host] [-t timeout]\n", pmProgname); errflag++; break; } } if (errflag) exit(4); if ((clnt = clnt_create(host, AUTOFSD_PROGRAM, AUTOFSD_VERSION, "udp")) == NULL) { clnt_pcreateerror("clnt_create"); exit(2); } /* * take control of the timeout algorithm */ clnt_control(clnt, CLSET_TIMEOUT, (char *)&tv); clnt_control(clnt, CLSET_RETRY_TIMEOUT, (char *)&tv); stat = clnt_call(clnt, NULLPROC, (xdrproc_t)xdr_void, (char *)0, (xdrproc_t)xdr_void, (char *)0, tv); if (stat != RPC_SUCCESS) { clnt_perror(clnt, "clnt_call"); exit(1); } exit(0); }