lists.openwall.net   lists  /  announce  owl-users  owl-dev  john-users  john-dev  passwdqc-users  yescrypt  popa3d-users  /  oss-security  kernel-hardening  musl  sabotage  tlsify  passwords  /  crypt-dev  xvendor  /  Bugtraq  Full-Disclosure  linux-kernel  linux-netdev  linux-ext4  linux-hardening  linux-cve-announce  PHC 
Open Source and information security mailing list archives
 
Hash Suite: Windows password security audit tool. GUI, reports in PDF.
[<prev] [next>] [<thread-prev] [day] [month] [year] [list]
Message-ID: <20140306183014.456591b1@gandalf.local.home>
Date:	Thu, 6 Mar 2014 18:30:14 -0500
From:	Steven Rostedt <rostedt@...dmis.org>
To:	Bharath Ravi <rbharath@...gle.com>
Cc:	Vaibhav Nagarnaik <vnagarnaik@...gle.com>,
	David Sharp <dhsharp@...gle.com>, linux-kernel@...r.kernel.org
Subject: Re: [PATCH] tracing: Allow instances to have independent trace
 flags/trace options.

On Fri, 14 Feb 2014 15:30:54 -0800
Bharath Ravi <rbharath@...gle.com> wrote:

> Hi Steven,
> 
> What are your thoughts on this patch?

