Skip to content
This repository was archived by the owner on Jan 17, 2019. It is now read-only.

Commit 6157e89

Browse files
bkokoszxbkokoszx
committed
logger: added tool for parsing new trace format
Signed-off-by: Bartosz Kokoszko <bartoszx.kokoszko@linux.intel.com>
1 parent 78748d4 commit 6157e89

1 file changed

Lines changed: 294 additions & 0 deletions

File tree

‎logger/logger.c‎

Lines changed: 294 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,294 @@
1+
#include <stdlib.h>
2+
#include <stdio.h>
3+
#include <stdint.h>
4+
#include <string.h>
5+
#include <errno.h>
6+
#include <unistd.h>
7+
#include "/usr/local/include/sof/uapi/logging.h"
8+
9+
#define CEIL(a, b) ((a+b-1)/b)
10+
11+
/* elf signature params */
12+
#define SND_SOF_LOGS_SIG_SIZE 4
13+
#define SND_SOF_LOGS_SIG "Logs"
14+
15+
struct snd_sof_logs_header {
16+
/* "Logs" */
17+
unsigned char sig[SND_SOF_LOGS_SIG_SIZE];
18+
/* address of log entries section */
19+
uint32_t base_address;
20+
/* amount of bytes following this header */
21+
uint32_t data_length;
22+
/* offset to first entry in this file */
23+
uint32_t data_offset;
24+
};
25+
26+
struct ldc_entry_header {
27+
uint32_t level;
28+
uint32_t component_id;
29+
uint32_t params_num;
30+
uint32_t line_idx;
31+
uint32_t file_name_len;
32+
};
33+
34+
struct ldc_entry {
35+
struct ldc_entry_header header;
36+
char *file_name;
37+
uint32_t text_len;
38+
char *text;
39+
uint32_t *params;
40+
};
41+
42+
struct dma_log {
43+
struct log_entry_header header;
44+
uint32_t address;
45+
};
46+
47+
static int fetch_entry(FILE *f_ldc, FILE *f_dma, uint32_t base_address,
48+
uint32_t data_offset, struct dma_log dma_log);
49+
static void print_table_header(void);
50+
static void print_entry_params(struct dma_log dma_log, struct ldc_entry);
51+
static void usage(char *name);
52+
53+
static inline void print_table_header(void)
54+
{
55+
fprintf(stdout, "%10s %8s %8s %14s %16s %24s\t%s\n",
56+
"ADDRESS",
57+
"CORE_ID",
58+
"LEVEL",
59+
"COMPONENT_ID",
60+
"TIMESTAMP",
61+
"FILE_NAME",
62+
"CONTENT");
63+
}
64+
65+
static void print_entry_params(struct dma_log dma_log,
66+
struct ldc_entry entry)
67+
{
68+
fprintf(stdout, "%10x %8u %8u %14u %16lu %20s:%u\t",
69+
dma_log.address,
70+
dma_log.header.core_id,
71+
entry.header.level,
72+
entry.header.component_id,
73+
dma_log.header.timestamp,
74+
entry.file_name,
75+
entry.header.line_idx);
76+
77+
switch (entry.header.params_num){
78+
case 0:
79+
fprintf(stdout, "%s", entry.text);
80+
break;
81+
case 1:
82+
fprintf(stdout, entry.text, entry.params[0]);
83+
break;
84+
case 2:
85+
fprintf(stdout, entry.text, entry.params[0],
86+
entry.params[1]);
87+
break;
88+
case 3:
89+
fprintf(stdout, entry.text, entry.params[0], entry.params[1],
90+
entry.params[2]);
91+
break;
92+
}
93+
fprintf(stdout, "\n");
94+
}
95+
96+
static void usage(char *name)
97+
{
98+
fprintf(stdout, "Usage %s <file(s)>\n", name);
99+
fprintf(stdout, "%s:\t Parse traces logs\n", name);
100+
fprintf(stdout, "%s:\t -l *.ldc_file\t-d dma_dump_file\n", name);
101+
exit(0);
102+
}
103+
104+
105+
static int fetch_entry(FILE *f_ldc, FILE *f_dma, uint32_t base_address,
106+
uint32_t data_offset, struct dma_log dma_log)
107+
{
108+
109+
struct ldc_entry entry;
110+
long int padding;
111+
112+
uint32_t entry_offset;
113+
uint32_t text_len;
114+
115+
int ret;
116+
117+
entry.file_name = NULL;
118+
entry.text = NULL;
119+
entry.params = NULL;
120+
121+
/* evaluate entry offset in input file */
122+
entry_offset = dma_log.address - base_address;
123+
124+
/* set file position to beginning of processed entry */
125+
fseek(f_ldc, entry_offset + data_offset, SEEK_SET);
126+
127+
/* fetching elf header params */
128+
ret = fread(&entry.header, sizeof(entry.header), 1, f_ldc);
129+
if (!ret) {
130+
ret = -ferror(f_ldc);
131+
goto out;
132+
}
133+
134+
entry.file_name = (char *) malloc(entry.header.file_name_len);
135+
if (!entry.file_name){
136+
fprintf(stderr, "error: can't allocate %d byte for "
137+
"entry.file_name\n", entry.header.file_name_len);
138+
ret = -ENOMEM;
139+
goto out;
140+
}
141+
142+
ret = fread(entry.file_name, sizeof(char), entry.header.file_name_len,
143+
f_ldc);
144+
if (ret != entry.header.file_name_len) {
145+
ret = -ferror(f_ldc);
146+
goto out;
147+
}
148+
149+
/* padding - sequences of chars are aligned to DWORDS */
150+
fseek(f_ldc, CEIL(entry.header.file_name_len, sizeof(uint32_t)) *
151+
sizeof(uint32_t) - entry.header.file_name_len, SEEK_CUR);
152+
153+
/* fetching text length */
154+
ret = fread(&entry.text_len, sizeof(entry.text_len), 1, f_ldc);
155+
if (!ret) {
156+
ret = -ferror(f_ldc);
157+
goto out;
158+
}
159+
160+
/* fetching text */
161+
entry.text = (char *) malloc(entry.text_len);
162+
if (entry.text == NULL) {
163+
fprintf(stderr, "error: can't allocate %d byte for "
164+
"entry.text\n", entry.text_len);
165+
ret = -ENOMEM;
166+
goto out;
167+
}
168+
169+
ret = fread(entry.text, sizeof(char), entry.text_len, f_ldc);
170+
if (ret != entry.text_len) {
171+
ret = -ferror(f_ldc);
172+
goto out;
173+
}
174+
175+
/* fetching entry params from dma dump */
176+
entry.params = (uint32_t *) malloc(sizeof(uint32_t) *
177+
entry.header.params_num);
178+
ret = fread(entry.params, sizeof(uint32_t), entry.header.params_num,
179+
f_dma);
180+
if (ret != entry.header.params_num) {
181+
ret = -ferror(f_dma);
182+
goto out;
183+
}
184+
185+
/* printing entry content */
186+
print_entry_params(dma_log, entry);
187+
188+
/* set f_ldc file position to the beginning */
189+
rewind(f_ldc);
190+
191+
ret = 0;
192+
out:
193+
/* free alocated memory */
194+
free(entry.params);
195+
free(entry.text);
196+
free(entry.file_name);
197+
198+
return ret;
199+
}
200+
201+
int main(int argc, char *argv[])
202+
{
203+
struct dma_log dma_log;
204+
struct snd_sof_logs_header snd;
205+
206+
int ret;
207+
int opt;
208+
209+
const char *ldc_dir = NULL;
210+
const char *dma_dump = NULL;
211+
212+
while ((opt = getopt(argc, argv, "l:d:")) != -1) {
213+
switch (opt) {
214+
case 'l':
215+
ldc_dir = optarg;
216+
break;
217+
case 'd':
218+
dma_dump = optarg;
219+
break;
220+
default:
221+
usage(argv[0]);
222+
}
223+
}
224+
225+
if (!ldc_dir) {
226+
fprintf(stderr, "error: invalid ldc file.\n");
227+
return -EINVAL;
228+
}
229+
if (!dma_dump) {
230+
fprintf(stderr, "error: invalid dma_dump file.\n");
231+
return -EINVAL;
232+
}
233+
234+
FILE *f_ldc = fopen(ldc_dir, "r");
235+
FILE *f_dma = fopen(dma_dump, "r");
236+
237+
if (f_ldc == NULL) {
238+
fprintf(stderr, "Error while opening %s. \n", ldc_dir);
239+
ret = errno;
240+
goto out;
241+
}
242+
243+
if (f_dma == NULL) {
244+
fprintf(stderr, "Error while opening %s. \n", dma_dump);
245+
ret = errno;
246+
goto out;
247+
}
248+
249+
/* set file positions to the beginning */
250+
rewind(f_ldc);
251+
rewind(f_dma);
252+
253+
/* veryfing ldc signature */
254+
ret = fread(&snd, sizeof(snd), 1, f_ldc);
255+
if (!ret) {
256+
ret = -ferror(f_ldc);
257+
goto out;
258+
}
259+
260+
if (strncmp(snd.sig, SND_SOF_LOGS_SIG, SND_SOF_LOGS_SIG_SIZE)) {
261+
fprintf(stderr, "Error: Invalid ldc file signature. \n");
262+
ret = -EINVAL;
263+
goto out;
264+
}
265+
266+
print_table_header();
267+
268+
while (!feof(f_dma)) {
269+
270+
/* getting entry parameters from dma dump */
271+
ret = fread(&dma_log, sizeof(dma_log), 1, f_dma);
272+
if (!ret) {
273+
ret = -ferror(f_dma);
274+
goto out;
275+
}
276+
277+
/* checking log address */
278+
if ((dma_log.address < snd.base_address) ||
279+
(dma_log.address > (snd.base_address + snd.data_length)))
280+
continue;
281+
282+
/* fetching entry from elf dump*/
283+
ret = fetch_entry(f_ldc, f_dma, snd.base_address,
284+
snd.data_offset, dma_log);
285+
if (ret) goto out;
286+
}
287+
288+
ret = 0;
289+
out:
290+
if (f_dma) fclose(f_dma);
291+
if (f_ldc) fclose(f_ldc);
292+
293+
return ret;
294+
}

0 commit comments

Comments
 (0)