Commit 71a374bb authored by Kajol Jain's avatar Kajol Jain Committed by Arnaldo Carvalho de Melo
Browse files

perf jevents: Add new structure to pass json fields. 



This patch adds new structure called 'json_event' inside jevents.c
file to improve the callback prototype inside jevent files.

Initially, whenever user want to add new field, they need to update
in all function callback which make it more and more complex with
increased number of parmeters.

With this change, we just need to add it in new structure 'json_event'.

Signed-off-by: default avatarKajol Jain <kjain@linux.ibm.com>
Reviewed-by: default avatarAndi Kleen <ak@linux.intel.com>
Reviewed-by: default avatarJohn Garry <john.garry@huawei.com>
Acked-by: default avatarJiri Olsa <jolsa@redhat.com>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Ian Rogers <irogers@google.com>
Cc: Jin Yao <yao.jin@linux.intel.com>
Cc: Madhavan Srinivasan <maddy@linux.ibm.com>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Clarke <pc@us.ibm.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Ravi Bangoria <ravi.bangoria@linux.ibm.com>
Link: http://lore.kernel.org/lkml/20200907064133.75090-3-kjain@linux.ibm.com


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

tools/perf/pmu-events/jevents.c

+97 −115
Original line number Original line Diff line number Diff line
@@ -52,6 +52,23 @@ 
int verbose;

int verbose;

char *prog;

char *prog;





struct json_event {

	char *name;

	char *event;

	char *desc;

	char *long_desc;

	char *pmu;

	char *unit;

	char *perpkg;

	char *metric_expr;

	char *metric_name;

	char *metric_group;

	char *deprecated;

	char *metric_constraint;

};



typedef int (*func)(void *data, struct json_event *je);



int eprintf(int level, int var, const char *fmt, ...)

int eprintf(int level, int var, const char *fmt, ...)

{

{
@@ -70,11 +87,6 @@ int eprintf(int level, int var, const char *fmt, ...) 
	return ret;

	return ret;

}

}





__attribute__((weak)) char *get_cpu_str(void)

{

	return NULL;

}



static void addfield(char *map, char **dst, const char *sep,

static void addfield(char *map, char **dst, const char *sep,

		     const char *a, jsmntok_t *bt)

		     const char *a, jsmntok_t *bt)

{

{
@@ -318,12 +330,7 @@ static void print_events_table_prefix(FILE *fp, const char *tblname) 
	close_table = 1;

	close_table = 1;

}

}





static int print_events_table_entry(void *data, char *name, char *event,

static int print_events_table_entry(void *data, struct json_event *je)

				    char *desc, char *long_desc,

				    char *pmu, char *unit, char *perpkg,

				    char *metric_expr,

				    char *metric_name, char *metric_group,

				    char *deprecated, char *metric_constraint)

{

{

	struct perf_entry_data *pd = data;

	struct perf_entry_data *pd = data;

	FILE *outfp = pd->outfp;

	FILE *outfp = pd->outfp;
@@ -335,30 +342,30 @@ static int print_events_table_entry(void *data, char *name, char *event, 
	 */

	 */

	fprintf(outfp, "{\n");

	fprintf(outfp, "{\n");





	if (name)

	if (je->name)

		fprintf(outfp, "\t.name = \"%s\",\n", name);

		fprintf(outfp, "\t.name = \"%s\",\n", je->name);

	if (event)

	if (je->event)

		fprintf(outfp, "\t.event = \"%s\",\n", event);

		fprintf(outfp, "\t.event = \"%s\",\n", je->event);

	fprintf(outfp, "\t.desc = \"%s\",\n", desc);

	fprintf(outfp, "\t.desc = \"%s\",\n", je->desc);

	fprintf(outfp, "\t.topic = \"%s\",\n", topic);

	fprintf(outfp, "\t.topic = \"%s\",\n", topic);

	if (long_desc && long_desc[0])

	if (je->long_desc && je->long_desc[0])

		fprintf(outfp, "\t.long_desc = \"%s\",\n", long_desc);

		fprintf(outfp, "\t.long_desc = \"%s\",\n", je->long_desc);

	if (pmu)

	if (je->pmu)

		fprintf(outfp, "\t.pmu = \"%s\",\n", pmu);

		fprintf(outfp, "\t.pmu = \"%s\",\n", je->pmu);

	if (unit)

	if (je->unit)

		fprintf(outfp, "\t.unit = \"%s\",\n", unit);

		fprintf(outfp, "\t.unit = \"%s\",\n", je->unit);

	if (perpkg)

	if (je->perpkg)

		fprintf(outfp, "\t.perpkg = \"%s\",\n", perpkg);

		fprintf(outfp, "\t.perpkg = \"%s\",\n", je->perpkg);

	if (metric_expr)

	if (je->metric_expr)

		fprintf(outfp, "\t.metric_expr = \"%s\",\n", metric_expr);

		fprintf(outfp, "\t.metric_expr = \"%s\",\n", je->metric_expr);

	if (metric_name)

	if (je->metric_name)

		fprintf(outfp, "\t.metric_name = \"%s\",\n", metric_name);

		fprintf(outfp, "\t.metric_name = \"%s\",\n", je->metric_name);

	if (metric_group)

	if (je->metric_group)

		fprintf(outfp, "\t.metric_group = \"%s\",\n", metric_group);

		fprintf(outfp, "\t.metric_group = \"%s\",\n", je->metric_group);

	if (deprecated)

	if (je->deprecated)

		fprintf(outfp, "\t.deprecated = \"%s\",\n", deprecated);

		fprintf(outfp, "\t.deprecated = \"%s\",\n", je->deprecated);

	if (metric_constraint)

	if (je->metric_constraint)

		fprintf(outfp, "\t.metric_constraint = \"%s\",\n", metric_constraint);

		fprintf(outfp, "\t.metric_constraint = \"%s\",\n", je->metric_constraint);

	fprintf(outfp, "},\n");

	fprintf(outfp, "},\n");





	return 0;

	return 0;
@@ -380,17 +387,17 @@ struct event_struct { 
	char *metric_constraint;

	char *metric_constraint;

};

};





#define ADD_EVENT_FIELD(field) do { if (field) {		\

#define ADD_EVENT_FIELD(field) do { if (je->field) {		\

	es->field = strdup(field);				\

	es->field = strdup(je->field);				\

	if (!es->field)						\

	if (!es->field)						\

		goto out_free;					\

		goto out_free;					\

} } while (0)

} } while (0)





