projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
ath9k: optimize waking tx queues, slightly improves performance under load
[openwrt.git] / package / rbcfg / src / main.c
1 /*
2 * RouterBOOT configuration utility
3 *
4 * Copyright (C) 2010 Gabor Juhos <juhosg@openwrt.org>
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 as published
8 * by the Free Software Foundation.
9 *
10 */
11
12 #include <stdlib.h>
13 #include <stdio.h>
14 #include <stddef.h>
15 #include <stdint.h>
16 #include <string.h>
17 #include <fcntl.h>
18 #include <unistd.h>
19 #include <sys/stat.h>
20 #include <linux/limits.h>
21
22 #include "rbcfg.h"
23 #include "cyg_crc.h"
24
25 #define RBCFG_TMP_FILE "/tmp/.rbcfg"
26 #define RBCFG_MTD_NAME "soft_config"
27
28 #define RB_ERR_NOTFOUND 1
29 #define RB_ERR_INVALID 2
30 #define RB_ERR_NOMEM 3
31 #define RB_ERR_IO 4
32
33 #define ARRAY_SIZE(_a) (sizeof((_a)) / sizeof((_a)[0]))
34
35 struct rbcfg_ctx {
36 char *mtd_device;
37 char *tmp_file;
38 char *buf;
39 unsigned buflen;
40 };
41
42 struct rbcfg_value {
43 const char *name;
44 const char *desc;
45 union {
46 uint32_t u32;
47 const char *raw;
48 } val;
49 };
50
51 #define RBCFG_ENV_TYPE_U32 0
52
53 struct rbcfg_env {
54 const char *name;
55 int type;
56 uint16_t id;
57 const struct rbcfg_value *values;
58 int num_values;
59 };
60
61 #define CMD_FLAG_USES_CFG 0x01
62
63 struct rbcfg_command {
64 const char *command;
65 const char *usage;
66 int flags;
67 int (*exec)(int argc, const char *argv[]);
68 };
69
70 static void usage(void);
71
72 /* Globals */
73
74 static struct rbcfg_ctx *rbcfg_ctx;
75 static char *rbcfg_name;
76
77 #define CFG_U32(_name, _desc, _val) { \
78 .name = (_name), \
79 .desc = (_desc), \
80 .val.u32 = (_val), \
81 }
82
83 static const struct rbcfg_value rbcfg_boot_delay[] = {
84 CFG_U32("1", "1 second", RB_BOOT_DELAY_1SEC),
85 CFG_U32("2", "2 seconds", RB_BOOT_DELAY_2SEC),
86 CFG_U32("3", "3 seconds", RB_BOOT_DELAY_3SEC),
87 CFG_U32("4", "4 seconds", RB_BOOT_DELAY_4SEC),
88 CFG_U32("5", "5 seconds", RB_BOOT_DELAY_5SEC),
89 CFG_U32("6", "6 seconds", RB_BOOT_DELAY_6SEC),
90 CFG_U32("7", "7 seconds", RB_BOOT_DELAY_7SEC),
91 CFG_U32("8", "8 seconds", RB_BOOT_DELAY_8SEC),
92 CFG_U32("9", "9 seconds", RB_BOOT_DELAY_9SEC),
93 };
94
95 static const struct rbcfg_value rbcfg_boot_device[] = {
96 CFG_U32("eth", "boot over Ethernet",
97 RB_BOOT_DEVICE_ETHER),
98 CFG_U32("nandeth", "boot from NAND, if fail then Ethernet",
99 RB_BOOT_DEVICE_NANDETH),
100 CFG_U32("ethnand", "boot Ethernet once, then NAND",
101 RB_BOOT_DEVICE_ETHONCE),
102 CFG_U32("nand", "boot from NAND only",
103 RB_BOOT_DEVICE_NANDONLY),
104 };
105
106 static const struct rbcfg_value rbcfg_boot_key[] = {
107 CFG_U32("any", "any key", RB_BOOT_KEY_ANY),
108 CFG_U32("del", "<Delete> key only", RB_BOOT_KEY_DEL),
109 };
110
111 static const struct rbcfg_value rbcfg_boot_protocol[] = {
112 CFG_U32("bootp", "BOOTP protocol", RB_BOOT_PROTOCOL_BOOTP),
113 CFG_U32("dhcp", "DHCP protocol", RB_BOOT_PROTOCOL_DHCP),
114 };
115
116 static const struct rbcfg_value rbcfg_uart_speed[] = {
117 CFG_U32("115200", "", RB_UART_SPEED_115200),
118 CFG_U32("57600", "", RB_UART_SPEED_57600),
119 CFG_U32("38400", "", RB_UART_SPEED_38400),
120 CFG_U32("19200", "", RB_UART_SPEED_19200),
121 CFG_U32("9600", "", RB_UART_SPEED_9600),
122 CFG_U32("4800", "", RB_UART_SPEED_4800),
123 CFG_U32("2400", "", RB_UART_SPEED_2400),
124 CFG_U32("1200", "", RB_UART_SPEED_1200),
125 CFG_U32("off", "disable console output", RB_UART_SPEED_OFF),
126 };
127
128 static const struct rbcfg_value rbcfg_cpu_mode[] = {
129 CFG_U32("powersave", "power save", RB_CPU_MODE_POWERSAVE),
130 CFG_U32("regular", "regular (better for -0c environment)",
131 RB_CPU_MODE_REGULAR),
132 };
133
134 static const struct rbcfg_value rbcfg_booter[] = {
135 CFG_U32("regular", "load regular booter", RB_BOOTER_REGULAR),
136 CFG_U32("backup", "force backup-booter loading", RB_BOOTER_BACKUP),
137 };
138
139 static const struct rbcfg_env rbcfg_envs[] = {
140 {
141 .name = "boot_delay",
142 .id = RB_ID_BOOT_DELAY,
143 .type = RBCFG_ENV_TYPE_U32,
144 .values = rbcfg_boot_delay,
145 .num_values = ARRAY_SIZE(rbcfg_boot_delay),
146 }, {
147 .name = "boot_device",
148 .id = RB_ID_BOOT_DEVICE,
149 .type = RBCFG_ENV_TYPE_U32,
150 .values = rbcfg_boot_device,
151 .num_values = ARRAY_SIZE(rbcfg_boot_device),
152 }, {
153 .name = "boot_key",
154 .id = RB_ID_BOOT_KEY,
155 .type = RBCFG_ENV_TYPE_U32,
156 .values = rbcfg_boot_key,
157 .num_values = ARRAY_SIZE(rbcfg_boot_key),
158 }, {
159 .name = "boot_protocol",
160 .id = RB_ID_BOOT_PROTOCOL,
161 .type = RBCFG_ENV_TYPE_U32,
162 .values = rbcfg_boot_protocol,
163 .num_values = ARRAY_SIZE(rbcfg_boot_protocol),
164 }, {
165 .name = "booter",
166 .id = RB_ID_BOOTER,
167 .type = RBCFG_ENV_TYPE_U32,
168 .values = rbcfg_booter,
169 .num_values = ARRAY_SIZE(rbcfg_booter),
170 }, {
171 .name = "cpu_mode",
172 .id = RB_ID_CPU_MODE,
173 .type = RBCFG_ENV_TYPE_U32,
174 .values = rbcfg_cpu_mode,
175 .num_values = ARRAY_SIZE(rbcfg_cpu_mode),
176 }, {
177 .name = "uart_speed",
178 .id = RB_ID_UART_SPEED,
179 .type = RBCFG_ENV_TYPE_U32,
180 .values = rbcfg_uart_speed,
181 .num_values = ARRAY_SIZE(rbcfg_uart_speed),
182 }
183 };
184
185 static inline uint16_t
186 get_u16(const void *buf)
187 {
188 const uint8_t *p = buf;
189
190 return ((uint16_t) p[1] + ((uint16_t) p[0] << 8));
191 }
192
193 static inline uint32_t
194 get_u32(const void *buf)
195 {
196 const uint8_t *p = buf;
197
198 return ((uint32_t) p[3] + ((uint32_t) p[2] << 8) +
199 ((uint32_t) p[1] << 16) + ((uint32_t) p[0] << 24));
200 }
201
202 static inline void
203 put_u32(void *buf, uint32_t val)
204 {
205 uint8_t *p = buf;
206
207 p[3] = val & 0xff;
208 p[2] = (val >> 8) & 0xff;
209 p[1] = (val >> 16) & 0xff;
210 p[0] = (val >> 24) & 0xff;
211 }
212
213 static int
214 rbcfg_find_tag(struct rbcfg_ctx *ctx, uint16_t tag_id, uint16_t *tag_len,
215 void **tag_data)
216 {
217 uint16_t id;
218 uint16_t len;
219 char *buf = ctx->buf;
220 unsigned int buflen = ctx->buflen;
221 int ret = RB_ERR_NOTFOUND;
222
223 /* skip magic and CRC value */
224 buf += 8;
225 buflen -= 8;
226
227 while (buflen > 2) {
228 len = get_u16(buf);
229 buf += 2;
230 buflen -= 2;
231
232 if (buflen < 2)
233 break;
234
235 id = get_u16(buf);
236 buf += 2;
237 buflen -= 2;
238
239 if (id == RB_ID_TERMINATOR)
240 break;
241
242 if (buflen < len)
243 break;
244
245 if (id == tag_id) {
246 *tag_len = len;
247 *tag_data = buf;
248 ret = 0;
249 break;
250 }
251
252 buf += len;
253 buflen -= len;
254 }
255
256 if (ret)
257 fprintf(stderr, "no tag found with id=%u\n", tag_id);
258
259 return ret;
260 }
261
262 static int
263 rbcfg_get_u32(struct rbcfg_ctx *ctx, uint16_t id, uint32_t *val)
264 {
265 void *tag_data;
266 uint16_t tag_len;
267 int err;
268
269 err = rbcfg_find_tag(ctx, id, &tag_len, &tag_data);
270 if (err)
271 return err;
272
273 *val = get_u32(tag_data);
274 return 0;
275 }
276
277 static int
278 rbcfg_set_u32(struct rbcfg_ctx *ctx, uint16_t id, uint32_t val)
279 {
280 void *tag_data;
281 uint16_t tag_len;
282 int err;
283
284 err = rbcfg_find_tag(ctx, id, &tag_len, &tag_data);
285 if (err)
286 return err;
287
288 put_u32(tag_data, val);
289 return 0;
290 }
291
292 char *rbcfg_find_mtd(const char *name, int *erase_size)
293 {
294 FILE *f;
295 int mtd_num;
296 char dev[PATH_MAX];
297 char *ret = NULL;
298 struct stat s;
299 int err;
300
301 f = fopen("/proc/mtd", "r");
302 if (!f)
303 return NULL;
304
305 while (1) {
306 char *p;
307 p = fgets(dev, sizeof(dev), f);
308 if (!p)
309 break;
310
311 if (!strstr(dev, name))
312 continue;
313
314 err = sscanf(dev, "mtd%d: %08x", &mtd_num, erase_size);
315 if (err != 2)
316 break;
317
318 sprintf(dev, "/dev/mtdblock%d", mtd_num);
319 err = stat(dev, &s);
320 if (err < 0)
321 break;
322
323 if ((s.st_mode & S_IFBLK) == 0)
324 break;
325
326 ret = malloc(strlen(dev) + 1);
327 if (ret == NULL)
328 break;
329
330 strncpy(ret, dev, strlen(dev) + 1);
331 break;
332 }
333
334 fclose(f);
335 return ret;
336 }
337
338 static int
339 rbcfg_check_tmp(struct rbcfg_ctx *ctx)
340 {
341 struct stat s;
342 int err;
343
344 err = stat(ctx->tmp_file, &s);
345 if (err < 0)
346 return 0;
347
348 if ((s.st_mode & S_IFREG) == 0)
349 return 0;
350
351 if (s.st_size != ctx->buflen)
352 return 0;
353
354 return 1;
355 }
356
357 static int
358 rbcfg_load(struct rbcfg_ctx *ctx)
359 {
360 uint32_t magic;
361 uint32_t crc_orig, crc;
362 char *name;
363 int tmp;
364 int fd;
365 int err;
366
367 tmp = rbcfg_check_tmp(ctx);
368 name = (tmp) ? ctx->tmp_file : ctx->mtd_device;
369
370 fd = open(name, O_RDONLY);
371 if (fd < 0) {
372 fprintf(stderr, "unable to open %s\n", name);
373 err = RB_ERR_IO;
374 goto err;
375 }
376
377 err = read(fd, ctx->buf, ctx->buflen);
378 if (err != ctx->buflen) {
379 fprintf(stderr, "unable to read from %s\n", name);
380 err = RB_ERR_IO;
381 goto err_close;
382 }
383
384 magic = get_u32(ctx->buf);
385 if (magic != RB_MAGIC_SOFT) {
386 fprintf(stderr, "invalid configuration\n");
387 err = RB_ERR_INVALID;
388 goto err_close;
389 }
390
391 crc_orig = get_u32(ctx->buf + 4);
392 put_u32(ctx->buf + 4, 0);
393 crc = cyg_ether_crc32((unsigned char *) ctx->buf, ctx->buflen);
394 if (crc != crc_orig) {
395 fprintf(stderr, "configuration has CRC error\n");
396 err = RB_ERR_INVALID;
397 goto err_close;
398 }
399
400 err = 0;
401
402 err_close:
403 close(fd);
404 err:
405 return err;
406 }
407
408 static int
409 rbcfg_open()
410 {
411 char *mtd_device;
412 struct rbcfg_ctx *ctx;
413 int buflen;
414 int err;
415
416 mtd_device = rbcfg_find_mtd(RBCFG_MTD_NAME, &buflen);
417 if (!mtd_device) {
418 fprintf(stderr, "unable to find configuration\n");
419 return RB_ERR_NOTFOUND;
420 }
421
422 ctx = malloc(sizeof(struct rbcfg_ctx) + buflen);
423 if (ctx == NULL) {
424 err = RB_ERR_NOMEM;
425 goto err_free_mtd;
426 }
427
428 ctx->mtd_device = mtd_device;
429 ctx->tmp_file = RBCFG_TMP_FILE;
430 ctx->buflen = buflen;
431 ctx->buf = (char *) &ctx[1];
432
433 err = rbcfg_load(ctx);
434 if (err)
435 goto err_free_ctx;
436
437 rbcfg_ctx = ctx;
438 return 0;
439
440 err_free_ctx:
441 free(ctx);
442 err_free_mtd:
443 free(mtd_device);
444 return err;
445 }
446
447 static int
448 rbcfg_update(int tmp)
449 {
450 struct rbcfg_ctx *ctx = rbcfg_ctx;
451 char *name;
452 uint32_t crc;
453 int fd;
454 int err;
455
456 put_u32(ctx->buf, RB_MAGIC_SOFT);
457 put_u32(ctx->buf + 4, 0);
458 crc = cyg_ether_crc32((unsigned char *) ctx->buf, ctx->buflen);
459 put_u32(ctx->buf + 4, crc);
460
461 name = (tmp) ? ctx->tmp_file : ctx->mtd_device;
462 fd = open(name, O_WRONLY | O_CREAT);
463 if (fd < 0) {
464 fprintf(stderr, "unable to open %s for writing\n", name);
465 err = RB_ERR_IO;
466 goto out;
467 }
468
469 err = write(fd, ctx->buf, ctx->buflen);
470 if (err != ctx->buflen) {
471 err = RB_ERR_IO;
472 goto out_close;
473 }
474
475 fsync(fd);
476 err = 0;
477
478 out_close:
479 close(fd);
480 out:
481 return err;
482 }
483
484 static void
485 rbcfg_close(void)
486 {
487 struct rbcfg_ctx *ctx;
488
489 ctx = rbcfg_ctx;
490 free(ctx->mtd_device);
491 free(ctx);
492 }
493
494 static const struct rbcfg_value *
495 rbcfg_env_find(const struct rbcfg_env *env, const char *name)
496 {
497 unsigned i;
498
499 for (i = 0; i < env->num_values; i++) {
500 const struct rbcfg_value *v = &env->values[i];
501
502 if (strcmp(v->name, name) == 0)
503 return v;
504 }
505
506 return NULL;
507 }
508
509 static const struct rbcfg_value *
510 rbcfg_env_find_u32(const struct rbcfg_env *env, uint32_t val)
511 {
512 unsigned i;
513
514 for (i = 0; i < env->num_values; i++) {
515 const struct rbcfg_value *v = &env->values[i];
516
517 if (v->val.u32 == val)
518 return v;
519 }
520
521 return NULL;
522 }
523
524 static const char *
525 rbcfg_env_get_u32(const struct rbcfg_env *env)
526 {
527 const struct rbcfg_value *v;
528 uint32_t val;
529 int err;
530
531 err = rbcfg_get_u32(rbcfg_ctx, env->id, &val);
532 if (err)
533 return NULL;
534
535 v = rbcfg_env_find_u32(env, val);
536 if (v == NULL) {
537 fprintf(stderr, "unknown value %08x found for %s\n",
538 val, env->name);
539 return NULL;
540 }
541
542 return v->name;
543 }
544
545 static int
546 rbcfg_env_set_u32(const struct rbcfg_env *env, const char *data)
547 {
548 const struct rbcfg_value *v;
549 int err;
550
551 v = rbcfg_env_find(env, data);
552 if (v == NULL) {
553 fprintf(stderr, "invalid value '%s'\n", data);
554 return RB_ERR_INVALID;
555 }
556
557 err = rbcfg_set_u32(rbcfg_ctx, env->id, v->val.u32);
558 return err;
559 }
560
561 static const char *
562 rbcfg_env_get(const struct rbcfg_env *env)
563 {
564 const char *ret = NULL;
565
566 switch (env->type) {
567 case RBCFG_ENV_TYPE_U32:
568 ret = rbcfg_env_get_u32(env);
569 break;
570 }
571
572 return ret;
573 }
574
575 static int
576 rbcfg_env_set(const struct rbcfg_env *env, const char *data)
577 {
578 int ret = 0;
579
580 switch (env->type) {
581 case RBCFG_ENV_TYPE_U32:
582 ret = rbcfg_env_set_u32(env, data);
583 break;
584 }
585
586 return ret;
587 }
588
589 static int
590 rbcfg_cmd_apply(int argc, const char *argv[])
591 {
592 return rbcfg_update(0);
593 }
594
595 static int
596 rbcfg_cmd_help(int argc, const char *argv[])
597 {
598 usage();
599 return 0;
600 }
601
602 static int
603 rbcfg_cmd_get(int argc, const char *argv[])
604 {
605 int err = RB_ERR_NOTFOUND;
606 int i;
607
608 if (argc != 1) {
609 usage();
610 return RB_ERR_INVALID;
611 }
612
613 for (i = 0; i < ARRAY_SIZE(rbcfg_envs); i++) {
614 const struct rbcfg_env *env = &rbcfg_envs[i];
615 const char *value;
616
617 if (strcmp(env->name, argv[0]))
618 continue;
619
620 value = rbcfg_env_get(env);
621 if (value) {
622 fprintf(stdout, "%s\n", value);
623 err = 0;
624 }
625 break;
626 }
627
628 return err;
629 }
630
631 static int
632 rbcfg_cmd_set(int argc, const char *argv[])
633 {
634 int err = RB_ERR_INVALID;
635 int i;
636
637 if (argc != 2) {
638 /* not enough parameters */
639 usage();
640 return RB_ERR_INVALID;
641 }
642
643 for (i = 0; i < ARRAY_SIZE(rbcfg_envs); i++) {
644 const struct rbcfg_env *env = &rbcfg_envs[i];
645
646 if (strcmp(env->name, argv[0]))
647 continue;
648
649 err = rbcfg_env_set(env, argv[1]);
650 if (err == 0)
651 err = rbcfg_update(1);
652 break;
653 }
654
655 return err;
656 }
657
658 static int
659 rbcfg_cmd_show(int argc, const char *argv[])
660 {
661 int i;
662
663 if (argc != 0) {
664 usage();
665 return RB_ERR_INVALID;
666 }
667
668 for (i = 0; i < ARRAY_SIZE(rbcfg_envs); i++) {
669 const struct rbcfg_env *env = &rbcfg_envs[i];
670 const char *value;
671
672 value = rbcfg_env_get(env);
673 if (value)
674 fprintf(stdout, "%s=%s\n", env->name, value);
675 }
676
677 return 0;
678 }
679
680 static const struct rbcfg_command rbcfg_commands[] = {
681 {
682 .command = "apply",
683 .usage = "apply\n"
684 "\t- write configuration to the mtd device",
685 .flags = CMD_FLAG_USES_CFG,
686 .exec = rbcfg_cmd_apply,
687 }, {
688 .command = "help",
689 .usage = "help\n"
690 "\t- show this screen",
691 .exec = rbcfg_cmd_help,
692 }, {
693 .command = "get",
694 .usage = "get <name>\n"
695 "\t- get value of the configuration option <name>",
696 .flags = CMD_FLAG_USES_CFG,
697 .exec = rbcfg_cmd_get,
698 }, {
699 .command = "set",
700 .usage = "set <name> <value>\n"
701 "\t- set value of the configuration option <name> to <value>",
702 .flags = CMD_FLAG_USES_CFG,
703 .exec = rbcfg_cmd_set,
704 }, {
705 .command = "show",
706 .usage = "show\n"
707 "\t- show value of all configuration options",
708 .flags = CMD_FLAG_USES_CFG,
709 .exec = rbcfg_cmd_show,
710 }
711 };
712
713 static void
714 usage(void)
715 {
716 char buf[255];
717 int len;
718 int i;
719
720 fprintf(stderr, "Usage: %s <command>\n", rbcfg_name);
721
722 fprintf(stderr, "\nCommands:\n");
723 for (i = 0; i < ARRAY_SIZE(rbcfg_commands); i++) {
724 const struct rbcfg_command *cmd;
725 cmd = &rbcfg_commands[i];
726
727 len = snprintf(buf, sizeof(buf), cmd->usage);
728 buf[len] = '\0';
729 fprintf(stderr, "%s\n", buf);
730 }
731
732 fprintf(stderr, "\nConfiguration options:\n");
733 for (i = 0; i < ARRAY_SIZE(rbcfg_envs); i++) {
734 const struct rbcfg_env *env;
735 int j;
736
737 env = &rbcfg_envs[i];
738 fprintf(stderr, "\n%s:\n", env->name);
739 for (j = 0; j < env->num_values; j++) {
740 const struct rbcfg_value *v = &env->values[j];
741 fprintf(stderr, "\t%-12s %s\n", v->name, v->desc);
742 }
743 }
744 fprintf(stderr, "\n");
745 }
746
747 int main(int argc, const char *argv[])
748 {
749 const struct rbcfg_command *cmd = NULL;
750 int ret;
751 int i;
752
753 rbcfg_name = (char *) argv[0];
754
755 if (argc < 2) {
756 usage();
757 return EXIT_FAILURE;
758 }
759
760 for (i = 0; i < ARRAY_SIZE(rbcfg_commands); i++) {
761 if (strcmp(rbcfg_commands[i].command, argv[1]) == 0) {
762 cmd = &rbcfg_commands[i];
763 break;
764 }
765 }
766
767 if (cmd == NULL) {
768 fprintf(stderr, "unknown command '%s'\n", argv[1]);
769 usage();
770 return EXIT_FAILURE;
771 }
772
773 argc -= 2;
774 argv += 2;
775
776 if (cmd->flags & CMD_FLAG_USES_CFG) {
777 ret = rbcfg_open();
778 if (ret)
779 return EXIT_FAILURE;
780 }
781
782 ret = cmd->exec(argc, argv);
783
784 if (cmd->flags & CMD_FLAG_USES_CFG)
785 rbcfg_close();
786
787 if (ret)
788 return EXIT_FAILURE;
789
790 return EXIT_SUCCESS;
791 }
Personal OpenWRT clone
This page took 0.078329 seconds and 5 git commands to generate.