Ouch, I didn't mean to ignore you for so long. You should have pinged
again. Yeah, I know you pinged twice, but I was hacking away at other
things and even marked this email as "Important". The problem is, I
also marked a lot of other emails as "Important" too, and I'm just now
getting to this one :-(

This patch needs to be broken up into three. And probably needs to
rebase on my ftrace/core branch (note, that branch may rebase. You can
rebase on for-next*, which will not rebase, but also wont have all the
cool stuff I'm currently working on ;-)

First patch: Adds global_trace_flags() function and just substitutes
the trace_flags to global_trace_flags(). Nothing more.

Second patch: Adds the infrastructure to have a global_trace_flags()
and a instance trace_flags(). Just the infrastructure. Do not add any
instance flags.

Third patch: Moves overwrite to the instance trace flags.

Thanks!

-- Steve

* my for-next will rebase, but only when everything is in mainline.
  That is, I might merge stuff from multiple branches into my for-next
  branch, but after everything is in mainline. I just rebase to the
  next mainline release. Only the merge commit will disappear.


> --
> Bharath Ravi |  rbharath@...gle.com
> 
> 
> On Thu, Jan 23, 2014 at 11:46 AM, Bharath Ravi <rbharath@...gle.com> wrote:
> > Hi Steven,
> >
> > This patch allows instances to have their own independent trace
> > options (as opposed to the current globally shared trace options)
> >
> > Does this look like a reasonable change?
> > Bharath Ravi |  rbharath@...gle.com
> >
> >
> > On Fri, Nov 22, 2013 at 10:51 AM, Bharath Ravi <rbharath@...gle.com> wrote:
> >> Currently, the trace options are global, and shared among all
> >> instances. This change divides the set of trace options into global
> >> options and instance specific options. Instance specific options may be
> >> set independently by an instance without affecting either the global
> >> tracer or other instances. Global options are viewable and modifiable
> >> only from the global tracer, preventing tracers from modifying shared
> >> flags.
> >>
> >> Currently, only the "overwrite" flag is a per-instance flag. Others may
> >> be supported as and when instances are modified to support more tracers.
> >>
> >> As a side-effect, the global trace_flags variable is replaced by
> >> instance specific trace_flags in trace_array. References to the old
> >> global flags variable are replaced with accessors to the global_tracer's
> >> trace_flags.
> >>
> >> Signed-off-by: Bharath Ravi <rbharath@...gle.com>
> >> ---
> >>  kernel/trace/blktrace.c              |   5 +-
> >>  kernel/trace/ftrace.c                |   4 +-
> >>  kernel/trace/trace.c                 | 131 +++++++++++++++++++++++++----------
> >>  kernel/trace/trace.h                 |  51 +++++++-------
> >>  kernel/trace/trace_events.c          |   2 +-
> >>  kernel/trace/trace_functions_graph.c |  10 +--
> >>  kernel/trace/trace_irqsoff.c         |   3 +-
> >>  kernel/trace/trace_kdb.c             |   6 +-
> >>  kernel/trace/trace_output.c          |   8 +--
> >>  kernel/trace/trace_printk.c          |   8 +--
> >>  kernel/trace/trace_sched_wakeup.c    |   3 +-
> >>  kernel/trace/trace_syscalls.c        |   2 +-
> >>  12 files changed, 149 insertions(+), 84 deletions(-)
> >>
> >> diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
> >> index b8b8560..0d71009 100644
> >> --- a/kernel/trace/blktrace.c
> >> +++ b/kernel/trace/blktrace.c
> >> @@ -1350,7 +1350,7 @@ static enum print_line_t print_one_line(struct trace_iterator *iter,
> >>
> >>         t          = te_blk_io_trace(iter->ent);
> >>         what       = t->action & ((1 << BLK_TC_SHIFT) - 1);
> >> -       long_act   = !!(trace_flags & TRACE_ITER_VERBOSE);
> >> +       long_act   = !!(global_trace_flags() & TRACE_ITER_VERBOSE);
> >>         log_action = classic ? &blk_log_action_classic : &blk_log_action;
> >>
> >>         if (t->action == BLK_TN_MESSAGE) {
> >> @@ -1411,12 +1411,15 @@ static enum print_line_t blk_tracer_print_line(struct trace_iterator *iter)
> >>
> >>  static int blk_tracer_set_flag(u32 old_flags, u32 bit, int set)
> >>  {
> >> +       unsigned long trace_flags = global_trace_flags();
> >>         /* don't output context-info for blk_classic output */
> >>         if (bit == TRACE_BLK_OPT_CLASSIC) {
> >>                 if (set)
> >>                         trace_flags &= ~TRACE_ITER_CONTEXT_INFO;
> >>                 else
> >>                         trace_flags |= TRACE_ITER_CONTEXT_INFO;
> >> +
> >> +               set_global_trace_flags(trace_flags);
> >>         }
> >>         return 0;
> >>  }
> >> diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
> >> index 03cf44a..c356d5d 100644
> >> --- a/kernel/trace/ftrace.c
> >> +++ b/kernel/trace/ftrace.c
> >> @@ -911,7 +911,7 @@ static void profile_graph_return(struct ftrace_graph_ret *trace)
> >>
> >>         calltime = trace->rettime - trace->calltime;
> >>
> >> -       if (!(trace_flags & TRACE_ITER_GRAPH_TIME)) {
> >> +       if (!(global_trace_flags() & TRACE_ITER_GRAPH_TIME)) {
> >>                 int index;
> >>
> >>                 index = trace->depth;
> >> @@ -4836,7 +4836,7 @@ ftrace_graph_probe_sched_switch(void *ignore,
> >>          * Does the user want to count the time a function was asleep.
> >>          * If so, do not update the time stamps.
> >>          */
> >> -       if (trace_flags & TRACE_ITER_SLEEP_TIME)
> >> +       if (global_trace_flags() & TRACE_ITER_SLEEP_TIME)
> >>                 return;
> >>
> >>         timestamp = trace_clock_local();
> >> diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
> >> index 7974ba2..7add8bc 100644
> >> --- a/kernel/trace/trace.c
> >> +++ b/kernel/trace/trace.c
> >> @@ -386,11 +386,16 @@ static inline void trace_access_lock_init(void)
> >>
> >>  #endif
> >>
> >> -/* trace_flags holds trace_options default values */
> >> -unsigned long trace_flags = TRACE_ITER_PRINT_PARENT | TRACE_ITER_PRINTK |
> >> -       TRACE_ITER_ANNOTATE | TRACE_ITER_CONTEXT_INFO | TRACE_ITER_SLEEP_TIME |
> >> -       TRACE_ITER_GRAPH_TIME | TRACE_ITER_RECORD_CMD | TRACE_ITER_OVERWRITE |
> >> -       TRACE_ITER_IRQ_INFO | TRACE_ITER_MARKERS | TRACE_ITER_FUNCTION;
> >> +/* Sets default values for a tracer's trace_options */
> >> +static inline void init_trace_flags(unsigned long *trace_flags)
> >> +{
> >> +       *trace_flags = TRACE_ITER_PRINT_PARENT | TRACE_ITER_PRINTK |
> >> +               TRACE_ITER_ANNOTATE | TRACE_ITER_CONTEXT_INFO |
> >> +               TRACE_ITER_SLEEP_TIME | TRACE_ITER_GRAPH_TIME |
> >> +               TRACE_ITER_RECORD_CMD | TRACE_ITER_IRQ_INFO |
> >> +               TRACE_ITER_MARKERS | TRACE_ITER_FUNCTION |
> >> +               TRACE_ITER_OVERWRITE;
> >> +}
> >>
> >>  static void tracer_tracing_on(struct trace_array *tr)
> >>  {
> >> @@ -705,8 +710,9 @@ unsigned long nsecs_to_usecs(unsigned long nsecs)
> >>         return nsecs / 1000;
> >>  }
> >>
> >> -/* These must match the bit postions in trace_iterator_flags */
> >> -static const char *trace_options[] = {
> >> +/* These must match the bit positions in trace_iterator_flags */
> >> +static const char * const trace_options[] = {
> >> +       "overwrite",
> >>         "print-parent",
> >>         "sym-offset",
> >>         "sym-addr",
> >> @@ -728,7 +734,6 @@ static const char *trace_options[] = {
> >>         "sleep-time",
> >>         "graph-time",
> >>         "record-cmd",
> >> -       "overwrite",
> >>         "disable_on_free",
> >>         "irq-info",
> >>         "markers",
> >> @@ -736,6 +741,13 @@ static const char *trace_options[] = {
> >>         NULL
> >>  };
> >>
> >> +/*
> >> + * The index of the first global flag in trace_options. Indices higher than or
> >> + * equal to this are global flags, while indices smaller than this are
> >> + * per-instance flags.
> >> + */
> >> +static const int global_flags_start = 1;
> >> +
> >>  static struct {
> >>         u64 (*func)(void);
> >>         const char *name;
> >> @@ -1260,6 +1272,17 @@ int is_tracing_stopped(void)
> >>         return global_trace.stop_count;
> >>  }
> >>
> >> +unsigned long global_trace_flags(void)
> >> +{
> >> +       return global_trace.trace_flags;
> >> +}
> >> +
> >> +void set_global_trace_flags(unsigned long flags)
> >> +{
> >> +       global_trace.trace_flags = flags;
> >> +}
> >> +
> >> +
> >>  /**
> >>   * ftrace_off_permanent - disable all ftrace code permanently
> >>   *
> >> @@ -1728,7 +1751,7 @@ static void __ftrace_trace_stack(struct ring_buffer *buffer,
> >>  void ftrace_trace_stack_regs(struct ring_buffer *buffer, unsigned long flags,
> >>                              int skip, int pc, struct pt_regs *regs)
> >>  {
> >> -       if (!(trace_flags & TRACE_ITER_STACKTRACE))
> >> +       if (!(global_trace_flags() & TRACE_ITER_STACKTRACE))
> >>                 return;
> >>
> >>         __ftrace_trace_stack(buffer, flags, skip, pc, regs);
> >> @@ -1737,7 +1760,7 @@ void ftrace_trace_stack_regs(struct ring_buffer *buffer, unsigned long flags,
> >>  void ftrace_trace_stack(struct ring_buffer *buffer, unsigned long flags,
> >>                         int skip, int pc)
> >>  {
> >> -       if (!(trace_flags & TRACE_ITER_STACKTRACE))
> >> +       if (!(global_trace_flags() & TRACE_ITER_STACKTRACE))
> >>                 return;
> >>
> >>         __ftrace_trace_stack(buffer, flags, skip, pc, NULL);
> >> @@ -1781,7 +1804,7 @@ ftrace_trace_userstack(struct ring_buffer *buffer, unsigned long flags, int pc)
> >>         struct userstack_entry *entry;
> >>         struct stack_trace trace;
> >>
> >> -       if (!(trace_flags & TRACE_ITER_USERSTACKTRACE))
> >> +       if (!(global_trace_flags() & TRACE_ITER_USERSTACKTRACE))
> >>                 return;
> >>
> >>         /*
> >> @@ -2086,7 +2109,7 @@ int trace_array_printk(struct trace_array *tr,
> >>         int ret;
> >>         va_list ap;
> >>
> >> -       if (!(trace_flags & TRACE_ITER_PRINTK))
> >> +       if (!(global_trace_flags() & TRACE_ITER_PRINTK))
> >>                 return 0;
> >>
> >>         va_start(ap, fmt);
> >> @@ -2101,7 +2124,7 @@ int trace_array_printk_buf(struct ring_buffer *buffer,
> >>         int ret;
> >>         va_list ap;
> >>
> >> -       if (!(trace_flags & TRACE_ITER_PRINTK))
> >> +       if (!(global_trace_flags() & TRACE_ITER_PRINTK))
> >>                 return 0;
> >>
> >>         va_start(ap, fmt);
> >> @@ -2442,7 +2465,7 @@ static void print_func_help_header_irq(struct trace_buffer *buf, struct seq_file
> >>  void
> >>  print_trace_header(struct seq_file *m, struct trace_iterator *iter)
> >>  {
> >> -       unsigned long sym_flags = (trace_flags & TRACE_ITER_SYM_MASK);
> >> +       unsigned long sym_flags = (global_trace_flags() & TRACE_ITER_SYM_MASK);
> >>         struct trace_buffer *buf = iter->trace_buffer;
> >>         struct trace_array_cpu *data = per_cpu_ptr(buf->data, buf->cpu);
> >>         struct tracer *type = iter->trace;
> >> @@ -2505,7 +2528,7 @@ static void test_cpu_buff_start(struct trace_iterator *iter)
> >>  {
> >>         struct trace_seq *s = &iter->seq;
> >>
> >> -       if (!(trace_flags & TRACE_ITER_ANNOTATE))
> >> +       if (!(global_trace_flags() & TRACE_ITER_ANNOTATE))
> >>                 return;
> >>
> >>         if (!(iter->iter_flags & TRACE_FILE_ANNOTATE))
> >> @@ -2528,7 +2551,7 @@ static void test_cpu_buff_start(struct trace_iterator *iter)
> >>  static enum print_line_t print_trace_fmt(struct trace_iterator *iter)
> >>  {
> >>         struct trace_seq *s = &iter->seq;
> >> -       unsigned long sym_flags = (trace_flags & TRACE_ITER_SYM_MASK);
> >> +       unsigned long sym_flags = (global_trace_flags() & TRACE_ITER_SYM_MASK);
> >>         struct trace_entry *entry;
> >>         struct trace_event *event;
> >>
> >> @@ -2538,7 +2561,7 @@ static enum print_line_t print_trace_fmt(struct trace_iterator *iter)
> >>
> >>         event = ftrace_find_event(entry->type);
> >>
> >> -       if (trace_flags & TRACE_ITER_CONTEXT_INFO) {
> >> +       if (global_trace_flags() & TRACE_ITER_CONTEXT_INFO) {
> >>                 if (iter->iter_flags & TRACE_FILE_LAT_FMT) {
> >>                         if (!trace_print_lat_context(iter))
> >>                                 goto partial;
> >> @@ -2567,7 +2590,7 @@ static enum print_line_t print_raw_fmt(struct trace_iterator *iter)
> >>
> >>         entry = iter->ent;
> >>
> >> -       if (trace_flags & TRACE_ITER_CONTEXT_INFO) {
> >> +       if (global_trace_flags() & TRACE_ITER_CONTEXT_INFO) {
> >>                 if (!trace_seq_printf(s, "%d %d %llu ",
> >>                                       entry->pid, iter->cpu, iter->ts))
> >>                         goto partial;
> >> @@ -2594,7 +2617,7 @@ static enum print_line_t print_hex_fmt(struct trace_iterator *iter)
> >>
> >>         entry = iter->ent;
> >>
> >> -       if (trace_flags & TRACE_ITER_CONTEXT_INFO) {
> >> +       if (global_trace_flags() & TRACE_ITER_CONTEXT_INFO) {
> >>                 SEQ_PUT_HEX_FIELD_RET(s, entry->pid);
> >>                 SEQ_PUT_HEX_FIELD_RET(s, iter->cpu);
> >>                 SEQ_PUT_HEX_FIELD_RET(s, iter->ts);
> >> @@ -2620,7 +2643,7 @@ static enum print_line_t print_bin_fmt(struct trace_iterator *iter)
> >>
> >>         entry = iter->ent;
> >>
> >> -       if (trace_flags & TRACE_ITER_CONTEXT_INFO) {
> >> +       if (global_trace_flags() & TRACE_ITER_CONTEXT_INFO) {
> >>                 SEQ_PUT_FIELD_RET(s, entry->pid);
> >>                 SEQ_PUT_FIELD_RET(s, iter->cpu);
> >>                 SEQ_PUT_FIELD_RET(s, iter->ts);
> >> @@ -2667,6 +2690,7 @@ int trace_empty(struct trace_iterator *iter)
> >>  /*  Called with trace_event_read_lock() held. */
> >>  enum print_line_t print_trace_line(struct trace_iterator *iter)
> >>  {
> >> +       unsigned long trace_flags = global_trace_flags();
> >>         enum print_line_t ret;
> >>
> >>         if (iter->lost_events &&
> >> @@ -2718,12 +2742,13 @@ void trace_latency_header(struct seq_file *m)
> >>         if (iter->iter_flags & TRACE_FILE_LAT_FMT)
> >>                 print_trace_header(m, iter);
> >>
> >> -       if (!(trace_flags & TRACE_ITER_VERBOSE))
> >> +       if (!(global_trace_flags() & TRACE_ITER_VERBOSE))
> >>                 print_lat_help_header(m);
> >>  }
> >>
> >>  void trace_default_header(struct seq_file *m)
> >>  {
> >> +       unsigned long trace_flags = global_trace_flags();
> >>         struct trace_iterator *iter = m->private;
> >>
> >>         if (!(trace_flags & TRACE_ITER_CONTEXT_INFO))
> >> @@ -3064,7 +3089,7 @@ static int tracing_open(struct inode *inode, struct file *file)
> >>                 iter = __tracing_open(inode, file, false);
> >>                 if (IS_ERR(iter))
> >>                         ret = PTR_ERR(iter);
> >> -               else if (trace_flags & TRACE_ITER_LATENCY_FMT)
> >> +               else if (global_trace_flags() & TRACE_ITER_LATENCY_FMT)
> >>                         iter->iter_flags |= TRACE_FILE_LAT_FMT;
> >>         }
> >>
> >> @@ -3270,13 +3295,23 @@ static int tracing_trace_options_show(struct seq_file *m, void *v)
> >>         tracer_flags = tr->current_trace->flags->val;
> >>         trace_opts = tr->current_trace->flags->opts;
> >>
> >> -       for (i = 0; trace_options[i]; i++) {
> >> -               if (trace_flags & (1 << i))
> >> +       for (i = 0; i < global_flags_start; i++) {
> >> +               if (tr->trace_flags & (1 << i))
> >>                         seq_printf(m, "%s\n", trace_options[i]);
> >>                 else
> >>                         seq_printf(m, "no%s\n", trace_options[i]);
> >>         }
> >>
> >> +       /* For the global trace, also display global options*/
> >> +       if (tr->flags & TRACE_ARRAY_FL_GLOBAL) {
> >> +               for (i = global_flags_start; trace_options[i]; i++) {
> >> +                       if (global_trace_flags() & (1 << i))
> >> +                               seq_printf(m, "%s\n", trace_options[i]);
> >> +                       else
> >> +                               seq_printf(m, "no%s\n", trace_options[i]);
> >> +               }
> >> +       }
> >> +
> >>         for (i = 0; trace_opts[i].name; i++) {
> >>                 if (tracer_flags & trace_opts[i].bit)
> >>                         seq_printf(m, "%s\n", trace_opts[i].name);
> >> @@ -3334,8 +3369,13 @@ int trace_keep_overwrite(struct tracer *tracer, u32 mask, int set)
> >>
> >>  int set_tracer_flag(struct trace_array *tr, unsigned int mask, int enabled)
> >>  {
> >> +       /* If this is a global flag, disallow instances from modifying it. */
> >> +       if (mask >= (1 << global_flags_start) &&
> >> +           !(tr->flags & TRACE_ARRAY_FL_GLOBAL))
> >> +               return -EINVAL;
> >> +
> >>         /* do nothing if flag is already set */
> >> -       if (!!(trace_flags & mask) == !!enabled)
> >> +       if (!!(tr->trace_flags & mask) == !!enabled)
> >>                 return 0;
> >>
> >>         /* Give the tracer a chance to approve the change */
> >> @@ -3344,9 +3384,9 @@ int set_tracer_flag(struct trace_array *tr, unsigned int mask, int enabled)
> >>                         return -EINVAL;
> >>
> >>         if (enabled)
> >> -               trace_flags |= mask;
> >> +               tr->trace_flags |= mask;
> >>         else
> >> -               trace_flags &= ~mask;
> >> +               tr->trace_flags &= ~mask;
> >>
> >>         if (mask == TRACE_ITER_RECORD_CMD)
> >>                 trace_event_enable_cmd_record(enabled);
> >> @@ -3370,6 +3410,7 @@ static int trace_set_options(struct trace_array *tr, char *option)
> >>         int neg = 0;
> >>         int ret = -ENODEV;
> >>         int i;
> >> +       bool option_found = false;
> >>
> >>         cmp = strstrip(option);
> >>
> >> @@ -3380,15 +3421,27 @@ static int trace_set_options(struct trace_array *tr, char *option)
> >>
> >>         mutex_lock(&trace_types_lock);
> >>
> >> -       for (i = 0; trace_options[i]; i++) {
> >> +       for (i = 0; i < global_flags_start; i++) {
> >>                 if (strcmp(cmp, trace_options[i]) == 0) {
> >>                         ret = set_tracer_flag(tr, 1 << i, !neg);
> >>                         break;
> >>                 }
> >>         }
> >> +       if (i < global_flags_start) {
> >> +               option_found = true;
> >> +       } else if (tr->flags & TRACE_ARRAY_FL_GLOBAL) {
> >> +               /* If this is the global trace, try the global options */
> >> +               for (i = global_flags_start; trace_options[i]; i++) {
> >> +                       if (strcmp(cmp, trace_options[i]) == 0) {
> >> +                               ret = set_tracer_flag(tr, 1 << i, !neg);
> >> +                               break;
> >> +                       }
> >> +               }
> >> +               option_found = trace_options[i];
> >> +       }
> >>
> >>         /* If no option could be set, test the specific tracer options */
> >> -       if (!trace_options[i])
> >> +       if (!option_found)
> >>                 ret = set_tracer_option(tr->current_trace, cmp, neg);
> >>
> >>         mutex_unlock(&trace_types_lock);
> >> @@ -3963,7 +4016,7 @@ static int tracing_open_pipe(struct inode *inode, struct file *filp)
> >>         /* trace pipe does not show start of buffer */
> >>         cpumask_setall(iter->started);
> >>
> >> -       if (trace_flags & TRACE_ITER_LATENCY_FMT)
> >> +       if (global_trace_flags() & TRACE_ITER_LATENCY_FMT)
> >>                 iter->iter_flags |= TRACE_FILE_LAT_FMT;
> >>
> >>         /* Output in nanoseconds only if we are using a clock in nanoseconds. */
> >> @@ -4021,7 +4074,7 @@ trace_poll(struct trace_iterator *iter, struct file *filp, poll_table *poll_tabl
> >>         if (trace_buffer_iter(iter, iter->cpu_file))
> >>                 return POLLIN | POLLRDNORM;
> >>
> >> -       if (trace_flags & TRACE_ITER_BLOCK)
> >> +       if (global_trace_flags() & TRACE_ITER_BLOCK)
> >>                 /*
> >>                  * Always select as readable when in blocking mode
> >>                  */
> >> @@ -4465,7 +4518,7 @@ tracing_free_buffer_release(struct inode *inode, struct file *filp)
> >>         struct trace_array *tr = inode->i_private;
> >>
> >>         /* disable tracing ? */
> >> -       if (trace_flags & TRACE_ITER_STOP_ON_FREE)
> >> +       if (global_trace_flags() & TRACE_ITER_STOP_ON_FREE)
> >>                 tracer_tracing_off(tr);
> >>         /* resize the ring buffer to 0 */
> >>         tracing_resize_ring_buffer(tr, 0, RING_BUFFER_ALL_CPUS);
> >> @@ -4498,7 +4551,7 @@ tracing_mark_write(struct file *filp, const char __user *ubuf,
> >>         if (tracing_disabled)
> >>                 return -EINVAL;
> >>
> >> -       if (!(trace_flags & TRACE_ITER_MARKERS))
> >> +       if (!(global_trace_flags() & TRACE_ITER_MARKERS))
> >>                 return -EINVAL;
> >>
> >>         if (cnt > TRACE_BUF_SIZE)
> >> @@ -5628,7 +5681,7 @@ trace_options_core_read(struct file *filp, char __user *ubuf, size_t cnt,
> >>         long index = (long)filp->private_data;
> >>         char *buf;
> >>
> >> -       if (trace_flags & (1 << index))
> >> +       if (global_trace_flags() & (1 << index))
> >>                 buf = "1\n";
> >>         else
> >>                 buf = "0\n";
> >> @@ -5867,7 +5920,7 @@ allocate_trace_buffer(struct trace_array *tr, struct trace_buffer *buf, int size
> >>  {
> >>         enum ring_buffer_flags rb_flags;
> >>
> >> -       rb_flags = trace_flags & TRACE_ITER_OVERWRITE ? RB_FL_OVERWRITE : 0;
> >> +       rb_flags = tr->trace_flags & TRACE_ITER_OVERWRITE ? RB_FL_OVERWRITE : 0;
> >>
> >>         buf->buffer = ring_buffer_alloc(size, rb_flags);
> >>         if (!buf->buffer)
> >> @@ -5941,6 +5994,7 @@ static int new_instance_create(const char *name)
> >>         cpumask_copy(tr->tracing_cpumask, cpu_all_mask);
> >>
> >>         raw_spin_lock_init(&tr->start_lock);
> >> +       init_trace_flags(&(tr->trace_flags));
> >>
> >>         tr->current_trace = &nop_trace;
> >>
> >> @@ -6289,10 +6343,10 @@ void ftrace_dump(enum ftrace_dump_mode oops_dump_mode)
> >>                 atomic_inc(&per_cpu_ptr(iter.tr->trace_buffer.data, cpu)->disabled);
> >>         }
> >>
> >> -       old_userobj = trace_flags & TRACE_ITER_SYM_USEROBJ;
> >> +       old_userobj = global_trace_flags() & TRACE_ITER_SYM_USEROBJ;
> >>
> >>         /* don't look at user memory in panic mode */
> >> -       trace_flags &= ~TRACE_ITER_SYM_USEROBJ;
> >> +       set_global_trace_flags(global_trace_flags() & ~TRACE_ITER_SYM_USEROBJ);
> >>
> >>         switch (oops_dump_mode) {
> >>         case DUMP_ALL:
> >> @@ -6355,7 +6409,7 @@ void ftrace_dump(enum ftrace_dump_mode oops_dump_mode)
> >>                 printk(KERN_TRACE "---------------------------------\n");
> >>
> >>   out_enable:
> >> -       trace_flags |= old_userobj;
> >> +       set_global_trace_flags(global_trace_flags() | old_userobj);
> >>
> >>         for_each_tracing_cpu(cpu) {
> >>                 atomic_dec(&per_cpu_ptr(iter.trace_buffer->data, cpu)->disabled);
> >> @@ -6392,6 +6446,7 @@ __init static int tracer_alloc_buffers(void)
> >>         cpumask_copy(global_trace.tracing_cpumask, cpu_all_mask);
> >>
> >>         raw_spin_lock_init(&global_trace.start_lock);
> >> +       init_trace_flags(&global_trace.trace_flags);
> >>
> >>         /* TODO: make the number of buffers hot pluggable with CPUS */
> >>         if (allocate_trace_buffers(&global_trace, ring_buf_size) < 0) {
> >> diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
> >> index 10c86fb..10e2984 100644
> >> --- a/kernel/trace/trace.h
> >> +++ b/kernel/trace/trace.h
> >> @@ -199,6 +199,7 @@ struct trace_array {
> >>         int                     clock_id;
> >>         struct tracer           *current_trace;
> >>         unsigned int            flags;
> >> +       unsigned long           trace_flags;
> >>         raw_spinlock_t          start_lock;
> >>         struct dentry           *dir;
> >>         struct dentry           *options;
> >> @@ -584,6 +585,8 @@ void tracing_stop_sched_switch_record(void);
> >>  void tracing_start_sched_switch_record(void);
> >>  int register_tracer(struct tracer *type);
> >>  int is_tracing_stopped(void);
> >> +unsigned long global_trace_flags(void);
> >> +void set_global_trace_flags(unsigned long flags);
> >>
> >>  extern cpumask_var_t __read_mostly tracing_buffer_mask;
> >>
> >> @@ -699,8 +702,6 @@ int trace_array_printk_buf(struct ring_buffer *buffer,
> >>  void trace_printk_seq(struct trace_seq *s);
> >>  enum print_line_t print_trace_line(struct trace_iterator *iter);
> >>
> >> -extern unsigned long trace_flags;
> >> -
> >>  /* Standard output formatting function used for function return traces */
> >>  #ifdef CONFIG_FUNCTION_GRAPH_TRACER
> >>
> >> @@ -837,28 +838,30 @@ extern int trace_get_user(struct trace_parser *parser, const char __user *ubuf,
> >>   *       trace.c.
> >>   */
> >>  enum trace_iterator_flags {
> >> -       TRACE_ITER_PRINT_PARENT         = 0x01,
> >> -       TRACE_ITER_SYM_OFFSET           = 0x02,
> >> -       TRACE_ITER_SYM_ADDR             = 0x04,
> >> -       TRACE_ITER_VERBOSE              = 0x08,
> >> -       TRACE_ITER_RAW                  = 0x10,
> >> -       TRACE_ITER_HEX                  = 0x20,
> >> -       TRACE_ITER_BIN                  = 0x40,
> >> -       TRACE_ITER_BLOCK                = 0x80,
> >> -       TRACE_ITER_STACKTRACE           = 0x100,
> >> -       TRACE_ITER_PRINTK               = 0x200,
> >> -       TRACE_ITER_PREEMPTONLY          = 0x400,
> >> -       TRACE_ITER_BRANCH               = 0x800,
> >> -       TRACE_ITER_ANNOTATE             = 0x1000,
> >> -       TRACE_ITER_USERSTACKTRACE       = 0x2000,
> >> -       TRACE_ITER_SYM_USEROBJ          = 0x4000,
> >> -       TRACE_ITER_PRINTK_MSGONLY       = 0x8000,
> >> -       TRACE_ITER_CONTEXT_INFO         = 0x10000, /* Print pid/cpu/time */
> >> -       TRACE_ITER_LATENCY_FMT          = 0x20000,
> >> -       TRACE_ITER_SLEEP_TIME           = 0x40000,
> >> -       TRACE_ITER_GRAPH_TIME           = 0x80000,
> >> -       TRACE_ITER_RECORD_CMD           = 0x100000,
> >> -       TRACE_ITER_OVERWRITE            = 0x200000,
> >> +       /* Instance specific flags */
> >> +       TRACE_ITER_OVERWRITE            = 0x01,
> >> +       /* Global flags */
> >> +       TRACE_ITER_PRINT_PARENT         = 0x02,
> >> +       TRACE_ITER_SYM_OFFSET           = 0x04,
> >> +       TRACE_ITER_SYM_ADDR             = 0x08,
> >> +       TRACE_ITER_VERBOSE              = 0x10,
> >> +       TRACE_ITER_RAW                  = 0x20,
> >> +       TRACE_ITER_HEX                  = 0x40,
> >> +       TRACE_ITER_BIN                  = 0x80,
> >> +       TRACE_ITER_BLOCK                = 0x100,
> >> +       TRACE_ITER_STACKTRACE           = 0x200,
> >> +       TRACE_ITER_PRINTK               = 0x400,
> >> +       TRACE_ITER_PREEMPTONLY          = 0x800,
> >> +       TRACE_ITER_BRANCH               = 0x1000,
> >> +       TRACE_ITER_ANNOTATE             = 0x2000,
> >> +       TRACE_ITER_USERSTACKTRACE       = 0x4000,
> >> +       TRACE_ITER_SYM_USEROBJ          = 0x8000,
> >> +       TRACE_ITER_PRINTK_MSGONLY       = 0x10000,
> >> +       TRACE_ITER_CONTEXT_INFO         = 0x20000, /* Print pid/cpu/time */
> >> +       TRACE_ITER_LATENCY_FMT          = 0x40000,
> >> +       TRACE_ITER_SLEEP_TIME           = 0x80000,
> >> +       TRACE_ITER_GRAPH_TIME           = 0x100000,
> >> +       TRACE_ITER_RECORD_CMD           = 0x200000,
> >>         TRACE_ITER_STOP_ON_FREE         = 0x400000,
> >>         TRACE_ITER_IRQ_INFO             = 0x800000,
> >>         TRACE_ITER_MARKERS              = 0x1000000,
> >> diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
> >> index 368a4d5..e04cc60 100644
> >> --- a/kernel/trace/trace_events.c
> >> +++ b/kernel/trace/trace_events.c
> >> @@ -320,7 +320,7 @@ static int __ftrace_event_enable_disable(struct ftrace_event_file *file,
> >>                         if (soft_disable)
> >>                                 set_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags);
> >>
> >> -                       if (trace_flags & TRACE_ITER_RECORD_CMD) {
> >> +                       if (global_trace_flags() & TRACE_ITER_RECORD_CMD) {
> >>                                 tracing_start_cmdline_record();
> >>                                 set_bit(FTRACE_EVENT_FL_RECORDED_CMD_BIT, &file->flags);
> >>                         }
> >> diff --git a/kernel/trace/trace_functions_graph.c b/kernel/trace/trace_functions_graph.c
> >> index b5c0924..d6cc96b 100644
> >> --- a/kernel/trace/trace_functions_graph.c
> >> +++ b/kernel/trace/trace_functions_graph.c
> >> @@ -625,7 +625,7 @@ print_graph_irq(struct trace_iterator *iter, unsigned long addr,
> >>                 addr >= (unsigned long)__irqentry_text_end)
> >>                 return TRACE_TYPE_UNHANDLED;
> >>
> >> -       if (trace_flags & TRACE_ITER_CONTEXT_INFO) {
> >> +       if (global_trace_flags() & TRACE_ITER_CONTEXT_INFO) {
> >>                 /* Absolute time */
> >>                 if (flags & TRACE_GRAPH_PRINT_ABS_TIME) {
> >>                         ret = print_graph_abs_time(iter->ts, s);
> >> @@ -725,7 +725,7 @@ print_graph_duration(unsigned long long duration, struct trace_seq *s,
> >>         int ret = -1;
> >>
> >>         if (!(flags & TRACE_GRAPH_PRINT_DURATION) ||
> >> -           !(trace_flags & TRACE_ITER_CONTEXT_INFO))
> >> +           !(global_trace_flags() & TRACE_ITER_CONTEXT_INFO))
> >>                         return TRACE_TYPE_HANDLED;
> >>
> >>         /* No real adata, just filling the column with spaces */
> >> @@ -882,6 +882,7 @@ print_graph_prologue(struct trace_iterator *iter, struct trace_seq *s,
> >>         struct trace_entry *ent = iter->ent;
> >>         int cpu = iter->cpu;
> >>         int ret;
> >> +       unsigned long trace_flags = global_trace_flags();
> >>
> >>         /* Pid */
> >>         if (verif_pid(s, ent->pid, cpu, data) == TRACE_TYPE_PARTIAL_LINE)
> >> @@ -1158,7 +1159,7 @@ static enum print_line_t
> >>  print_graph_comment(struct trace_seq *s, struct trace_entry *ent,
> >>                     struct trace_iterator *iter, u32 flags)
> >>  {
> >> -       unsigned long sym_flags = (trace_flags & TRACE_ITER_SYM_MASK);
> >> +       unsigned long sym_flags = (global_trace_flags() & TRACE_ITER_SYM_MASK);
> >>         struct fgraph_data *data = iter->private;
> >>         struct trace_event *event;
> >>         int depth = 0;
> >> @@ -1321,7 +1322,7 @@ static void print_lat_header(struct seq_file *s, u32 flags)
> >>
> >>  static void __print_graph_headers_flags(struct seq_file *s, u32 flags)
> >>  {
> >> -       int lat = trace_flags & TRACE_ITER_LATENCY_FMT;
> >> +       int lat = global_trace_flags() & TRACE_ITER_LATENCY_FMT;
> >>
> >>         if (lat)
> >>                 print_lat_header(s, flags);
> >> @@ -1362,6 +1363,7 @@ void print_graph_headers(struct seq_file *s)
> >>
> >>  void print_graph_headers_flags(struct seq_file *s, u32 flags)
> >>  {
> >> +       unsigned long trace_flags = global_trace_flags();
> >>         struct trace_iterator *iter = s->private;
> >>
> >>         if (!(trace_flags & TRACE_ITER_CONTEXT_INFO))
> >> diff --git a/kernel/trace/trace_irqsoff.c b/kernel/trace/trace_irqsoff.c
> >> index 2aefbee..bc90b07 100644
> >> --- a/kernel/trace/trace_irqsoff.c
> >> +++ b/kernel/trace/trace_irqsoff.c
> >> @@ -532,6 +532,7 @@ void trace_preempt_off(unsigned long a0, unsigned long a1)
> >>  static int register_irqsoff_function(int graph, int set)
> >>  {
> >>         int ret;
> >> +       unsigned long trace_flags = global_trace_flags();
> >>
> >>         /* 'set' is set if TRACE_ITER_FUNCTION is about to be set */
> >>         if (function_enabled || (!set && !(trace_flags & TRACE_ITER_FUNCTION)))
> >> @@ -601,7 +602,7 @@ static void stop_irqsoff_tracer(struct trace_array *tr, int graph)
> >>
> >>  static void __irqsoff_tracer_init(struct trace_array *tr)
> >>  {
> >> -       save_flags = trace_flags;
> >> +       save_flags = global_trace_flags();
> >>
> >>         /* non overwrite screws up the latency tracers */
> >>         set_tracer_flag(tr, TRACE_ITER_OVERWRITE, 1);
> >> diff --git a/kernel/trace/trace_kdb.c b/kernel/trace/trace_kdb.c
> >> index bd90e1b..752759e 100644
> >> --- a/kernel/trace/trace_kdb.c
> >> +++ b/kernel/trace/trace_kdb.c
> >> @@ -29,10 +29,10 @@ static void ftrace_dump_buf(int skip_lines, long cpu_file)
> >>                 atomic_inc(&per_cpu_ptr(iter.trace_buffer->data, cpu)->disabled);
> >>         }
> >>
> >> -       old_userobj = trace_flags;
> >> +       old_userobj = global_trace_flags();
> >>
> >>         /* don't look at user memory in panic mode */
> >> -       trace_flags &= ~TRACE_ITER_SYM_USEROBJ;
> >> +       set_global_trace_flags(global_trace_flags() & ~TRACE_ITER_SYM_USEROBJ);
> >>
> >>         kdb_printf("Dumping ftrace buffer:\n");
> >>
> >> @@ -80,7 +80,7 @@ static void ftrace_dump_buf(int skip_lines, long cpu_file)
> >>                 kdb_printf("---------------------------------\n");
> >>
> >>  out:
> >> -       trace_flags = old_userobj;
> >> +       set_global_trace_flags(old_userobj);
> >>
> >>         for_each_tracing_cpu(cpu) {
> >>                 atomic_dec(&per_cpu_ptr(iter.trace_buffer->data, cpu)->disabled);
> >> diff --git a/kernel/trace/trace_output.c b/kernel/trace/trace_output.c
> >> index 34e7cba..ee536d0 100644
> >> --- a/kernel/trace/trace_output.c
> >> +++ b/kernel/trace/trace_output.c
> >> @@ -534,7 +534,7 @@ seq_print_userip_objs(const struct userstack_entry *entry, struct trace_seq *s,
> >>         int ret = 1;
> >>         unsigned int i;
> >>
> >> -       if (trace_flags & TRACE_ITER_SYM_USEROBJ) {
> >> +       if (global_trace_flags() & TRACE_ITER_SYM_USEROBJ) {
> >>                 struct task_struct *task;
> >>                 /*
> >>                  * we do the lookup on the thread group leader,
> >> @@ -657,7 +657,7 @@ static unsigned long preempt_mark_thresh_us = 100;
> >>  static int
> >>  lat_print_timestamp(struct trace_iterator *iter, u64 next_ts)
> >>  {
> >> -       unsigned long verbose = trace_flags & TRACE_ITER_VERBOSE;
> >> +       unsigned long verbose = global_trace_flags() & TRACE_ITER_VERBOSE;
> >>         unsigned long in_ns = iter->iter_flags & TRACE_FILE_TIME_IN_NS;
> >>         unsigned long long abs_ts = iter->ts - iter->trace_buffer->time_start;
> >>         unsigned long long rel_ts = next_ts - iter->ts;
> >> @@ -710,7 +710,7 @@ int trace_print_context(struct trace_iterator *iter)
> >>         if (!ret)
> >>                 return 0;
> >>
> >> -       if (trace_flags & TRACE_ITER_IRQ_INFO) {
> >> +       if (global_trace_flags() & TRACE_ITER_IRQ_INFO) {
> >>                 ret = trace_print_lat_fmt(s, entry);
> >>                 if (!ret)
> >>                         return 0;
> >> @@ -735,7 +735,7 @@ int trace_print_lat_context(struct trace_iterator *iter)
> >>         struct trace_entry *entry = iter->ent,
> >>                            *next_entry = trace_find_next_entry(iter, NULL,
> >>                                                                &next_ts);
> >> -       unsigned long verbose = (trace_flags & TRACE_ITER_VERBOSE);
> >> +       unsigned long verbose = global_trace_flags() & TRACE_ITER_VERBOSE;
> >>
> >>         /* Restore the original ent_size */
> >>         iter->ent_size = ent_size;
> >> diff --git a/kernel/trace/trace_printk.c b/kernel/trace/trace_printk.c
> >> index 2900817..7c9ce2e 100644
> >> --- a/kernel/trace/trace_printk.c
> >> +++ b/kernel/trace/trace_printk.c
> >> @@ -194,7 +194,7 @@ int __trace_bprintk(unsigned long ip, const char *fmt, ...)
> >>         if (unlikely(!fmt))
> >>                 return 0;
> >>
> >> -       if (!(trace_flags & TRACE_ITER_PRINTK))
> >> +       if (!(global_trace_flags() & TRACE_ITER_PRINTK))
> >>                 return 0;
> >>
> >>         va_start(ap, fmt);
> >> @@ -209,7 +209,7 @@ int __ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap)
> >>         if (unlikely(!fmt))
> >>                 return 0;
> >>
> >> -       if (!(trace_flags & TRACE_ITER_PRINTK))
> >> +       if (!(global_trace_flags() & TRACE_ITER_PRINTK))
> >>                 return 0;
> >>
> >>         return trace_vbprintk(ip, fmt, ap);
> >> @@ -221,7 +221,7 @@ int __trace_printk(unsigned long ip, const char *fmt, ...)
> >>         int ret;
> >>         va_list ap;
> >>
> >> -       if (!(trace_flags & TRACE_ITER_PRINTK))
> >> +       if (!(global_trace_flags() & TRACE_ITER_PRINTK))
> >>                 return 0;
> >>
> >>         va_start(ap, fmt);
> >> @@ -233,7 +233,7 @@ EXPORT_SYMBOL_GPL(__trace_printk);
> >>
> >>  int __ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap)
> >>  {
> >> -       if (!(trace_flags & TRACE_ITER_PRINTK))
> >> +       if (!(global_trace_flags() & TRACE_ITER_PRINTK))
> >>                 return 0;
> >>
> >>         return trace_vprintk(ip, fmt, ap);
> >> diff --git a/kernel/trace/trace_sched_wakeup.c b/kernel/trace/trace_sched_wakeup.c
> >> index fee77e1..87dc330 100644
> >> --- a/kernel/trace/trace_sched_wakeup.c
> >> +++ b/kernel/trace/trace_sched_wakeup.c
> >> @@ -138,6 +138,7 @@ static struct ftrace_ops trace_ops __read_mostly =
> >>  static int register_wakeup_function(int graph, int set)
> >>  {
> >>         int ret;
> >> +       int trace_flags = global_trace_flags();
> >>
> >>         /* 'set' is set if TRACE_ITER_FUNCTION is about to be set */
> >>         if (function_enabled || (!set && !(trace_flags & TRACE_ITER_FUNCTION)))
> >> @@ -583,7 +584,7 @@ static void stop_wakeup_tracer(struct trace_array *tr)
> >>
> >>  static int __wakeup_tracer_init(struct trace_array *tr)
> >>  {
> >> -       save_flags = trace_flags;
> >> +       save_flags = global_trace_flags();
> >>
> >>         /* non overwrite screws up the latency tracers */
> >>         set_tracer_flag(tr, TRACE_ITER_OVERWRITE, 1);
> >> diff --git a/kernel/trace/trace_syscalls.c b/kernel/trace/trace_syscalls.c
> >> index 559329d..c496eb5 100644
> >> --- a/kernel/trace/trace_syscalls.c
> >> +++ b/kernel/trace/trace_syscalls.c
> >> @@ -134,7 +134,7 @@ print_syscall_enter(struct trace_iterator *iter, int flags,
> >>
> >>         for (i = 0; i < entry->nb_args; i++) {
> >>                 /* parameter types */
> >> -               if (trace_flags & TRACE_ITER_VERBOSE) {
> >> +               if (global_trace_flags() & TRACE_ITER_VERBOSE) {
> >>                         ret = trace_seq_printf(s, "%s ", entry->types[i]);
> >>                         if (!ret)
> >>                                 return TRACE_TYPE_PARTIAL_LINE;
> >> --
> >> 1.8.4.1
> >>

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@...r.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

Powered by blists - more mailing lists