[PATCH] syslet: fix leak of ring and ahu
[fio.git] / parse.c
1 /*
2  * This file contains the ini and command liner parser main.
3  */
4 #include <stdio.h>
5 #include <stdlib.h>
6 #include <unistd.h>
7 #include <ctype.h>
8 #include <string.h>
9 #include <errno.h>
10 #include <limits.h>
11
12 #include "parse.h"
13
14 static unsigned long get_mult_time(char c)
15 {
16         switch (c) {
17                 case 'm':
18                 case 'M':
19                         return 60;
20                 case 'h':
21                 case 'H':
22                         return 60 * 60;
23                 case 'd':
24                 case 'D':
25                         return 24 * 60 * 60;
26                 default:
27                         return 1;
28         }
29 }
30
31 static unsigned long get_mult_bytes(char c)
32 {
33         switch (c) {
34                 case 'k':
35                 case 'K':
36                         return 1024;
37                 case 'm':
38                 case 'M':
39                         return 1024 * 1024;
40                 case 'g':
41                 case 'G':
42                         return 1024 * 1024 * 1024;
43                 case 'e':
44                 case 'E':
45                         return 1024 * 1024 * 1024 * 1024UL;
46                 default:
47                         return 1;
48         }
49 }
50
51 /*
52  * convert string into decimal value, noting any size suffix
53  */
54 static int str_to_decimal(const char *str, long long *val, int kilo)
55 {
56         int len;
57
58         len = strlen(str);
59         if (!len)
60                 return 1;
61
62         *val = strtoll(str, NULL, 10);
63         if (*val == LONG_MAX && errno == ERANGE)
64                 return 1;
65
66         if (kilo)
67                 *val *= get_mult_bytes(str[len - 1]);
68         else
69                 *val *= get_mult_time(str[len - 1]);
70
71         return 0;
72 }
73
74 static int check_str_bytes(const char *p, long long *val)
75 {
76         return str_to_decimal(p, val, 1);
77 }
78
79 static int check_str_time(const char *p, long long *val)
80 {
81         return str_to_decimal(p, val, 0);
82 }
83
84 void strip_blank_front(char **p)
85 {
86         char *s = *p;
87
88         while (isspace(*s))
89                 s++;
90 }
91
92 void strip_blank_end(char *p)
93 {
94         char *s = p + strlen(p) - 1;
95
96         while (isspace(*s) || iscntrl(*s))
97                 s--;
98
99         *(s + 1) = '\0';
100 }
101
102 static int check_range_bytes(const char *str, long *val)
103 {
104         char suffix;
105
106         if (!strlen(str))
107                 return 1;
108
109         if (sscanf(str, "%lu%c", val, &suffix) == 2) {
110                 *val *= get_mult_bytes(suffix);
111                 return 0;
112         }
113
114         if (sscanf(str, "%lu", val) == 1)
115                 return 0;
116
117         return 1;
118 }
119
120 static int check_int(const char *p, int *val)
121 {
122         if (!strlen(p))
123                 return 1;
124         if (sscanf(p, "%u", val) == 1)
125                 return 0;
126
127         return 1;
128 }
129
130 static struct fio_option *find_option(struct fio_option *options,
131                                       const char *opt)
132 {
133         struct fio_option *o;
134
135         for (o = &options[0]; o->name; o++) {
136                 if (!strcmp(o->name, opt))
137                         return o;
138                 else if (o->alias && !strcmp(o->alias, opt))
139                         return o;
140         }
141
142         return NULL;
143 }
144
145 #define val_store(ptr, val, off, data)                  \
146         do {                                            \
147                 ptr = td_var((data), (off));            \
148                 *ptr = (val);                           \
149         } while (0)
150
151 static int __handle_option(struct fio_option *o, const char *ptr, void *data,
152                            int first, int more)
153 {
154         int il, *ilp;
155         long long ull, *ullp;
156         long ul1, ul2;
157         char **cp;
158         int ret = 0, is_time = 0;
159
160         if (!ptr && o->type != FIO_OPT_STR_SET) {
161                 fprintf(stderr, "Option %s requires an argument\n", o->name);
162                 return 1;
163         }
164
165         switch (o->type) {
166         case FIO_OPT_STR: {
167                 fio_opt_str_fn *fn = o->cb;
168
169                 ret = fn(data, ptr);
170                 break;
171         }
172         case FIO_OPT_STR_VAL_TIME:
173                 is_time = 1;
174         case FIO_OPT_STR_VAL:
175         case FIO_OPT_STR_VAL_INT: {
176                 fio_opt_str_val_fn *fn = o->cb;
177
178                 if (is_time)
179                         ret = check_str_time(ptr, &ull);
180                 else
181                         ret = check_str_bytes(ptr, &ull);
182
183                 if (ret)
184                         break;
185
186                 if (o->maxval && ull > o->maxval) {
187                         fprintf(stderr, "max value out of range: %lld (%d max)\n", ull, o->maxval);
188                         return 1;
189                 }
190                 if (o->minval && ull < o->minval) {
191                         fprintf(stderr, "min value out of range: %lld (%d min)\n", ull, o->minval);
192                         return 1;
193                 }
194
195                 if (fn)
196                         ret = fn(data, &ull);
197                 else {
198                         if (o->type == FIO_OPT_STR_VAL_INT) {
199                                 if (first)
200                                         val_store(ilp, ull, o->off1, data);
201                                 if (!more && o->off2)
202                                         val_store(ilp, ull, o->off2, data);
203                         } else {
204                                 if (first)
205                                         val_store(ullp, ull, o->off1, data);
206                                 if (!more && o->off2)
207                                         val_store(ullp, ull, o->off2, data);
208                         }
209                 }
210                 break;
211         }
212         case FIO_OPT_STR_STORE:
213                 cp = td_var(data, o->off1);
214                 *cp = strdup(ptr);
215                 break;
216         case FIO_OPT_RANGE: {
217                 char tmp[128];
218                 char *p1, *p2;
219
220                 strncpy(tmp, ptr, sizeof(tmp) - 1);
221
222                 p1 = strchr(tmp, '-');
223                 if (!p1) {
224                         p1 = strchr(tmp, ':');
225                         if (!p1) {
226                                 ret = 1;
227                                 break;
228                         }
229                 }
230
231                 p2 = p1 + 1;
232                 *p1 = '\0';
233                 p1 = tmp;
234
235                 ret = 1;
236                 if (!check_range_bytes(p1, &ul1) && !check_range_bytes(p2, &ul2)) {
237                         ret = 0;
238                         if (ul1 > ul2) {
239                                 unsigned long foo = ul1;
240
241                                 ul1 = ul2;
242                                 ul2 = foo;
243                         }
244
245                         if (first) {
246                                 val_store(ilp, ul1, o->off1, data);
247                                 val_store(ilp, ul2, o->off2, data);
248                         }
249                         if (!more && o->off3 && o->off4) {
250                                 val_store(ilp, ul1, o->off3, data);
251                                 val_store(ilp, ul2, o->off4, data);
252                         }
253                 }
254
255                 break;
256         }
257         case FIO_OPT_INT:
258         case FIO_OPT_BOOL: {
259                 fio_opt_int_fn *fn = o->cb;
260
261                 ret = check_int(ptr, &il);
262                 if (ret)
263                         break;
264
265                 if (o->maxval && il > (int) o->maxval) {
266                         fprintf(stderr, "max value out of range: %d (%d max)\n", il, o->maxval);
267                         return 1;
268                 }
269                 if (o->minval && il < o->minval) {
270                         fprintf(stderr, "min value out of range: %d (%d min)\n", il, o->minval);
271                         return 1;
272                 }
273
274                 if (o->neg)
275                         il = !il;
276
277                 if (fn)
278                         ret = fn(data, &il);
279                 else {
280                         if (first)
281                                 val_store(ilp, il, o->off1, data);
282                         if (!more && o->off2)
283                                 val_store(ilp, il, o->off2, data);
284                 }
285                 break;
286         }
287         case FIO_OPT_STR_SET: {
288                 fio_opt_str_set_fn *fn = o->cb;
289
290                 if (fn)
291                         ret = fn(data);
292                 else {
293                         if (first)
294                                 val_store(ilp, 1, o->off1, data);
295                         if (!more && o->off2)
296                                 val_store(ilp, 1, o->off2, data);
297                 }
298                 break;
299         }
300         default:
301                 fprintf(stderr, "Bad option type %u\n", o->type);
302                 ret = 1;
303         }
304
305         return ret;
306 }
307
308 static int handle_option(struct fio_option *o, const char *ptr, void *data)
309 {
310         const char *ptr2 = NULL;
311         int r1, r2;
312
313         /*
314          * See if we have a second set of parameters, hidden after a comma.
315          * Do this before parsing the first round, to check if we should
316          * copy set 1 options to set 2.
317          */
318         if (ptr && (o->type != FIO_OPT_STR_STORE)) {
319                 ptr2 = strchr(ptr, ',');
320                 if (!ptr2)
321                         ptr2 = strchr(ptr, ':');
322         }
323
324         /*
325          * Don't return early if parsing the first option fails - if
326          * we are doing multiple arguments, we can allow the first one
327          * being empty.
328          */
329         r1 = __handle_option(o, ptr, data, 1, !!ptr2);
330
331         if (!ptr2)
332                 return r1;
333
334         ptr2++;
335         r2 = __handle_option(o, ptr2, data, 0, 0);
336
337         return r1 && r2;
338 }
339
340 int parse_cmd_option(const char *opt, const char *val,
341                      struct fio_option *options, void *data)
342 {
343         struct fio_option *o;
344
345         o = find_option(options, opt);
346         if (!o) {
347                 fprintf(stderr, "Bad option %s\n", opt);
348                 return 1;
349         }
350
351         if (!handle_option(o, val, data))
352                 return 0;
353
354         fprintf(stderr, "fio: failed parsing %s=%s\n", opt, val);
355         return 1;
356 }
357
358 int parse_option(const char *opt, struct fio_option *options, void *data)
359 {
360         struct fio_option *o;
361         char *pre, *post;
362         char tmp[64];
363
364         strncpy(tmp, opt, sizeof(tmp) - 1);
365
366         pre = strchr(tmp, '=');
367         if (pre) {
368                 post = pre;
369                 *pre = '\0';
370                 pre = tmp;
371                 post++;
372                 o = find_option(options, pre);
373         } else {
374                 o = find_option(options, tmp);
375                 post = NULL;
376         }
377
378         if (!o) {
379                 fprintf(stderr, "Bad option %s\n", tmp);
380                 return 1;
381         }
382
383         if (!handle_option(o, post, data))
384                 return 0;
385
386         fprintf(stderr, "fio: failed parsing %s\n", opt);
387         return 1;
388 }
389
390 static void show_option_range(struct fio_option *o)
391 {
392         if (!o->minval && !o->maxval)
393                 return;
394
395         printf("%16s: min=%d, max=%d\n", "range", o->minval, o->maxval);
396 }
397
398 static void show_option_values(struct fio_option *o)
399 {
400         const char *msg;
401         int i = 0;
402
403         if (!o->posval)
404                 return;
405
406         do {
407                 msg = o->posval[i];
408                 if (!msg)
409                         break;
410
411                 if (!i)
412                         printf("%16s: ", "valid values");
413
414                 printf("%s,", msg);
415                 i++;
416         } while (1);
417
418         if (i)
419                 printf("\n");
420 }
421
422 int show_cmd_help(struct fio_option *options, const char *name)
423 {
424         int show_all = !strcmp(name, "all");
425         const char *typehelp[] = {
426                 "string (opt=bla)",
427                 "string with possible k/m/g postfix (opt=4k)",
428                 "string with range and postfix (opt=1k-4k)",
429                 "string with time postfix (opt=10s)",
430                 "string (opt=bla)",
431                 "string with dual range (opt=1k-4k,4k-8k)",
432                 "integer value (opt=100)",
433                 "boolean value (opt=1)",
434                 "no argument (opt)",
435         };
436         struct fio_option *o;
437         int found = 0;
438
439         for (o = &options[0]; o->name; o++) {
440                 int match = !strcmp(name, o->name);
441
442                 if (show_all || match) {
443                         found = 1;
444                         printf("%16s: %s\n", o->name, o->help);
445                         if (show_all)
446                                 continue;
447                 }
448
449                 if (!match)
450                         continue;
451
452                 printf("%16s: %s\n", "type", typehelp[o->type]);
453                 printf("%16s: %s\n", "default", o->def ? o->def : "no default");
454                 show_option_range(o);
455                 show_option_values(o);
456         }
457
458         if (found)
459                 return 0;
460
461         printf("No such command: %s\n", name);
462         return 1;
463 }
464
465 /*
466  * Handle parsing of default parameters.
467  */
468 void fill_default_options(void *data, struct fio_option *options)
469 {
470         struct fio_option *o;
471
472         for (o = &options[0]; o->name; o++)
473                 if (o->def)
474                         handle_option(o, o->def, data);
475 }
476
477 /*
478  * Sanitize the options structure. For now it just sets min/max for bool
479  * values and whether both callback and offsets are given.
480  */
481 void options_init(struct fio_option *options)
482 {
483         struct fio_option *o;
484
485         for (o = &options[0]; o->name; o++) {
486                 if (o->type == FIO_OPT_BOOL) {
487                         o->minval = 0;
488                         o->maxval = 1;
489                 }
490                 if (o->cb && (o->off1 || o->off2 || o->off3 || o->off4))
491                         fprintf(stderr, "Option %s: both cb and offset given\n", o->name);
492         }
493 }