Re: [RFC][PATCH 03/12 v3] tracing: Create seq_buf layer in trace_seq

Steven Rostedt
2014-11-10T17:37:55Z

On Mon, 10 Nov 2014 14:53:30 +0100
Petr Mladek <pmladek@suse.cz> wrote:

> > +/*
> > + * How much buffer is left on the seq_buf?
> > + */
> > +static inline unsigned int
> > +seq_buf_buffer_left(struct seq_buf *s)
> > +{
> > + return (s->size - 1) - s->len;
>
> This should be
>
> if (seq_buf_has_overflowed(s)
> return 0;
> return (s->size - 1) - s->len;
>
> otherwise, it would return UNIT_MAX for the overflown state. If I am
> not mistaken.

I guess I could add that. Probably the safer bet. Or document it that
this is undefined if buffer has overflowed. I have to check how my use
cases worked.

Probably best to add the overflow check anyway.

>
> [...]
>
> > diff --git a/kernel/trace/seq_buf.c b/kernel/trace/seq_buf.c
> > new file mode 100644
> > index 000000000000..88738b200bf3
> > --- /dev/null
> > +++ b/kernel/trace/seq_buf.c
>
> [...]
>
> > +
> > +/**
> > + * seq_buf_bitmask - write a bitmask array in its ASCII representation
> > + * @s: seq_buf descriptor
> > + * @maskp: points to an array of unsigned longs that represent a bitmask
> > + * @nmaskbits: The number of bits that are valid in @maskp
> > + *
> > + * Writes a ASCII representation of a bitmask string into @s.
> > + *
> > + * Returns zero on success, -1 on overflow.
> > + */
> > +int seq_buf_bitmask(struct seq_buf *s, const unsigned long *maskp,
> > + int nmaskbits)
> > +{
> > + unsigned int len = seq_buf_buffer_left(s);
> > + int ret;
> > +
> > + WARN_ON(s->size == 0);
> > +
> > + /*
> > + * The last byte of the buffer is used to determine if we
> > + * overflowed or not.
> > + */
> > + if (len > 1) {
> > + ret = bitmap_scnprintf(s->buffer, len, maskp, nmaskbits);
>
> It should be:
>
> ret = bitmap_scnprintf(s->buffer + s->len, len,
> maskp, nmaskbits);
>
> otherwise, we would write to the beginning to the buffer.

You are correct. But I'll make that a separate patch. This is just
keeping the bug that was in the original code.

>
> > + if (ret < len) {
> > + s->len += ret;
> > + return 0;
> > + }
> > + }
> > + seq_buf_set_overflow(s);
> > + return -1;
> > +}
> > +
>
> [...]
>
> > diff --git a/kernel/trace/trace_seq.c b/kernel/trace/trace_seq.c
> > index 1f24ed99dca2..3ad8738aea19 100644
> > --- a/kernel/trace/trace_seq.c
> > +++ b/kernel/trace/trace_seq.c
>
> [...]
>
> > @@ -144,23 +160,24 @@ EXPORT_SYMBOL_GPL(trace_seq_bitmask);
> > */
> > int trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args)
> > {
> > - unsigned int len = TRACE_SEQ_BUF_LEFT(s);
> > + unsigned int save_len = s->seq.len;
> > int ret;
> >
> > - if (s->full || !len)
> > + if (s->full)
> > return 0;
> >
> > - ret = vsnprintf(s->buffer + s->len, len, fmt, args);
> > + __trace_seq_init(s);
> > +
> > + ret = seq_buf_vprintf(&s->seq, fmt, args);
>
> Note that this returns 0 on success => we do not need to store it
>
> > /* If we can't write it all, don't bother writing anything */
> > - if (ret >= len) {
> > + if (unlikely(seq_buf_has_overflowed(&s->seq))) {
> > + s->seq.len = save_len;
> > s->full = 1;
> > return 0;
> > }
> >
> > - s->len += ret;
> > -
> > - return len;
> > + return ret;
>
> Instead, we have to do something like:
>
> return s->seq.len - save_len;

Actually, I need to make the trace_seq_*() functions return the same as
the seq_buf_*() functions.

I'll update this for now, but it's gotta change later. Probably why I
wasn't so careful about it.

>
> > }
> > EXPORT_SYMBOL_GPL(trace_seq_vprintf);
> >
> > @@ -183,23 +200,24 @@ EXPORT_SYMBOL_GPL(trace_seq_vprintf);
> > */
> > int trace_seq_bprintf(struct trace_seq *s, const char *fmt, const u32 *binary)
> > {
> > - unsigned int len = TRACE_SEQ_BUF_LEFT(s);
> > + unsigned int save_len = s->seq.len;
> > int ret;
> >
> > - if (s->full || !len)
> > + if (s->full)
> > return 0;
> >
> > - ret = bstr_printf(s->buffer + s->len, len, fmt, binary);
> > + __trace_seq_init(s);
> > +
> > + ret = seq_buf_bprintf(&s->seq, fmt, binary);
>
> Same here, it returns 0 on success => no need to store.
>
> > /* If we can't write it all, don't bother writing anything */
> > - if (ret >= len) {
> > + if (unlikely(seq_buf_has_overflowed(&s->seq))) {
> > + s->seq.len = save_len;
> > s->full = 1;
> > return 0;
> > }
> >
> > - s->len += ret;
> > -
> > - return len;
> > + return ret;
>
> and

same thing.

>
> return s->seq.len - save_len;
>
> > }
> > EXPORT_SYMBOL_GPL(trace_seq_bprintf);
> >
>
> [...]
>
> > /**
> > * trace_seq_putmem_hex - write raw memory into the buffer in ASCII hex
> > * @s: trace sequence descriptor
> > @@ -309,35 +328,30 @@ EXPORT_SYMBOL_GPL(trace_seq_putmem);
> > int trace_seq_putmem_hex(struct trace_seq *s, const void *mem,
> > unsigned int len)
> > {
> > - unsigned char hex[HEX_CHARS];
> > - const unsigned char *data = mem;
> > - unsigned int start_len;
> > - int i, j;
> > - int cnt = 0;
> > + unsigned int save_len = s->seq.len;
> > + int ret;
> >
> > if (s->full)
> > return 0;
> >
> > - while (len) {
> > - start_len = min(len, HEX_CHARS - 1);
> > -#ifdef __BIG_ENDIAN
> > - for (i = 0, j = 0; i < start_len; i++) {
> > -#else
> > - for (i = start_len-1, j = 0; i >= 0; i--) {
> > -#endif
> > - hex[j++] = hex_asc_hi(data[i]);
> > - hex[j++] = hex_asc_lo(data[i]);
> > - }
> > - if (WARN_ON_ONCE(j == 0 || j/2 > len))
> > - break;
> > -
> > - /* j increments twice per loop */
> > - len -= j / 2;
> > - hex[j++] = ' ';
> > -
> > - cnt += trace_seq_putmem(s, hex, j);
> > + __trace_seq_init(s);
> > +
> > + /* Each byte is represented by two chars */
> > + if (len * 2 > TRACE_SEQ_BUF_LEFT(s)) {
> > + s->full = 1;
> > + return 0;
> > + }
> > +
> > + /* The added spaces can still cause an overflow */
> > + ret = seq_buf_putmem_hex(&s->seq, mem, len);
>
> and here, it returns zero on success
>
> > +
> > + if (unlikely(seq_buf_has_overflowed(&s->seq))) {
> > + s->seq.len = save_len;
> > + s->full = 1;
> > + return 0;
> > }
> > - return cnt;
> > +
> > + return ret;
>
> Therefore we need something like:
>
> return s->seq.len - save_len;
>

Hmm, I may make the trace_seq_*() functions not return length written
first, before pulling out the seq_buf_*() code. That is, make the
trace_seq_*() behave more like what the seq_buf_*() code does first,
before pulling out the seq_buf_*() code.

> > }
> > EXPORT_SYMBOL_GPL(trace_seq_putmem_hex);
> >
> > @@ -355,30 +369,28 @@ EXPORT_SYMBOL_GPL(trace_seq_putmem_hex);
> > */
> > int trace_seq_path(struct trace_seq *s, const struct path *path)
> > {
> > - unsigned char *p;
> > + unsigned int save_len = s->seq.len;
> > + int ret;
> >
> > if (s->full)
> > return 0;
> >
> > + __trace_seq_init(s);
> > +
> > if (TRACE_SEQ_BUF_LEFT(s) < 1) {
> > s->full = 1;
> > return 0;
> > }
> >
> > - p = d_path(path, s->buffer + s->len, PAGE_SIZE - s->len);
> > - if (!IS_ERR(p)) {
> > - p = mangle_path(s->buffer + s->len, p, "\n");
> > - if (p) {
> > - s->len = p - s->buffer;
> > - return 1;
> > - }
> > - } else {
> > - s->buffer[s->len++] = '?';
> > - return 1;
> > + ret = seq_buf_path(&s->seq, path);
>
> This returns zero on sucess.
>
> > + if (unlikely(seq_buf_has_overflowed(&s->seq))) {
> > + s->seq.len = save_len;
> > + s->full = 1;
> > + return 0;
> > }
> >
> > - s->full = 1;
> > - return 0;
> > + return ret;
>
> and we want to return 1 on success =>
>
> return 1;
>
> > }
> > EXPORT_SYMBOL_GPL(trace_seq_path);
>
> Best Regards,
> Petr
>
>
> PS: I have to leave for a bit now. I hope that I will be able to look
> at the other patches later today.

Thanks for the review. Most of this will be fixed by doing the change
to the return value of the trace_seq_*() code first. I think I'll do
that.

-- Steve