perf: Move to dev-utils/perf
[akaros.git] / tools / dev-util / 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         struct stat stat_buf;
98         int fd = fileno(file);
99
100         if (fd < 0) {
101                 perror("xfsize fileno");
102                 exit(1);
103         }
104         if (fstat(fd, &stat_buf)) {
105                 perror("xfsize fstat");
106                 exit(1);
107         }
108         return stat_buf.st_size;
109 }
110
111 void xfwrite(const void *data, size_t size, FILE *file)
112 {
113         if (fwrite(data, 1, size, file) != size) {
114                 fprintf(stderr, "Unable to write %lu bytes: %s\n", size,
115                                 strerror(errno));
116                 exit(1);
117         }
118 }
119
120 void xfseek(FILE *file, off_t offset, int whence)
121 {
122         if (fseeko(file, offset, whence)) {
123                 int error = errno;
124
125                 fprintf(stderr, "Unable to seek at offset %ld from %s (fpos=%ld): %s\n",
126                                 offset, whence == SEEK_SET ? "beginning of file" :
127                                 (whence == SEEK_END ? "end of file" : "current position"),
128                                 ftell(file), strerror(error));
129                 exit(1);
130         }
131 }
132
133 void *xmalloc(size_t size)
134 {
135         void *data = malloc(size);
136
137         if (!data) {
138                 perror("Allocating memory block");
139                 exit(1);
140         }
141
142         return data;
143 }
144
145 void *xzmalloc(size_t size)
146 {
147         void *data = xmalloc(size);
148
149         memset(data, 0, size);
150
151         return data;
152 }
153
154 char *xstrdup(const char *str)
155 {
156         char *dstr = strdup(str);
157
158         if (dstr == NULL) {
159                 perror("Duplicating a string");
160                 exit(1);
161         }
162
163         return dstr;
164 }
165
166 const char *vb_decode_uint64(const char *data, uint64_t *pval)
167 {
168         unsigned int i;
169         uint64_t val = 0;
170
171         for (i = 0; (*data & 0x80) != 0; i += 7, data++)
172                 val |= (((uint64_t) *data) & 0x7f) << i;
173         *pval = val | ((uint64_t) *data) << i;
174
175         return data + 1;
176 }
177
178 int vb_fdecode_uint64(FILE *file, uint64_t *pval)
179 {
180         unsigned int i = 0;
181         uint64_t val = 0;
182
183         for (;;) {
184                 int c = fgetc(file);
185
186                 if (c == EOF)
187                         return EOF;
188                 val |= (((uint64_t) c) & 0x7f) << i;
189                 i += 7;
190                 if ((c & 0x80) == 0)
191                         break;
192         }
193         *pval = val;
194
195         return i / 7;
196 }
197
198 uint8_t nibble_to_num(char c)
199 {
200         switch (c) {
201         case '0':
202                 return 0;
203         case '1':
204                 return 1;
205         case '2':
206                 return 2;
207         case '3':
208                 return 3;
209         case '4':
210                 return 4;
211         case '5':
212                 return 5;
213         case '6':
214                 return 6;
215         case '7':
216                 return 7;
217         case '8':
218                 return 8;
219         case '9':
220                 return 9;
221         case 'a':
222         case 'A':
223                 return 0xa;
224         case 'b':
225         case 'B':
226                 return 0xb;
227         case 'c':
228         case 'C':
229                 return 0xc;
230         case 'd':
231         case 'D':
232                 return 0xd;
233         case 'e':
234         case 'E':
235                 return 0xe;
236         case 'f':
237         case 'F':
238                 return 0xf;
239         };
240         return -1;
241 }