#define FREE_EVENT_FIELD(field) free(es->field)

#define FREE_EVENT_FIELD(field) free(es->field)





#define TRY_FIXUP_FIELD(field) do { if (es->field && !*field) {\

#define TRY_FIXUP_FIELD(field) do { if (es->field && !je->field) {\

	*field = strdup(es->field);				\

	je->field = strdup(es->field);				\

	if (!*field)						\

	if (!je->field)						\

		return -ENOMEM;					\

		return -ENOMEM;					\

} } while (0)

} } while (0)
@@ -421,11 +428,7 @@ static void free_arch_std_events(void) 
	}

	}

}

}





static int save_arch_std_events(void *data, char *name, char *event,

static int save_arch_std_events(void *data, struct json_event *je)

				char *desc, char *long_desc, char *pmu,

				char *unit, char *perpkg, char *metric_expr,

				char *metric_name, char *metric_group,

				char *deprecated, char *metric_constraint)

{

{

	struct event_struct *es;

	struct event_struct *es;
@@ -485,11 +488,8 @@ static char *real_event(const char *name, char *event) 
}

}





static int

static int

try_fixup(const char *fn, char *arch_std, char **event, char **desc,

try_fixup(const char *fn, char *arch_std, unsigned long long eventcode,

	  char **name, char **long_desc, char **pmu, char **filter,

	  struct json_event *je)

	  char **perpkg, char **unit, char **metric_expr, char **metric_name,

	  char **metric_group, unsigned long long eventcode,

	  char **deprecated, char **metric_constraint)

