/* * usage */ static void usage(FILE *ofp) { fprintf(ofp, "usage: lttng enable-channel NAME[,NAME2,...] (-u | -k) [OPTIONS]\n"); fprintf(ofp, "\n"); fprintf(ofp, "Options:\n"); fprintf(ofp, " -h, --help Show this help\n"); fprintf(ofp, " --list-options Simple listing of options\n"); fprintf(ofp, " -s, --session NAME Apply to session name\n"); fprintf(ofp, " -k, --kernel Apply to the kernel tracer\n"); fprintf(ofp, " -u, --userspace Apply to the user-space tracer\n"); fprintf(ofp, "\n"); fprintf(ofp, "Channel options:\n"); fprintf(ofp, " --discard Discard event when buffers are full%s\n", DEFAULT_CHANNEL_OVERWRITE ? "" : " (default)"); fprintf(ofp, " --overwrite Flight recorder mode%s\n", DEFAULT_CHANNEL_OVERWRITE ? " (default)" : ""); fprintf(ofp, " --subbuf-size SIZE Subbuffer size in bytes {+k,+M,+G}\n"); fprintf(ofp, " (default UST uid: %zu, UST pid: %zu, kernel: %zu, metadata: %zu)\n", default_get_ust_uid_channel_subbuf_size(), default_get_ust_pid_channel_subbuf_size(), default_get_kernel_channel_subbuf_size(), default_get_metadata_subbuf_size()); fprintf(ofp, " Rounded up to the next power of 2.\n"); fprintf(ofp, " --num-subbuf NUM Number of subbufers\n"); fprintf(ofp, " (default UST uid: %u, UST pid: %u, kernel: %u, metadata: %u)\n", DEFAULT_UST_UID_CHANNEL_SUBBUF_NUM, DEFAULT_UST_PID_CHANNEL_SUBBUF_NUM, DEFAULT_KERNEL_CHANNEL_SUBBUF_NUM, DEFAULT_METADATA_SUBBUF_NUM); fprintf(ofp, " Rounded up to the next power of 2.\n"); fprintf(ofp, " --switch-timer USEC Switch timer interval in usec\n"); fprintf(ofp, " (default UST uid: %u, UST pid: %u, kernel: %u, metadata: %u)\n", DEFAULT_UST_UID_CHANNEL_SWITCH_TIMER, DEFAULT_UST_PID_CHANNEL_SWITCH_TIMER, DEFAULT_KERNEL_CHANNEL_SWITCH_TIMER, DEFAULT_METADATA_SWITCH_TIMER); fprintf(ofp, " --read-timer USEC Read timer interval in usec.\n"); fprintf(ofp, " (default UST uid: %u, UST pid: %u, kernel: %u, metadata: %u)\n", DEFAULT_UST_UID_CHANNEL_READ_TIMER, DEFAULT_UST_UID_CHANNEL_READ_TIMER, DEFAULT_KERNEL_CHANNEL_READ_TIMER, DEFAULT_METADATA_READ_TIMER); fprintf(ofp, " --output TYPE Channel output type (Values: %s, %s)\n", output_mmap, output_splice); fprintf(ofp, " (default UST uid: %s, UST pid: %s, kernel: %s, metadata: %s)\n", DEFAULT_UST_UID_CHANNEL_OUTPUT == LTTNG_EVENT_MMAP ? output_mmap : output_splice, DEFAULT_UST_PID_CHANNEL_OUTPUT == LTTNG_EVENT_MMAP ? output_mmap : output_splice, DEFAULT_KERNEL_CHANNEL_OUTPUT == LTTNG_EVENT_MMAP ? output_mmap : output_splice, DEFAULT_METADATA_OUTPUT == LTTNG_EVENT_MMAP ? output_mmap : output_splice); fprintf(ofp, " --buffers-uid Use per UID buffer (-u only)\n"); fprintf(ofp, " --buffers-pid Use per PID buffer (-u only)\n"); fprintf(ofp, " --buffers-global Use shared buffer for the whole system (-k only)\n"); fprintf(ofp, " -C, --tracefile-size SIZE\n"); fprintf(ofp, " Maximum size of each tracefile within a stream (in bytes). 0 means unlimited.\n"); fprintf(ofp, " (default: %u)\n", DEFAULT_CHANNEL_TRACEFILE_SIZE); fprintf(ofp, " Note: traces generated with this option may inaccurately report\n"); fprintf(ofp, " discarded events as per CTF 1.8.\n"); fprintf(ofp, " -W, --tracefile-count COUNT\n"); fprintf(ofp, " Used in conjunction with -C option, this will limit the number\n"); fprintf(ofp, " of files created to the specified count. 0 means unlimited.\n"); fprintf(ofp, " (default: %u)\n", DEFAULT_CHANNEL_TRACEFILE_COUNT); fprintf(ofp, "\n"); }
/* * Set default channel attributes. * If either or both of the arguments are null, attr content is zeroe'd. */ void lttng_channel_set_default_attr(struct lttng_domain *domain, struct lttng_channel_attr *attr) { /* Safety check */ if (attr == NULL || domain == NULL) { return; } memset(attr, 0, sizeof(struct lttng_channel_attr)); /* Same for all domains. */ attr->overwrite = DEFAULT_CHANNEL_OVERWRITE; attr->tracefile_size = DEFAULT_CHANNEL_TRACEFILE_SIZE; attr->tracefile_count = DEFAULT_CHANNEL_TRACEFILE_COUNT; switch (domain->type) { case LTTNG_DOMAIN_KERNEL: attr->switch_timer_interval = DEFAULT_KERNEL_CHANNEL_SWITCH_TIMER; attr->read_timer_interval = DEFAULT_KERNEL_CHANNEL_READ_TIMER; attr->subbuf_size = default_get_kernel_channel_subbuf_size(); attr->num_subbuf = DEFAULT_KERNEL_CHANNEL_SUBBUF_NUM; attr->output = DEFAULT_KERNEL_CHANNEL_OUTPUT; break; case LTTNG_DOMAIN_UST: switch (domain->buf_type) { case LTTNG_BUFFER_PER_UID: attr->subbuf_size = default_get_ust_uid_channel_subbuf_size(); attr->num_subbuf = DEFAULT_UST_UID_CHANNEL_SUBBUF_NUM; attr->output = DEFAULT_UST_UID_CHANNEL_OUTPUT; attr->switch_timer_interval = DEFAULT_UST_UID_CHANNEL_SWITCH_TIMER; attr->read_timer_interval = DEFAULT_UST_UID_CHANNEL_READ_TIMER; break; case LTTNG_BUFFER_PER_PID: default: attr->subbuf_size = default_get_ust_pid_channel_subbuf_size(); attr->num_subbuf = DEFAULT_UST_PID_CHANNEL_SUBBUF_NUM; attr->output = DEFAULT_UST_PID_CHANNEL_OUTPUT; attr->switch_timer_interval = DEFAULT_UST_PID_CHANNEL_SWITCH_TIMER; attr->read_timer_interval = DEFAULT_UST_PID_CHANNEL_READ_TIMER; break; } default: /* Default behavior: leave set to 0. */ break; } }
/* * Return allocated channel attributes. */ struct lttng_channel *channel_new_default_attr(int dom, enum lttng_buffer_type type) { struct lttng_channel *chan; const char *channel_name = DEFAULT_CHANNEL_NAME; struct lttng_channel_extended *extended_attr = NULL; chan = zmalloc(sizeof(struct lttng_channel)); if (chan == NULL) { PERROR("zmalloc channel init"); goto error_alloc; } extended_attr = zmalloc(sizeof(struct lttng_channel_extended)); if (!extended_attr) { PERROR("zmalloc channel extended init"); goto error; } chan->attr.extended.ptr = extended_attr; /* Same for all domains. */ chan->attr.overwrite = DEFAULT_CHANNEL_OVERWRITE; chan->attr.tracefile_size = DEFAULT_CHANNEL_TRACEFILE_SIZE; chan->attr.tracefile_count = DEFAULT_CHANNEL_TRACEFILE_COUNT; switch (dom) { case LTTNG_DOMAIN_KERNEL: assert(type == LTTNG_BUFFER_GLOBAL); chan->attr.subbuf_size = default_get_kernel_channel_subbuf_size(); chan->attr.num_subbuf = DEFAULT_KERNEL_CHANNEL_SUBBUF_NUM; chan->attr.output = DEFAULT_KERNEL_CHANNEL_OUTPUT; chan->attr.switch_timer_interval = DEFAULT_KERNEL_CHANNEL_SWITCH_TIMER; chan->attr.read_timer_interval = DEFAULT_KERNEL_CHANNEL_READ_TIMER; chan->attr.live_timer_interval = DEFAULT_KERNEL_CHANNEL_LIVE_TIMER; extended_attr->blocking_timeout = DEFAULT_KERNEL_CHANNEL_BLOCKING_TIMEOUT; extended_attr->monitor_timer_interval = DEFAULT_KERNEL_CHANNEL_MONITOR_TIMER; break; case LTTNG_DOMAIN_JUL: channel_name = DEFAULT_JUL_CHANNEL_NAME; goto common_ust; case LTTNG_DOMAIN_LOG4J: channel_name = DEFAULT_LOG4J_CHANNEL_NAME; goto common_ust; case LTTNG_DOMAIN_PYTHON: channel_name = DEFAULT_PYTHON_CHANNEL_NAME; goto common_ust; case LTTNG_DOMAIN_UST: common_ust: switch (type) { case LTTNG_BUFFER_PER_UID: chan->attr.subbuf_size = default_get_ust_uid_channel_subbuf_size(); chan->attr.num_subbuf = DEFAULT_UST_UID_CHANNEL_SUBBUF_NUM; chan->attr.output = DEFAULT_UST_UID_CHANNEL_OUTPUT; chan->attr.switch_timer_interval = DEFAULT_UST_UID_CHANNEL_SWITCH_TIMER; chan->attr.read_timer_interval = DEFAULT_UST_UID_CHANNEL_READ_TIMER; chan->attr.live_timer_interval = DEFAULT_UST_UID_CHANNEL_LIVE_TIMER; extended_attr->blocking_timeout = DEFAULT_UST_UID_CHANNEL_BLOCKING_TIMEOUT; extended_attr->monitor_timer_interval = DEFAULT_UST_UID_CHANNEL_MONITOR_TIMER; break; case LTTNG_BUFFER_PER_PID: default: chan->attr.subbuf_size = default_get_ust_pid_channel_subbuf_size(); chan->attr.num_subbuf = DEFAULT_UST_PID_CHANNEL_SUBBUF_NUM; chan->attr.output = DEFAULT_UST_PID_CHANNEL_OUTPUT; chan->attr.switch_timer_interval = DEFAULT_UST_PID_CHANNEL_SWITCH_TIMER; chan->attr.read_timer_interval = DEFAULT_UST_PID_CHANNEL_READ_TIMER; chan->attr.live_timer_interval = DEFAULT_UST_PID_CHANNEL_LIVE_TIMER; extended_attr->blocking_timeout = DEFAULT_UST_PID_CHANNEL_BLOCKING_TIMEOUT; extended_attr->monitor_timer_interval = DEFAULT_UST_PID_CHANNEL_MONITOR_TIMER; break; } break; default: goto error; /* Not implemented */ } if (snprintf(chan->name, sizeof(chan->name), "%s", channel_name) < 0) { PERROR("snprintf default channel name"); goto error; } return chan; error: free(extended_attr); free(chan); error_alloc: return NULL; }