tracing: Print trace_bprintk() formats for modules too

	return 0;

}

/*

 * The debugfs/tracing/printk_formats file maps the addresses with

 * the ASCII formats that are used in the bprintk events in the

 * buffer. For userspace tools to be able to decode the events from

 * the buffer, they need to be able to map the address with the format.

 *

 * The addresses of the bprintk formats are in their own section

 * __trace_printk_fmt. But for modules we copy them into a link list.

 * The code to print the formats and their addresses passes around the

 * address of the fmt string. If the fmt address passed into the seq

 * functions is within the kernel core __trace_printk_fmt section, then

 * it simply uses the next pointer in the list.

 *

 * When the fmt pointer is outside the kernel core __trace_printk_fmt

 * section, then we need to read the link list pointers. The trick is

 * we pass the address of the string to the seq function just like

 * we do for the kernel core formats. To get back the structure that

 * holds the format, we simply use containerof() and then go to the

 * next format in the list.

 */

static const char **

find_next_mod_format(int start_index, void *v, const char **fmt, loff_t *pos)

{

	struct trace_bprintk_fmt *mod_fmt;

	if (list_empty(&trace_bprintk_fmt_list))

		return NULL;

	/*

	 * v will point to the address of the fmt record from t_next

	 * v will be NULL from t_start.

	 * If this is the first pointer or called from start

	 * then we need to walk the list.

	 */

	if (!v || start_index == *pos) {

		struct trace_bprintk_fmt *p;

		/* search the module list */

		list_for_each_entry(p, &trace_bprintk_fmt_list, list) {

			if (start_index == *pos)

				return &p->fmt;

			start_index++;

		}

		/* pos > index */

		return NULL;

	}

	/*

	 * v points to the address of the fmt field in the mod list

	 * structure that holds the module print format.

	 */

	mod_fmt = container_of(v, typeof(*mod_fmt), fmt);

	if (mod_fmt->list.next == &trace_bprintk_fmt_list)

		return NULL;

	mod_fmt = container_of(mod_fmt->list.next, typeof(*mod_fmt), list);

	return &mod_fmt->fmt;

}

static void format_mod_start(void)

{

	mutex_lock(&btrace_mutex);

}

static void format_mod_stop(void)

{

	mutex_unlock(&btrace_mutex);

}

#else /* !CONFIG_MODULES */

__init static int

module_trace_bprintk_format_notify(struct notifier_block *self,

{

	return 0;

}

static inline const char **

find_next_mod_format(int start_index, void *v, const char **fmt, loff_t *pos)

{

	return NULL;

}

static inline void format_mod_start(void) { }

static inline void format_mod_stop(void) { }

#endif /* CONFIG_MODULES */

}

EXPORT_SYMBOL_GPL(__ftrace_vprintk);

static void *

t_start(struct seq_file *m, loff_t *pos)

static const char **find_next(void *v, loff_t *pos)

{

	const char **fmt = __start___trace_bprintk_fmt + *pos;

	const char **fmt = v;

	int start_index;

	if ((unsigned long)fmt >= (unsigned long)__stop___trace_bprintk_fmt)

		return NULL;

	if (!fmt)

		fmt = __start___trace_bprintk_fmt + *pos;

	start_index = __stop___trace_bprintk_fmt - __start___trace_bprintk_fmt;

	if (*pos < start_index)

		return fmt;

	return find_next_mod_format(start_index, v, fmt, pos);

}

static void *

t_start(struct seq_file *m, loff_t *pos)

{

	format_mod_start();

	return find_next(NULL, pos);

}

static void *t_next(struct seq_file *m, void * v, loff_t *pos)

{

	(*pos)++;

	return t_start(m, pos);

	return find_next(v, pos);

}

static int t_show(struct seq_file *m, void *v)

static void t_stop(struct seq_file *m, void *p)

{

	format_mod_stop();

}

static const struct seq_operations show_format_seq_ops = {