perf: Add the perf stat subcommand
[akaros.git] / tools / profile / perf / xlib.c
1 /* Copyright (c) 2015 Google Inc
2  * Davide Libenzi <dlibenzi@google.com>
3  * See LICENSE for details.
4  */
5
6 #include <sys/types.h>
7 #include <sys/stat.h>
8 #include <stdint.h>
9 #include <stdio.h>
10 #include <string.h>
11 #include <stdlib.h>
12 #include <unistd.h>
13 #include <fcntl.h>
14 #include <errno.h>
15 #include "xlib.h"
16
17 int xopen(const char *path, int flags, mode_t mode)
18 {
19         int fd = open(path, flags, mode);
20
21         if (fd < 0) {
22                 perror(path);
23                 exit(1);
24         }
25
26         return fd;
27 }
28
29 void xwrite(int fd, const void *data, size_t size)
30 {
31         ssize_t wcount = write(fd, data, size);
32
33         if (size != (size_t) wcount) {
34                 perror("Writing file");
35                 exit(1);
36         }
37 }
38
39 void xread(int fd, void *data, size_t size)
40 {
41         ssize_t rcount = read(fd, data, size);
42
43         if (size != (size_t) rcount) {
44                 perror("Reading file");
45                 exit(1);
46         }
47 }
48
49 void xpwrite(int fd, const void *data, size_t size, off_t off)
50 {
51         ssize_t wcount = pwrite(fd, data, size, off);
52
53         if (size != (size_t) wcount) {
54                 perror("Writing file");
55                 exit(1);
56         }
57 }
58
59 void xpread(int fd, void *data, size_t size, off_t off)
60 {
61         ssize_t rcount = pread(fd, data, size, off);
62
63         if (size != (size_t) rcount) {
64                 perror("Reading file");
65                 exit(1);
66         }
67 }
68
69 FILE *xfopen(const char *path, const char *mode)
70 {
71         FILE *file = fopen(path, mode);
72
73         if (!file) {
74                 fprintf(stderr, "Unable to open file '%s' for mode '%s': %s\n",
75                                 path, mode, strerror(errno));
76                 exit(1);
77         }
78
79         return file;
80 }
81
82 FILE *xfdopen(int fd, const char *mode)
83 {
84         FILE *file = fdopen(fd, mode);
85
86         if (!file) {
87                 fprintf(stderr, "Unable to reopen fd '%d' for mode '%s;: %s\n", fd,
88                         mode, strerror(errno));
89                 exit(1);
90         }
91
92         return file;
93 }
94
95 off_t xfsize(FILE *file)
96 {
97         off_t pos = ftello(file), size;
98
99         xfseek(file, 0, SEEK_END);
100         size = ftello(file);
101         xfseek(file, pos, SEEK_SET);
102
103         return size;
104 }
105
106 void xfwrite(const void *data, size_t size, FILE *file)
107 {
108         if (fwrite(data, 1, size, file) != size) {
109                 fprintf(stderr, "Unable to write %lu bytes: %s\n", size,
110                                 strerror(errno));
111                 exit(1);
112         }
113 }
114
115 void xfseek(FILE *file, off_t offset, int whence)
116 {
117         if (fseeko(file, offset, whence)) {
118                 int error = errno;
119
120                 fprintf(stderr, "Unable to seek at offset %ld from %s (fpos=%ld): %s\n",
121                                 offset, whence == SEEK_SET ? "beginning of file" :
122                                 (whence == SEEK_END ? "end of file" : "current position"),
123                                 ftell(file), strerror(error));
124                 exit(1);
125         }
126 }
127
128 void *xmalloc(size_t size)
129 {
130         void *data = malloc(size);
131
132         if (!data) {
133                 perror("Allocating memory block");
134                 exit(1);
135         }
136
137         return data;
138 }
139
140 void *xzmalloc(size_t size)
141 {
142         void *data = xmalloc(size);
143
144         memset(data, 0, size);
145
146         return data;
147 }
148
149 char *xstrdup(const char *str)
150 {
151         char *dstr = strdup(str);
152
153         if (dstr == NULL) {
154                 perror("Duplicating a string");
155                 exit(1);
156         }
157
158         return dstr;
159 }
160
161 const char *vb_decode_uint64(const char *data, uint64_t *pval)
162 {
163         unsigned int i;
164         uint64_t val = 0;
165
166         for (i = 0; (*data & 0x80) != 0; i += 7, data++)
167                 val |= (((uint64_t) *data) & 0x7f) << i;
168         *pval = val | ((uint64_t) *data) << i;
169
170         return data + 1;
171 }
172
173 int vb_fdecode_uint64(FILE *file, uint64_t *pval)
174 {
175         unsigned int i = 0;
176         uint64_t val = 0;
177
178         for (;;) {
179                 int c = fgetc(file);
180
181                 if (c == EOF)
182                         return EOF;
183                 val |= (((uint64_t) c) & 0x7f) << i;
184                 i += 7;
185                 if ((c & 0x80) == 0)
186                         break;
187         }
188         *pval = val;
189
190         return i / 7;
191 }
192
193 uint8_t nibble_to_num(char c)
194 {
195         switch (c) {
196         case '0':
197                 return 0;
198         case '1':
199                 return 1;
200         case '2':
201                 return 2;
202         case '3':
203                 return 3;
204         case '4':
205                 return 4;
206         case '5':
207                 return 5;
208         case '6':
209                 return 6;
210         case '7':
211                 return 7;
212         case '8':
213                 return 8;
214         case '9':
215                 return 9;
216         case 'a':
217         case 'A':
218                 return 0xa;
219         case 'b':
220         case 'B':
221                 return 0xb;
222         case 'c':
223         case 'C':
224                 return 0xc;
225         case 'd':
226         case 'D':
227                 return 0xd;
228         case 'e':
229         case 'E':
230                 return 0xe;
231         case 'f':
232         case 'F':
233                 return 0xf;
234         };
235         return -1;
236 }