{

{

	/* try to find matching event from arch standard values */

	/* try to find matching event from arch standard values */

	struct event_struct *es;

	struct event_struct *es;
@@ -498,8 +498,8 @@ try_fixup(const char *fn, char *arch_std, char **event, char **desc, 
		if (!strcmp(arch_std, es->name)) {

		if (!strcmp(arch_std, es->name)) {

			if (!eventcode && es->event) {

			if (!eventcode && es->event) {

				/* allow EventCode to be overridden */

				/* allow EventCode to be overridden */

				free(*event);

				free(je->event);

				*event = NULL;

				je->event = NULL;

			}

			}

			FOR_ALL_EVENT_STRUCT_FIELDS(TRY_FIXUP_FIELD);

			FOR_ALL_EVENT_STRUCT_FIELDS(TRY_FIXUP_FIELD);

			return 0;

			return 0;
@@ -513,12 +513,7 @@ try_fixup(const char *fn, char *arch_std, char **event, char **desc, 




/* Call func with each event in the json file */

/* Call func with each event in the json file */

static int json_events(const char *fn,

static int json_events(const char *fn,

	  int (*func)(void *data, char *name, char *event, char *desc,

		int (*func)(void *data, struct json_event *je),

		      char *long_desc,

		      char *pmu, char *unit, char *perpkg,

		      char *metric_expr,

		      char *metric_name, char *metric_group,

		      char *deprecated, char *metric_constraint),

			void *data)

			void *data)

{

{

	int err;

	int err;
@@ -537,18 +532,10 @@ static int json_events(const char *fn, 
	EXPECT(tokens->type == JSMN_ARRAY, tokens, "expected top level array");

	EXPECT(tokens->type == JSMN_ARRAY, tokens, "expected top level array");

	tok = tokens + 1;

	tok = tokens + 1;

	for (i = 0; i < tokens->size; i++) {

	for (i = 0; i < tokens->size; i++) {

		char *event = NULL, *desc = NULL, *name = NULL;

		char *event = NULL;

		char *long_desc = NULL;

		char *extra_desc = NULL;

		char *extra_desc = NULL;

		char *pmu = NULL;

		char *filter = NULL;

		char *filter = NULL;

		char *perpkg = NULL;

		struct json_event je = {};

		char *unit = NULL;

		char *metric_expr = NULL;

		char *metric_name = NULL;

		char *metric_group = NULL;

		char *deprecated = NULL;

		char *metric_constraint = NULL;

		char *arch_std = NULL;

		char *arch_std = NULL;

		unsigned long long eventcode = 0;

		unsigned long long eventcode = 0;

		struct msrmap *msr = NULL;

		struct msrmap *msr = NULL;
@@ -583,14 +570,14 @@ static int json_events(const char *fn, 
				eventcode |= strtoul(code, NULL, 0) << 21;

				eventcode |= strtoul(code, NULL, 0) << 21;

				free(code);

				free(code);

			} else if (json_streq(map, field, "EventName")) {

			} else if (json_streq(map, field, "EventName")) {

				addfield(map, &name, "", "", val);

				addfield(map, &je.name, "", "", val);

			} else if (json_streq(map, field, "BriefDescription")) {

			} else if (json_streq(map, field, "BriefDescription")) {

				addfield(map, &desc, "", "", val);

				addfield(map, &je.desc, "", "", val);

				fixdesc(desc);

				fixdesc(je.desc);

			} else if (json_streq(map, field,

			} else if (json_streq(map, field,

					     "PublicDescription")) {

					     "PublicDescription")) {

				addfield(map, &long_desc, "", "", val);

				addfield(map, &je.long_desc, "", "", val);

				fixdesc(long_desc);

				fixdesc(je.long_desc);

			} else if (json_streq(map, field, "PEBS") && nz) {

			} else if (json_streq(map, field, "PEBS") && nz) {

				precise = val;

				precise = val;

			} else if (json_streq(map, field, "MSRIndex") && nz) {

			} else if (json_streq(map, field, "MSRIndex") && nz) {
@@ -610,34 +597,34 @@ static int json_events(const char *fn, 




				ppmu = field_to_perf(unit_to_pmu, map, val);

				ppmu = field_to_perf(unit_to_pmu, map, val);

				if (ppmu) {

				if (ppmu) {

					pmu = strdup(ppmu);

					je.pmu = strdup(ppmu);

				} else {

				} else {

					if (!pmu)

					if (!je.pmu)

						pmu = strdup("uncore_");

						je.pmu = strdup("uncore_");

					addfield(map, &pmu, "", "", val);

					addfield(map, &je.pmu, "", "", val);

					for (s = pmu; *s; s++)

					for (s = je.pmu; *s; s++)

						*s = tolower(*s);

						*s = tolower(*s);

				}

				}

				addfield(map, &desc, ". ", "Unit: ", NULL);

				addfield(map, &je.desc, ". ", "Unit: ", NULL);

				addfield(map, &desc, "", pmu, NULL);

				addfield(map, &je.desc, "", je.pmu, NULL);

				addfield(map, &desc, "", " ", NULL);

				addfield(map, &je.desc, "", " ", NULL);

			} else if (json_streq(map, field, "Filter")) {

			} else if (json_streq(map, field, "Filter")) {

				addfield(map, &filter, "", "", val);

				addfield(map, &filter, "", "", val);

			} else if (json_streq(map, field, "ScaleUnit")) {

			} else if (json_streq(map, field, "ScaleUnit")) {

				addfield(map, &unit, "", "", val);

				addfield(map, &je.unit, "", "", val);

			} else if (json_streq(map, field, "PerPkg")) {

			} else if (json_streq(map, field, "PerPkg")) {

				addfield(map, &perpkg, "", "", val);

				addfield(map, &je.perpkg, "", "", val);

			} else if (json_streq(map, field, "Deprecated")) {

			} else if (json_streq(map, field, "Deprecated")) {

				addfield(map, &deprecated, "", "", val);

				addfield(map, &je.deprecated, "", "", val);

			} else if (json_streq(map, field, "MetricName")) {

			} else if (json_streq(map, field, "MetricName")) {

				addfield(map, &metric_name, "", "", val);

				addfield(map, &je.metric_name, "", "", val);

			} else if (json_streq(map, field, "MetricGroup")) {

			} else if (json_streq(map, field, "MetricGroup")) {

				addfield(map, &metric_group, "", "", val);

				addfield(map, &je.metric_group, "", "", val);

			} else if (json_streq(map, field, "MetricConstraint")) {

			} else if (json_streq(map, field, "MetricConstraint")) {

				addfield(map, &metric_constraint, "", "", val);

				addfield(map, &je.metric_constraint, "", "", val);

			} else if (json_streq(map, field, "MetricExpr")) {

			} else if (json_streq(map, field, "MetricExpr")) {

				addfield(map, &metric_expr, "", "", val);

				addfield(map, &je.metric_expr, "", "", val);

				for (s = metric_expr; *s; s++)

				for (s = je.metric_expr; *s; s++)

					*s = tolower(*s);

					*s = tolower(*s);

			} else if (json_streq(map, field, "ArchStdEvent")) {

			} else if (json_streq(map, field, "ArchStdEvent")) {

				addfield(map, &arch_std, "", "", val);

				addfield(map, &arch_std, "", "", val);
@@ -646,7 +633,7 @@ static int json_events(const char *fn, 
			}

			}

			/* ignore unknown fields */

			/* ignore unknown fields */

		}

		}

		if (precise && desc && !strstr(desc, "(Precise Event)")) {

		if (precise && je.desc && !strstr(je.desc, "(Precise Event)")) {

			if (json_streq(map, precise, "2"))

			if (json_streq(map, precise, "2"))

				addfield(map, &extra_desc, " ",

				addfield(map, &extra_desc, " ",

						"(Must be precise)", NULL);

						"(Must be precise)", NULL);
@@ -656,48 +643,43 @@ static int json_events(const char *fn, 
		}

		}

		snprintf(buf, sizeof buf, "event=%#llx", eventcode);

		snprintf(buf, sizeof buf, "event=%#llx", eventcode);

		addfield(map, &event, ",", buf, NULL);

		addfield(map, &event, ",", buf, NULL);

		if (desc && extra_desc)

		if (je.desc && extra_desc)

			addfield(map, &desc, " ", extra_desc, NULL);

			addfield(map, &je.desc, " ", extra_desc, NULL);

		if (long_desc && extra_desc)

		if (je.long_desc && extra_desc)

			addfield(map, &long_desc, " ", extra_desc, NULL);

			addfield(map, &je.long_desc, " ", extra_desc, NULL);

		if (filter)

		if (filter)

			addfield(map, &event, ",", filter, NULL);

			addfield(map, &event, ",", filter, NULL);

		if (msr != NULL)

		if (msr != NULL)

			addfield(map, &event, ",", msr->pname, msrval);

			addfield(map, &event, ",", msr->pname, msrval);

		if (name)

		if (je.name)

			fixname(name);

			fixname(je.name);





		if (arch_std) {

		if (arch_std) {

			/*

			/*

			 * An arch standard event is referenced, so try to

			 * An arch standard event is referenced, so try to

			 * fixup any unassigned values.

			 * fixup any unassigned values.

			 */

			 */

			err = try_fixup(fn, arch_std, &event, &desc, &name,

			err = try_fixup(fn, arch_std, eventcode, &je);

					&long_desc, &pmu, &filter, &perpkg,

					&unit, &metric_expr, &metric_name,

					&metric_group, eventcode,

					&deprecated, &metric_constraint);

			if (err)

			if (err)

				goto free_strings;

				goto free_strings;

		}

		}

		err = func(data, name, real_event(name, event), desc, long_desc,

		je.event = real_event(je.name, event);

			   pmu, unit, perpkg, metric_expr, metric_name,

		err = func(data, &je);

			   metric_group, deprecated, metric_constraint);

free_strings:

free_strings:

		free(event);

		free(event);

		free(desc);

		free(je.desc);

		free(name);

		free(je.name);

		free(long_desc);

		free(je.long_desc);

		free(extra_desc);

		free(extra_desc);

		free(pmu);

		free(je.pmu);

		free(filter);

		free(filter);

		free(perpkg);

		free(je.perpkg);

		free(deprecated);

		free(je.deprecated);

		free(unit);

		free(je.unit);

		free(metric_expr);

		free(je.metric_expr);

		free(metric_name);

		free(je.metric_name);

		free(metric_group);

		free(je.metric_group);

		free(metric_constraint);

		free(je.metric_constraint);

		free(arch_std);

		free(arch_std);





		if (err)

		if (err)