Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5cea57f3 authored by Masami Hiramatsu's avatar Masami Hiramatsu Committed by Arnaldo Carvalho de Melo
Browse files

perf tools: Rewrite strbuf not to die() 



Rewrite strbuf implementation not to use die() nor xrealloc().  Instead
of die(), now most of the API returns error code or 0 if succeeded.

Suggested-by: default avatarArnaldo Carvalho de Melo <acme@redhat.com>
Signed-off-by: default avatarMasami Hiramatsu <mhiramat@kernel.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20160510054658.6158.24080.stgit@devbox


Signed-off-by: default avatarArnaldo Carvalho de Melo <acme@redhat.com>
parent 9c7b37cd

tools/perf/util/strbuf.c

+67 −26
Original line number Diff line number Diff line 
#include "debug.h"

#include "cache.h"

#include <linux/kernel.h>
@@ -17,12 +18,13 @@ int prefixcmp(const char *str, const char *prefix) 
 */

char strbuf_slopbuf[1];



void strbuf_init(struct strbuf *sb, ssize_t hint)

int strbuf_init(struct strbuf *sb, ssize_t hint)

{

	sb->alloc = sb->len = 0;

	sb->buf = strbuf_slopbuf;

	if (hint)

		strbuf_grow(sb, hint);

		return strbuf_grow(sb, hint);

	return 0;

}



void strbuf_release(struct strbuf *sb)
@@ -42,67 +44,104 @@ char *strbuf_detach(struct strbuf *sb, size_t *sz) 
	return res;

}



void strbuf_grow(struct strbuf *sb, size_t extra)

int strbuf_grow(struct strbuf *sb, size_t extra)

{

	if (sb->len + extra + 1 <= sb->len)

		die("you want to use way too much memory");

	if (!sb->alloc)

		sb->buf = NULL;

	ALLOC_GROW(sb->buf, sb->len + extra + 1, sb->alloc);

	char *buf;

	size_t nr = sb->len + extra + 1;



	if (nr < sb->alloc)

		return 0;



	if (nr <= sb->len)

		return -E2BIG;



	if (alloc_nr(sb->alloc) > nr)

		nr = alloc_nr(sb->alloc);



	/*

	 * Note that sb->buf == strbuf_slopbuf if sb->alloc == 0, and it is

	 * a static variable. Thus we have to avoid passing it to realloc.

	 */

	buf = realloc(sb->alloc ? sb->buf : NULL, nr * sizeof(*buf));

	if (!buf)

		return -ENOMEM;



	sb->buf = buf;

	sb->alloc = nr;

	return 0;

}



void strbuf_addch(struct strbuf *sb, int c)

int strbuf_addch(struct strbuf *sb, int c)

{

	strbuf_grow(sb, 1);

	int ret = strbuf_grow(sb, 1);

	if (ret)

		return ret;



	sb->buf[sb->len++] = c;

	sb->buf[sb->len] = '\0';

	return 0;

}



void strbuf_add(struct strbuf *sb, const void *data, size_t len)

int strbuf_add(struct strbuf *sb, const void *data, size_t len)

{

	strbuf_grow(sb, len);

	int ret = strbuf_grow(sb, len);

	if (ret)

		return ret;



	memcpy(sb->buf + sb->len, data, len);

	strbuf_setlen(sb, sb->len + len);

	return strbuf_setlen(sb, sb->len + len);

}



static void strbuf_addv(struct strbuf *sb, const char *fmt, va_list ap)

static int strbuf_addv(struct strbuf *sb, const char *fmt, va_list ap)

