Use compiler-agnostic defines to silence warning

[lttng-tools.git] / src / bin / lttng / commands / enable_events.cpp

diff --git a/src/bin/lttng/commands/enable_events.cpp b/src/bin/lttng/commands/enable_events.cpp
index 095a3df38cde77e589379e903c0687dc85ab44d1..1f1c8b4593ddb8a324e70c0045d7a1b65e932301 100644 (file)
--- a/src/bin/lttng/commands/enable_events.cpp
+++ b/src/bin/lttng/commands/enable_events.cpp
@@ -61,6 +61,7 @@ char *opt_session_name;
 int opt_userspace;
 int opt_jul;
 int opt_log4j;
 int opt_userspace;
 int opt_jul;
 int opt_log4j;

+int opt_log4j2;

 int opt_python;
 int opt_enable_all;
 char *opt_probe;
 int opt_python;
 int opt_enable_all;
 char *opt_probe;


@@ -104,6 +105,7 @@ struct poptOption long_options[] = {
        { "userspace", 'u', POPT_ARG_NONE, nullptr, OPT_USERSPACE, nullptr, nullptr },
        { "jul", 'j', POPT_ARG_VAL, &opt_jul, 1, nullptr, nullptr },
        { "log4j", 'l', POPT_ARG_VAL, &opt_log4j, 1, nullptr, nullptr },
        { "userspace", 'u', POPT_ARG_NONE, nullptr, OPT_USERSPACE, nullptr, nullptr },
        { "jul", 'j', POPT_ARG_VAL, &opt_jul, 1, nullptr, nullptr },
        { "log4j", 'l', POPT_ARG_VAL, &opt_log4j, 1, nullptr, nullptr },

+       { "log4j2", 0, POPT_ARG_VAL, &opt_log4j2, 1, nullptr, nullptr },

        { "python", 'p', POPT_ARG_VAL, &opt_python, 1, nullptr, nullptr },
        { "tracepoint", 0, POPT_ARG_NONE, nullptr, OPT_TRACEPOINT, nullptr, nullptr },
        { "probe", 0, POPT_ARG_STRING, &opt_probe, OPT_PROBE, nullptr, nullptr },
        { "python", 'p', POPT_ARG_VAL, &opt_python, 1, nullptr, nullptr },
        { "tracepoint", 0, POPT_ARG_NONE, nullptr, OPT_TRACEPOINT, nullptr, nullptr },
        { "probe", 0, POPT_ARG_STRING, &opt_probe, OPT_PROBE, nullptr, nullptr },


@@ -444,6 +446,10 @@ int enable_events(const std::string& session_name, const event_rule_patterns& pa
                dom.type = LTTNG_DOMAIN_LOG4J;
                /* Default. */
                dom.buf_type = LTTNG_BUFFER_PER_UID;
                dom.type = LTTNG_DOMAIN_LOG4J;
                /* Default. */
                dom.buf_type = LTTNG_BUFFER_PER_UID;

+       } else if (opt_log4j2) {
+               dom.type = LTTNG_DOMAIN_LOG4J2;
+               /* Default. */
+               dom.buf_type = LTTNG_BUFFER_PER_UID;

        } else if (opt_python) {
                dom.type = LTTNG_DOMAIN_PYTHON;
                /* Default. */
        } else if (opt_python) {
                dom.type = LTTNG_DOMAIN_PYTHON;
                /* Default. */


@@ -458,6 +464,7 @@ int enable_events(const std::string& session_name, const event_rule_patterns& pa
                case LTTNG_DOMAIN_KERNEL:
                case LTTNG_DOMAIN_JUL:
                case LTTNG_DOMAIN_LOG4J:
                case LTTNG_DOMAIN_KERNEL:
                case LTTNG_DOMAIN_JUL:
                case LTTNG_DOMAIN_LOG4J:

+               case LTTNG_DOMAIN_LOG4J2:

                case LTTNG_DOMAIN_PYTHON:
                        ERR("Event name exclusions are not supported for %s event rules",
                            lttng_domain_type_str(dom.type));
                case LTTNG_DOMAIN_PYTHON:
                        ERR("Event name exclusions are not supported for %s event rules",
                            lttng_domain_type_str(dom.type));


@@ -653,7 +660,7 @@ int enable_events(const std::string& session_name, const event_rule_patterns& pa
                        } else {
                                ev->loglevel = -1;
                        }
                        } else {
                                ev->loglevel = -1;
                        }

-               } else if (opt_jul || opt_log4j || opt_python) {
+               } else if (opt_jul || opt_log4j || opt_log4j2 || opt_python) {

                        if (opt_event_type != LTTNG_EVENT_ALL &&
                            opt_event_type != LTTNG_EVENT_TRACEPOINT) {
                                ERR("Instrumentation point type not supported for the %s domain",
                        if (opt_event_type != LTTNG_EVENT_ALL &&
                            opt_event_type != LTTNG_EVENT_TRACEPOINT) {
                                ERR("Instrumentation point type not supported for the %s domain",


@@ -678,6 +685,12 @@ int enable_events(const std::string& session_name, const event_rule_patterns& pa
                                        name_search_ret = loglevel_log4j_name_to_value(opt_loglevel,
                                                                                       &loglevel);
                                        ev->loglevel = (int) loglevel;
                                        name_search_ret = loglevel_log4j_name_to_value(opt_loglevel,
                                                                                       &loglevel);
                                        ev->loglevel = (int) loglevel;

+                               } else if (opt_log4j2) {
+                                       enum lttng_loglevel_log4j2 loglevel;
+
+                                       name_search_ret = loglevel_log4j2_name_to_value(
+                                               opt_loglevel, &loglevel);
+                                       ev->loglevel = (int) loglevel;

                                } else {
                                        /* python domain. */
                                        enum lttng_loglevel_python loglevel;
                                } else {
                                        /* python domain. */
                                        enum lttng_loglevel_python loglevel;


@@ -697,6 +710,8 @@ int enable_events(const std::string& session_name, const event_rule_patterns& pa
                                        ev->loglevel = LTTNG_LOGLEVEL_JUL_ALL;
                                } else if (opt_log4j) {
                                        ev->loglevel = LTTNG_LOGLEVEL_LOG4J_ALL;
                                        ev->loglevel = LTTNG_LOGLEVEL_JUL_ALL;
                                } else if (opt_log4j) {
                                        ev->loglevel = LTTNG_LOGLEVEL_LOG4J_ALL;

+                               } else if (opt_log4j2) {
+                                       ev->loglevel = LTTNG_LOGLEVEL_LOG4J2_ALL;

                                } else if (opt_python) {
                                        ev->loglevel = LTTNG_LOGLEVEL_PYTHON_DEBUG;
                                }
                                } else if (opt_python) {
                                        ev->loglevel = LTTNG_LOGLEVEL_PYTHON_DEBUG;
                                }


@@ -709,8 +724,6 @@ int enable_events(const std::string& session_name, const event_rule_patterns& pa
                }
 
                if (!opt_filter) {
                }
 
                if (!opt_filter) {

-                       char *exclusion_string;
-

                        command_ret = lttng_enable_event_with_exclusions(
                                handle,
                                ev,
                        command_ret = lttng_enable_event_with_exclusions(
                                handle,
                                ev,


@@ -718,7 +731,10 @@ int enable_events(const std::string& session_name, const event_rule_patterns& pa
                                nullptr,
                                lttng_dynamic_pointer_array_get_count(&exclusions),
                                (char **) exclusions.array.buffer.data);
                                nullptr,
                                lttng_dynamic_pointer_array_get_count(&exclusions),
                                (char **) exclusions.array.buffer.data);

-                       exclusion_string = print_exclusions(&exclusions);
+
+                       auto exclusion_string =
+                               lttng::make_unique_wrapper<char, lttng::memory::free>(
+                                       print_exclusions(&exclusions));

                        if (!exclusion_string) {
                                PERROR("Cannot allocate exclusion_string");
                                error = 1;
                        if (!exclusion_string) {
                                PERROR("Cannot allocate exclusion_string");
                                error = 1;


@@ -734,7 +750,7 @@ int enable_events(const std::string& session_name, const event_rule_patterns& pa
                                                              (std::string("with pattern `") +
                                                               pattern + std::string("`"))
                                                                      .c_str(),
                                                              (std::string("with pattern `") +
                                                               pattern + std::string("`"))
                                                                      .c_str(),

-                                            exclusion_string,
+                                            exclusion_string.get(),

                                             print_channel_name(channel_name),
                                             session_name.c_str());
                                        warn = 1;
                                             print_channel_name(channel_name),
                                             session_name.c_str());
                                        warn = 1;


@@ -759,12 +775,17 @@ int enable_events(const std::string& session_name, const event_rule_patterns& pa
                                                             (std::string("with pattern `") +
                                                              pattern + std::string("`"))
                                                                     .c_str(),
                                                             (std::string("with pattern `") +
                                                              pattern + std::string("`"))
                                                                     .c_str(),

-                                           exclusion_string,
+                                           exclusion_string.get(),

                                            command_ret == -LTTNG_ERR_NEED_CHANNEL_NAME ?
                                                    print_raw_channel_name(channel_name) :
                                                    print_channel_name(channel_name),
                                            lttng_strerror(command_ret),
                                            session_name.c_str());
                                            command_ret == -LTTNG_ERR_NEED_CHANNEL_NAME ?
                                                    print_raw_channel_name(channel_name) :
                                                    print_channel_name(channel_name),
                                            lttng_strerror(command_ret),
                                            session_name.c_str());

+
+                                       if (opt_kernel) {
+                                               print_kernel_tracer_status_error();
+                                       }
+

                                        error = 1;
                                        break;
                                }
                                        error = 1;
                                        break;
                                }


@@ -780,12 +801,13 @@ int enable_events(const std::string& session_name, const event_rule_patterns& pa
                                                             (std::string("with pattern `") +
                                                              pattern + std::string("`"))
                                                                     .c_str(),
                                                             (std::string("with pattern `") +
                                                              pattern + std::string("`"))
                                                                     .c_str(),

-                                           exclusion_string,
+                                           exclusion_string.get(),

                                            print_channel_name(channel_name));
                                        break;
                                }
                                case LTTNG_DOMAIN_JUL:
                                case LTTNG_DOMAIN_LOG4J:
                                            print_channel_name(channel_name));
                                        break;
                                }
                                case LTTNG_DOMAIN_JUL:
                                case LTTNG_DOMAIN_LOG4J:

+                               case LTTNG_DOMAIN_LOG4J2:

                                case LTTNG_DOMAIN_PYTHON:
                                        /*
                                         * Don't print the default channel
                                case LTTNG_DOMAIN_PYTHON:
                                        /*
                                         * Don't print the default channel


@@ -797,17 +819,13 @@ int enable_events(const std::string& session_name, const event_rule_patterns& pa
                                                             (std::string("with pattern `") +
                                                              pattern + std::string("`"))
                                                                     .c_str(),
                                                             (std::string("with pattern `") +
                                                              pattern + std::string("`"))
                                                                     .c_str(),

-                                           exclusion_string);
+                                           exclusion_string.get());

                                        break;
                                default:
                                        abort();
                                }
                        }
                                        break;
                                default:
                                        abort();
                                }
                        }

-
-                       free(exclusion_string);

                } else {
                } else {

-                       char *exclusion_string;
-

                        /* Filter present */
                        ev->filter = 1;
 
                        /* Filter present */
                        ev->filter = 1;
 


@@ -818,7 +836,10 @@ int enable_events(const std::string& session_name, const event_rule_patterns& pa
                                opt_filter,
                                lttng_dynamic_pointer_array_get_count(&exclusions),
                                (char **) exclusions.array.buffer.data);
                                opt_filter,
                                lttng_dynamic_pointer_array_get_count(&exclusions),
                                (char **) exclusions.array.buffer.data);

-                       exclusion_string = print_exclusions(&exclusions);
+
+                       auto exclusion_string =
+                               lttng::make_unique_wrapper<char, lttng::memory::free>(
+                                       print_exclusions(&exclusions));

                        if (!exclusion_string) {
                                PERROR("Failed allocate exclusion string");
                                error = 1;
                        if (!exclusion_string) {
                                PERROR("Failed allocate exclusion string");
                                error = 1;


@@ -832,7 +853,7 @@ int enable_events(const std::string& session_name, const event_rule_patterns& pa
                                                              (std::string("with pattern `") +
                                                               pattern + std::string("`"))
                                                                      .c_str(),
                                                              (std::string("with pattern `") +
                                                               pattern + std::string("`"))
                                                                      .c_str(),

-                                            exclusion_string,
+                                            exclusion_string.get(),

                                             opt_filter,
                                             print_channel_name(channel_name));
                                        warn = 1;
                                             opt_filter,
                                             print_channel_name(channel_name));
                                        warn = 1;


@@ -850,7 +871,7 @@ int enable_events(const std::string& session_name, const event_rule_patterns& pa
                                                             (std::string("with pattern `") +
                                                              pattern + std::string("`"))
                                                                     .c_str(),
                                                             (std::string("with pattern `") +
                                                              pattern + std::string("`"))
                                                                     .c_str(),

-                                           exclusion_string,
+                                           exclusion_string.get(),

                                            opt_filter,
                                            command_ret == -LTTNG_ERR_NEED_CHANNEL_NAME ?
                                                    print_raw_channel_name(channel_name) :
                                            opt_filter,
                                            command_ret == -LTTNG_ERR_NEED_CHANNEL_NAME ?
                                                    print_raw_channel_name(channel_name) :


@@ -858,6 +879,11 @@ int enable_events(const std::string& session_name, const event_rule_patterns& pa
                                            lttng_strerror(command_ret),
                                            session_name.c_str());
                                        error = 1;
                                            lttng_strerror(command_ret),
                                            session_name.c_str());
                                        error = 1;

+
+                                       if (opt_kernel) {
+                                               print_kernel_tracer_status_error();
+                                       }
+

                                        break;
                                }
 
                                        break;
                                }
 


@@ -870,11 +896,9 @@ int enable_events(const std::string& session_name, const event_rule_patterns& pa
                                                      std::string("`"))
                                                             .c_str(),
 
                                                      std::string("`"))
                                                             .c_str(),
 

