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