{

	int len;

	int len, ret;

	va_list ap_saved;



	if (!strbuf_avail(sb))

		strbuf_grow(sb, 64);

	if (!strbuf_avail(sb)) {

		ret = strbuf_grow(sb, 64);

		if (ret)

			return ret;

	}



	va_copy(ap_saved, ap);

	len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap);

	if (len < 0)

		die("your vsnprintf is broken");

		return len;

	if (len > strbuf_avail(sb)) {

		strbuf_grow(sb, len);

		ret = strbuf_grow(sb, len);

		if (ret)

			return ret;

		len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap_saved);

		va_end(ap_saved);

		if (len > strbuf_avail(sb)) {

			die("this should not happen, your vsnprintf is broken");

			pr_debug("this should not happen, your vsnprintf is broken");

			return -EINVAL;

		}

	}

	strbuf_setlen(sb, sb->len + len);

	return strbuf_setlen(sb, sb->len + len);

}



void strbuf_addf(struct strbuf *sb, const char *fmt, ...)

int strbuf_addf(struct strbuf *sb, const char *fmt, ...)

{

	va_list ap;

	int ret;



	va_start(ap, fmt);

	strbuf_addv(sb, fmt, ap);

	ret = strbuf_addv(sb, fmt, ap);

	va_end(ap);

	return ret;

}



ssize_t strbuf_read(struct strbuf *sb, int fd, ssize_t hint)

{

	size_t oldlen = sb->len;

	size_t oldalloc = sb->alloc;

	int ret;



	ret = strbuf_grow(sb, hint ? hint : 8192);

	if (ret)

		return ret;



	strbuf_grow(sb, hint ? hint : 8192);

	for (;;) {

		ssize_t cnt;
@@ -112,12 +151,14 @@ ssize_t strbuf_read(struct strbuf *sb, int fd, ssize_t hint) 
				strbuf_release(sb);

			else

				strbuf_setlen(sb, oldlen);

			return -1;

			return cnt;

		}

		if (!cnt)

			break;

		sb->len += cnt;

		strbuf_grow(sb, 8192);

		ret = strbuf_grow(sb, 8192);

		if (ret)

			return ret;

	}



	sb->buf[sb->len] = '\0';

tools/perf/util/strbuf.h

+15 −10
Original line number Diff line number Diff line
@@ -51,7 +51,7 @@ struct strbuf { 
#define STRBUF_INIT  { 0, 0, strbuf_slopbuf }



/*----- strbuf life cycle -----*/

void strbuf_init(struct strbuf *buf, ssize_t hint);

int strbuf_init(struct strbuf *buf, ssize_t hint);

void strbuf_release(struct strbuf *buf);

char *strbuf_detach(struct strbuf *buf, size_t *);
@@ -60,26 +60,31 @@ static inline ssize_t strbuf_avail(const struct strbuf *sb) { 
	return sb->alloc ? sb->alloc - sb->len - 1 : 0;

}



void strbuf_grow(struct strbuf *buf, size_t);

int strbuf_grow(struct strbuf *buf, size_t);



static inline void strbuf_setlen(struct strbuf *sb, size_t len) {

	if (!sb->alloc)

		strbuf_grow(sb, 0);

static inline int strbuf_setlen(struct strbuf *sb, size_t len) {

	int ret;

	if (!sb->alloc) {

		ret = strbuf_grow(sb, 0);

		if (ret)

			return ret;

	}

	assert(len < sb->alloc);

	sb->len = len;

	sb->buf[len] = '\0';

	return 0;

}



/*----- add data in your buffer -----*/

void strbuf_addch(struct strbuf *sb, int c);

int strbuf_addch(struct strbuf *sb, int c);



void strbuf_add(struct strbuf *buf, const void *, size_t);

static inline void strbuf_addstr(struct strbuf *sb, const char *s) {

	strbuf_add(sb, s, strlen(s));

int strbuf_add(struct strbuf *buf, const void *, size_t);

static inline int strbuf_addstr(struct strbuf *sb, const char *s) {

	return strbuf_add(sb, s, strlen(s));

}



__attribute__((format(printf,2,3)))

void strbuf_addf(struct strbuf *sb, const char *fmt, ...);

int strbuf_addf(struct strbuf *sb, const char *fmt, ...);



/* XXX: if read fails, any partial read is undone */

ssize_t strbuf_read(struct strbuf *, int fd, ssize_t hint);