-                                   exclusion_string,
+                                   exclusion_string.get(),

                                    opt_filter);
                        }
                                    opt_filter);
                        }

-
-                       free(exclusion_string);

                }
 
                if (lttng_opt_mi) {
                }
 
                if (lttng_opt_mi) {


@@ -1074,7 +1098,7 @@ int cmd_enable_events(int argc, const char **argv)
        }
 
        ret = print_missing_or_multiple_domains(
        }
 
        ret = print_missing_or_multiple_domains(

-               opt_kernel + opt_userspace + opt_jul + opt_log4j + opt_python, true);
+               opt_kernel + opt_userspace + opt_jul + opt_log4j + opt_log4j2 + opt_python, true);

        if (ret) {
                return CMD_ERROR;
        }
        if (ret) {
                return CMD_ERROR;
        }


@@ -1156,7 +1180,7 @@ int cmd_enable_events(int argc, const char **argv)
 
        if (!opt_session_name) {
                const auto rc_file_session_name =
 
        if (!opt_session_name) {
                const auto rc_file_session_name =

-                       lttng::make_unique_wrapper<char, lttng::free>(get_session_name());
+                       lttng::make_unique_wrapper<char, lttng::memory::free>(get_session_name());

 
                if (!rc_file_session_name) {
                        return CMD_ERROR;
 
                if (!rc_file_session_name) {
                        return CMD_ERROR;