From: David Goulet Date: Thu, 10 Nov 2011 20:10:35 +0000 (-0500) Subject: Add tracepoint listing for UST X-Git-Tag: v2.0-pre15~137 X-Git-Url: http://git.lttng.org/?a=commitdiff_plain;h=b551a063b85ebdf0accaf2bbe06d0231a7b50f23;hp=874d3f847b8053e38a50321b17abce4248ce6e53;p=lttng-tools.git Add tracepoint listing for UST Signed-off-by: David Goulet --- diff --git a/include/lttng/lttng.h b/include/lttng/lttng.h index a96c11f1d..ee749c1f6 100644 --- a/include/lttng/lttng.h +++ b/include/lttng/lttng.h @@ -145,6 +145,7 @@ struct lttng_event { char name[LTTNG_SYMBOL_NAME_LEN]; enum lttng_event_type type; uint32_t enabled; + pid_t pid; /* Per event type configuration */ union { struct lttng_event_probe_attr probe; diff --git a/lttng-sessiond/main.c b/lttng-sessiond/main.c index cc7885399..16dd9ab5d 100644 --- a/lttng-sessiond/main.c +++ b/lttng-sessiond/main.c @@ -1794,7 +1794,7 @@ static void list_lttng_sessions(struct lttng_session *sessions) /* * Fill lttng_channel array of all channels. */ -static void list_lttng_channels(struct ltt_session *session, +static void list_lttng_channels(int domain, struct ltt_session *session, struct lttng_channel *channels) { int i = 0; @@ -1802,59 +1802,162 @@ static void list_lttng_channels(struct ltt_session *session, DBG("Listing channels for session %s", session->name); - /* Kernel channels */ - if (session->kernel_session != NULL) { - cds_list_for_each_entry(kchan, - &session->kernel_session->channel_list.head, list) { - /* Copy lttng_channel struct to array */ - memcpy(&channels[i], kchan->channel, sizeof(struct lttng_channel)); - channels[i].enabled = kchan->enabled; + switch (domain) { + case LTTNG_DOMAIN_KERNEL: + /* Kernel channels */ + if (session->kernel_session != NULL) { + cds_list_for_each_entry(kchan, + &session->kernel_session->channel_list.head, list) { + /* Copy lttng_channel struct to array */ + memcpy(&channels[i], kchan->channel, sizeof(struct lttng_channel)); + channels[i].enabled = kchan->enabled; + i++; + } + } + break; + case LTTNG_DOMAIN_UST: + { + struct cds_lfht_iter iter; + struct ltt_ust_channel *uchan; + + cds_lfht_for_each_entry(session->ust_session->domain_global.channels, + &iter, uchan, node) { + strncpy(channels[i].name, uchan->name, LTTNG_SYMBOL_NAME_LEN); + channels[i].attr.overwrite = uchan->attr.overwrite; + channels[i].attr.subbuf_size = uchan->attr.subbuf_size; + channels[i].attr.num_subbuf = uchan->attr.num_subbuf; + channels[i].attr.switch_timer_interval = + uchan->attr.switch_timer_interval; + channels[i].attr.read_timer_interval = + uchan->attr.read_timer_interval; + channels[i].attr.output = uchan->attr.output; + } + break; + } + default: + break; + } +} + +/* + * Create a list of ust global domain events. + */ +static int list_lttng_ust_global_events(char *channel_name, + struct ltt_ust_domain_global *ust_global, struct lttng_event **events) +{ + int i = 0, ret = 0; + unsigned int nb_event = 0; + struct cds_lfht_iter iter; + struct ltt_ust_channel *uchan; + struct ltt_ust_event *uevent; + struct lttng_event *tmp; + + DBG("Listing UST global events for channel %s", channel_name); + + rcu_read_lock(); + + /* Count events in all channels */ + cds_lfht_for_each_entry(ust_global->channels, &iter, uchan, node) { + nb_event += hashtable_get_count(uchan->events); + } + + if (nb_event == 0) { + ret = nb_event; + goto error; + } + + DBG3("Listing UST global %d events", nb_event); + + tmp = zmalloc(nb_event * sizeof(struct lttng_event)); + if (tmp == NULL) { + ret = -LTTCOMM_FATAL; + goto error; + } + + cds_lfht_for_each_entry(ust_global->channels, &iter, uchan, node) { + cds_lfht_for_each_entry(uchan->events, &iter, uevent, node) { + strncpy(tmp[i].name, uevent->attr.name, LTTNG_SYMBOL_NAME_LEN); + tmp[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0'; + switch (uevent->attr.instrumentation) { + case LTTNG_UST_TRACEPOINT: + tmp[i].type = LTTNG_EVENT_TRACEPOINT; + break; + case LTTNG_UST_PROBE: + tmp[i].type = LTTNG_EVENT_PROBE; + break; + case LTTNG_UST_FUNCTION: + tmp[i].type = LTTNG_EVENT_FUNCTION; + break; + } i++; } } - /* TODO: Missing UST listing */ + ret = nb_event; + *events = tmp; + +error: + rcu_read_unlock(); + return ret; } /* - * Fill lttng_event array of all events in the channel. + * Fill lttng_event array of all kernel events in the channel. */ -static void list_lttng_events(struct ltt_kernel_channel *kchan, - struct lttng_event *events) +static int list_lttng_kernel_events(char *channel_name, + struct ltt_kernel_session *kernel_session, struct lttng_event **events) { - /* - * TODO: This is ONLY kernel. Need UST support. - */ - int i = 0; + int i = 0, ret; + unsigned int nb_event; struct ltt_kernel_event *event; + struct ltt_kernel_channel *kchan; + + kchan = trace_kernel_get_channel_by_name(channel_name, kernel_session); + if (kchan == NULL) { + ret = LTTCOMM_KERN_CHAN_NOT_FOUND; + goto error; + } + + nb_event = kchan->event_count; DBG("Listing events for channel %s", kchan->channel->name); + if (nb_event == 0) { + ret = nb_event; + goto error; + } + + *events = zmalloc(nb_event * sizeof(struct lttng_event)); + if (*events == NULL) { + ret = LTTCOMM_FATAL; + goto error; + } + /* Kernel channels */ cds_list_for_each_entry(event, &kchan->events_list.head , list) { - strncpy(events[i].name, event->event->name, LTTNG_SYMBOL_NAME_LEN); - events[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0'; - events[i].enabled = event->enabled; + strncpy((*events)[i].name, event->event->name, LTTNG_SYMBOL_NAME_LEN); + (*events)[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0'; + (*events)[i].enabled = event->enabled; switch (event->event->instrumentation) { case LTTNG_KERNEL_TRACEPOINT: - events[i].type = LTTNG_EVENT_TRACEPOINT; + (*events)[i].type = LTTNG_EVENT_TRACEPOINT; break; case LTTNG_KERNEL_KPROBE: case LTTNG_KERNEL_KRETPROBE: - events[i].type = LTTNG_EVENT_PROBE; - memcpy(&events[i].attr.probe, &event->event->u.kprobe, + (*events)[i].type = LTTNG_EVENT_PROBE; + memcpy(&(*events)[i].attr.probe, &event->event->u.kprobe, sizeof(struct lttng_kernel_kprobe)); break; case LTTNG_KERNEL_FUNCTION: - events[i].type = LTTNG_EVENT_FUNCTION; - memcpy(&events[i].attr.ftrace, &event->event->u.ftrace, + (*events)[i].type = LTTNG_EVENT_FUNCTION; + memcpy(&((*events)[i].attr.ftrace), &event->event->u.ftrace, sizeof(struct lttng_kernel_function)); break; case LTTNG_KERNEL_NOOP: - events[i].type = LTTNG_EVENT_NOOP; + (*events)[i].type = LTTNG_EVENT_NOOP; break; case LTTNG_KERNEL_SYSCALL: - events[i].type = LTTNG_EVENT_SYSCALL; + (*events)[i].type = LTTNG_EVENT_SYSCALL; break; case LTTNG_KERNEL_ALL: assert(0); @@ -1862,6 +1965,11 @@ static void list_lttng_events(struct ltt_kernel_channel *kchan, } i++; } + + return nb_event; + +error: + return ret; } /* @@ -2358,8 +2466,14 @@ static ssize_t cmd_list_tracepoints(int domain, struct lttng_event **events) goto error; } break; + case LTTNG_DOMAIN_UST: + nb_events = ust_app_list_events(events); + if (nb_events < 0) { + ret = LTTCOMM_UST_LIST_FAIL; + goto error; + } + break; default: - /* TODO: Userspace listing */ ret = LTTCOMM_NOT_IMPLEMENTED; goto error; } @@ -2641,22 +2755,34 @@ error: static ssize_t cmd_list_domains(struct ltt_session *session, struct lttng_domain **domains) { - int ret; + int ret, index = 0; ssize_t nb_dom = 0; if (session->kernel_session != NULL) { + DBG3("Listing domains found kernel domain"); nb_dom++; } - /* TODO: User-space tracer domain support */ + if (session->ust_session != NULL) { + DBG3("Listing domains found UST global domain"); + nb_dom++; + } - *domains = malloc(nb_dom * sizeof(struct lttng_domain)); + *domains = zmalloc(nb_dom * sizeof(struct lttng_domain)); if (*domains == NULL) { ret = -LTTCOMM_FATAL; goto error; } - (*domains)[0].type = LTTNG_DOMAIN_KERNEL; + if (session->kernel_session != NULL) { + (*domains)[index].type = LTTNG_DOMAIN_KERNEL; + index++; + } + + if (session->ust_session != NULL) { + (*domains)[index].type = LTTNG_DOMAIN_UST; + index++; + } return nb_dom; @@ -2667,25 +2793,43 @@ error: /* * Command LTTNG_LIST_CHANNELS processed by the client thread. */ -static ssize_t cmd_list_channels(struct ltt_session *session, +static ssize_t cmd_list_channels(int domain, struct ltt_session *session, struct lttng_channel **channels) { int ret; ssize_t nb_chan = 0; - if (session->kernel_session != NULL) { - nb_chan += session->kernel_session->channel_count; - } - - *channels = malloc(nb_chan * sizeof(struct lttng_channel)); - if (*channels == NULL) { - ret = -LTTCOMM_FATAL; + switch (domain) { + case LTTNG_DOMAIN_KERNEL: + if (session->kernel_session != NULL) { + nb_chan = session->kernel_session->channel_count; + } + DBG3("Number of kernel channels %ld", nb_chan); + break; + case LTTNG_DOMAIN_UST: + if (session->ust_session != NULL) { + nb_chan = hashtable_get_count( + session->ust_session->domain_global.channels); + } + DBG3("Number of UST global channels %ld", nb_chan); + break; + default: + *channels = NULL; + ret = -LTTCOMM_NOT_IMPLEMENTED; goto error; } - list_lttng_channels(session, *channels); + if (nb_chan > 0) { + *channels = zmalloc(nb_chan * sizeof(struct lttng_channel)); + if (*channels == NULL) { + ret = -LTTCOMM_FATAL; + goto error; + } - /* TODO UST support */ + list_lttng_channels(domain, session, *channels); + } else { + *channels = NULL; + } return nb_chan; @@ -2696,34 +2840,33 @@ error: /* * Command LTTNG_LIST_EVENTS processed by the client thread. */ -static ssize_t cmd_list_events(struct ltt_session *session, +static ssize_t cmd_list_events(int domain, struct ltt_session *session, char *channel_name, struct lttng_event **events) { - int ret; + int ret = 0; ssize_t nb_event = 0; - struct ltt_kernel_channel *kchan = NULL; - if (session->kernel_session != NULL) { - kchan = trace_kernel_get_channel_by_name(channel_name, - session->kernel_session); - if (kchan == NULL) { - ret = -LTTCOMM_KERN_CHAN_NOT_FOUND; - goto error; + switch (domain) { + case LTTNG_DOMAIN_KERNEL: + if (session->kernel_session != NULL) { + nb_event = list_lttng_kernel_events(channel_name, + session->kernel_session, events); } - nb_event += kchan->event_count; + break; + case LTTNG_DOMAIN_UST: + { + if (session->ust_session != NULL) { + nb_event = list_lttng_ust_global_events(channel_name, + &session->ust_session->domain_global, events); + } + break; } - - *events = malloc(nb_event * sizeof(struct lttng_event)); - if (*events == NULL) { - ret = -LTTCOMM_FATAL; + default: + ret = -LTTCOMM_NOT_IMPLEMENTED; goto error; } - list_lttng_events(kchan, *events); - - /* TODO: User-space tracer support */ - - return nb_event; + ret = nb_event; error: return ret; @@ -2999,7 +3142,8 @@ static int process_client_msg(struct command_ctx *cmd_ctx) size_t nb_chan; struct lttng_channel *channels; - nb_chan = cmd_list_channels(cmd_ctx->session, &channels); + nb_chan = cmd_list_channels(cmd_ctx->lsm->domain.type, + cmd_ctx->session, &channels); if (nb_chan < 0) { ret = -nb_chan; goto error; @@ -3021,10 +3165,10 @@ static int process_client_msg(struct command_ctx *cmd_ctx) } case LTTNG_LIST_EVENTS: { - size_t nb_event; + ssize_t nb_event; struct lttng_event *events = NULL; - nb_event = cmd_list_events(cmd_ctx->session, + nb_event = cmd_list_events(cmd_ctx->lsm->domain.type, cmd_ctx->session, cmd_ctx->lsm->u.list.channel_name, &events); if (nb_event < 0) { ret = -nb_event; diff --git a/lttng-sessiond/ust-app.c b/lttng-sessiond/ust-app.c index d93dc90f5..e063fb292 100644 --- a/lttng-sessiond/ust-app.c +++ b/lttng-sessiond/ust-app.c @@ -264,6 +264,66 @@ unsigned long ust_app_list_count(void) return count; } +/* + * Fill events array with all events name of all registered apps. + */ +int ust_app_list_events(struct lttng_event **events) +{ + int ret, handle; + size_t nbmem, count = 0; + struct cds_lfht_iter iter; + struct ust_app *app; + struct lttng_event *tmp; + + nbmem = UST_APP_EVENT_LIST_SIZE; + tmp = zmalloc(nbmem * sizeof(struct lttng_event)); + if (tmp == NULL) { + PERROR("zmalloc ust app events"); + ret = -ENOMEM; + goto error; + } + + rcu_read_lock(); + + cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) { + handle = ustctl_tracepoint_list(app->key.sock); + if (handle < 0) { + ERR("UST app list events getting handle failed for app pid %d", + app->key.pid); + continue; + } + + while ((ret = ustctl_tracepoint_list_get(app->key.sock, handle, + tmp[count].name)) != -ENOENT) { + if (count > nbmem) { + DBG2("Reallocating event list from %zu to %zu bytes", nbmem, + nbmem + UST_APP_EVENT_LIST_SIZE); + nbmem += UST_APP_EVENT_LIST_SIZE; + tmp = realloc(tmp, nbmem); + if (tmp == NULL) { + PERROR("realloc ust app events"); + ret = -ENOMEM; + goto rcu_error; + } + } + + tmp[count].type = LTTNG_UST_TRACEPOINT; + tmp[count].pid = app->key.pid; + count++; + } + } + + ret = count; + *events = tmp; + + DBG2("UST app list events done (%zu events)", count); + +rcu_error: + rcu_read_unlock(); +error: + return ret; +} + /* * Free and clean all traceable apps of the global list. */ diff --git a/lttng-sessiond/ust-app.h b/lttng-sessiond/ust-app.h index 76b81b29a..bcde8bc9c 100644 --- a/lttng-sessiond/ust-app.h +++ b/lttng-sessiond/ust-app.h @@ -24,6 +24,8 @@ #include "trace-ust.h" +#define UST_APP_EVENT_LIST_SIZE 32 + /* * Application registration data structure. */ @@ -108,6 +110,7 @@ int ust_app_add_event_all(struct ltt_ust_session *usess, unsigned long ust_app_list_count(void); int ust_app_start_trace(struct ltt_ust_session *usess, struct ust_app *app); int ust_app_start_trace_all(struct ltt_ust_session *usess); +int ust_app_list_events(struct lttng_event **events); void ust_app_global_update(struct ltt_ust_session *usess, int sock); void ust_app_clean_list(void); @@ -128,6 +131,11 @@ int ust_app_start_trace_all(struct ltt_ust_session *usess) return 0; } static inline +int ust_app_list_events(struct lttng_event **events) +{ + return 0; +} +static inline int ust_app_register(struct ust_register_msg *msg, int sock) { return -ENOSYS; diff --git a/lttng/commands/list.c b/lttng/commands/list.c index 50dad9a2b..808c2a549 100644 --- a/lttng/commands/list.c +++ b/lttng/commands/list.c @@ -82,7 +82,6 @@ static void usage(FILE *ofp) * On success, return an allocated string pointer to the proc cmdline. * On error, return NULL. */ -#ifdef DISABLE static char *get_cmdline_by_pid(pid_t pid) { int ret; @@ -107,7 +106,97 @@ static char *get_cmdline_by_pid(pid_t pid) end: return cmdline; } -#endif /* DISABLE */ + +/* + * Pretty print single event. + */ +static void print_events(struct lttng_event *event) +{ + switch (event->type) { + case LTTNG_EVENT_TRACEPOINT: + MSG("%s%s (type: tracepoint) [enabled: %d]", indent6, + event->name, event->enabled); + break; + case LTTNG_EVENT_PROBE: + MSG("%s%s (type: probe) [enabled: %d]", indent6, + event->name, event->enabled); + if (event->attr.probe.addr != 0) { + MSG("%saddr: 0x%" PRIx64, indent8, event->attr.probe.addr); + } else { + MSG("%soffset: 0x%" PRIx64, indent8, event->attr.probe.offset); + MSG("%ssymbol: %s", indent8, event->attr.probe.symbol_name); + } + break; + case LTTNG_EVENT_FUNCTION: + case LTTNG_EVENT_FUNCTION_ENTRY: + MSG("%s%s (type: function) [enabled: %d]", indent6, + event->name, event->enabled); + MSG("%ssymbol: \"%s\"", indent8, event->attr.ftrace.symbol_name); + break; + case LTTNG_EVENT_SYSCALL: + MSG("%s (type: syscall) [enabled: %d]", indent6, + event->enabled); + break; + case LTTNG_EVENT_NOOP: + MSG("%s (type: noop) [enabled: %d]", indent6, + event->enabled); + break; + case LTTNG_EVENT_ALL: + /* We should never have "all" events in list. */ + assert(0); + break; + } +} + +/* + * Ask session daemon for all user space tracepoints available. + */ +static int list_ust_events(void) +{ + int i, size; + struct lttng_domain domain; + struct lttng_handle *handle; + struct lttng_event *event_list; + pid_t cur_pid = 0; + + DBG("Getting UST tracing events"); + + domain.type = LTTNG_DOMAIN_UST; + + handle = lttng_create_handle(NULL, &domain); + if (handle == NULL) { + goto error; + } + + size = lttng_list_tracepoints(handle, &event_list); + if (size < 0) { + ERR("Unable to list UST events"); + return size; + } + + MSG("UST events:\n-------------"); + + if (size == 0) { + MSG("None"); + } + + for (i = 0; i < size; i++) { + if (cur_pid != event_list[i].pid) { + cur_pid = event_list[i].pid; + MSG("\nPID: %d - Name: %s", cur_pid, get_cmdline_by_pid(cur_pid)); + } + print_events(&event_list[i]); + } + + MSG(""); + + free(event_list); + + return CMD_SUCCESS; + +error: + return -1; +} /* * Ask for all trace events in the kernel and pretty print them. @@ -115,9 +204,18 @@ end: static int list_kernel_events(void) { int i, size; + struct lttng_domain domain; + struct lttng_handle *handle; struct lttng_event *event_list; - DBG("Getting all tracing events"); + DBG("Getting kernel tracing events"); + + domain.type = LTTNG_DOMAIN_KERNEL; + + handle = lttng_create_handle(NULL, &domain); + if (handle == NULL) { + goto error; + } size = lttng_list_tracepoints(handle, &event_list); if (size < 0) { @@ -128,12 +226,17 @@ static int list_kernel_events(void) MSG("Kernel events:\n-------------"); for (i = 0; i < size; i++) { - MSG(" %s", event_list[i].name); + print_events(&event_list[i]); } + MSG(""); + free(event_list); return CMD_SUCCESS; + +error: + return -1; } /* @@ -157,40 +260,7 @@ static int list_events(const char *channel_name) } for (i = 0; i < count; i++) { - switch (events[i].type) { - case LTTNG_EVENT_TRACEPOINT: - MSG("%s%s (type: tracepoint) [enabled: %d]", indent6, - events[i].name, events[i].enabled); - break; - case LTTNG_EVENT_PROBE: - MSG("%s%s (type: probe) [enabled: %d]", indent6, - events[i].name, events[i].enabled); - if (events[i].attr.probe.addr != 0) { - MSG("%saddr: 0x%" PRIx64, indent8, events[i].attr.probe.addr); - } else { - MSG("%soffset: 0x%" PRIx64, indent8, events[i].attr.probe.offset); - MSG("%ssymbol: %s", indent8, events[i].attr.probe.symbol_name); - } - break; - case LTTNG_EVENT_FUNCTION: - case LTTNG_EVENT_FUNCTION_ENTRY: - MSG("%s%s (type: function) [enabled: %d]", indent6, - events[i].name, events[i].enabled); - MSG("%ssymbol: \"%s\"", indent8, events[i].attr.ftrace.symbol_name); - break; - case LTTNG_EVENT_SYSCALL: - MSG("%s (type: syscall) [enabled: %d]", indent6, - events[i].enabled); - break; - case LTTNG_EVENT_NOOP: - MSG("%s (type: noop) [enabled: %d]", indent6, - events[i].enabled); - break; - case LTTNG_EVENT_ALL: - /* We should never have "all" events in list. */ - assert(0); - break; - } + print_events(&events[i]); } MSG(""); @@ -366,6 +436,10 @@ static int list_domains(void) switch (domains[i].type) { case LTTNG_DOMAIN_KERNEL: MSG(" - Kernel"); + break; + case LTTNG_DOMAIN_UST: + MSG(" - UST global"); + break; default: break; } @@ -384,6 +458,7 @@ error: int cmd_list(int argc, const char **argv) { int opt, i, ret = CMD_SUCCESS; + unsigned int nb_domain; const char *session_name; static poptContext pc; struct lttng_domain domain; @@ -409,16 +484,19 @@ int cmd_list(int argc, const char **argv) } } - if (opt_userspace || opt_pid != 0) { - MSG("*** Userspace tracing not implemented ***\n"); + if (opt_pid != 0) { + MSG("*** Userspace tracing not implemented for PID ***\n"); } /* Get session name (trailing argument) */ session_name = poptGetArg(pc); - DBG("Session name: %s", session_name); + DBG2("Session name: %s", session_name); if (opt_kernel) { domain.type = LTTNG_DOMAIN_KERNEL; + } else if (opt_userspace) { + DBG2("Listing userspace global domain"); + domain.type = LTTNG_DOMAIN_UST; } handle = lttng_create_handle(session_name, &domain); @@ -427,13 +505,20 @@ int cmd_list(int argc, const char **argv) } if (session_name == NULL) { + if (!opt_kernel && !opt_userspace) { + ret = list_sessions(NULL); + if (ret < 0) { + goto end; + } + } if (opt_kernel) { ret = list_kernel_events(); if (ret < 0) { goto end; } - } else { - ret = list_sessions(NULL); + } + if (opt_userspace) { + ret = list_ust_events(); if (ret < 0) { goto end; } @@ -457,20 +542,22 @@ int cmd_list(int argc, const char **argv) if (ret < 0) { goto end; } - } else if (opt_userspace) { - /* TODO: Userspace domain */ } else { /* We want all domain(s) */ - ret = lttng_list_domains(handle, &domains); - if (ret < 0) { + nb_domain = lttng_list_domains(handle, &domains); + if (nb_domain < 0) { + ret = nb_domain; goto end; } - for (i = 0; i < ret; i++) { + for (i = 0; i < nb_domain; i++) { switch (domains[i].type) { case LTTNG_DOMAIN_KERNEL: MSG("=== Domain: Kernel ===\n"); break; + case LTTNG_DOMAIN_UST: + MSG("=== Domain: UST global ===\n"); + break; default: MSG("=== Domain: Unimplemented ===\n"); break; diff --git a/lttng/lttng.c b/lttng/lttng.c index e488cc566..d0f23579d 100644 --- a/lttng/lttng.c +++ b/lttng/lttng.c @@ -380,7 +380,7 @@ static int parse_args(int argc, char **argv) usage(stderr); goto error; case 'v': - opt_verbose = 1; + opt_verbose += 1; break; case 'q': opt_quiet = 1;