example/config.c

   1 /*
   2  * 2008+ Copyright (c) Evgeniy Polyakov <zbr@ioremap.net>
   3  * All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  */
  15
  16 #include <sys/types.h>
  17 #include <sys/stat.h>
  18 #include <sys/socket.h>
  19 #include <sys/time.h>
  20 #include <sys/syscall.h>
  21
  22 #include <ctype.h>
  23 #include <fcntl.h>
  24 #include <errno.h>
  25 #include <malloc.h>
  26 #include <signal.h>
  27 #include <stdarg.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <syslog.h>
  32 #include <time.h>
  33 #include <unistd.h>
  34
  35 #include "elliptics/packet.h"
  36 #include "elliptics/interface.h"
  37
  38 #include "common.h"
  39 #include "backends.h"
  40
  41 #ifdef HAVE_SMACK_SUPPORT
  42 int dnet_smack_backend_init(void);
  43 void dnet_smack_backend_exit(void);
  44 #endif
  45
  46 #ifndef __unused
  47 #define __unused        __attribute__ ((unused))
  48 #endif
  49
  50 /*
  51  * Config parser is single-threaded.
  52  * No locks and simultaneous access from different threads.
  53  */
  54
  55 #define DNET_CONF_COMMENT       '#'
  56 #define DNET_CONF_DELIMITER     '='
  57
  58 static char *dnet_skip_line(char *line)
  59 {
  60         int len = strlen(line), i;
  61
  62         for (i=0; i<len; ++i) {
  63                 if (line[i] == DNET_CONF_COMMENT)
  64                         return NULL;
  65                 if (isspace(line[i]))
  66                         continue;
  67
  68                 return &line[i];
  69         }
  70
  71         return NULL;
  72 }
  73
  74 static struct dnet_log dnet_backend_logger;
  75 char *dnet_logger_value;
  76
  77 static struct dnet_config dnet_cfg_state;
  78 static char *dnet_cfg_remotes;
  79 static int dnet_daemon_mode;
  80
  81 static int dnet_simple_set(struct dnet_config_backend *b __unused, char *key, char *str)
  82 {
  83         unsigned long value = strtoul(str, NULL, 0);
  84
  85         if (!strcmp(key, "log_level"))
  86                 dnet_backend_logger.log_level = value;
  87         else if (!strcmp(key, "wait_timeout"))
  88                 dnet_cfg_state.wait_timeout = value;
  89         else if (!strcmp(key, "check_timeout"))
  90                 dnet_cfg_state.check_timeout = value;
  91         else if (!strcmp(key, "stall_count"))
  92                 dnet_cfg_state.stall_count = value;
  93         else if (!strcmp(key, "join"))
  94                 dnet_cfg_state.flags |= value ? DNET_CFG_JOIN_NETWORK : 0;
  95         else if (!strcmp(key, "flags"))
  96                 dnet_cfg_state.flags |= (value & ~DNET_CFG_JOIN_NETWORK);
  97         else if (!strcmp(key, "daemon"))
  98                 dnet_daemon_mode = value;
  99         else if (!strcmp(key, "io_thread_num"))
 100                 dnet_cfg_state.io_thread_num = value;
 101         else if (!strcmp(key, "nonblocking_io_thread_num"))
 102                 dnet_cfg_state.nonblocking_io_thread_num = value;
 103         else if (!strcmp(key, "net_thread_num"))
 104                 dnet_cfg_state.net_thread_num = value;
 105         else if (!strcmp(key, "bg_ionice_class"))
 106                 dnet_cfg_state.bg_ionice_class = value;
 107         else if (!strcmp(key, "bg_ionice_prio"))
 108                 dnet_cfg_state.bg_ionice_prio = value;
 109         else if (!strcmp(key, "removal_delay"))
 110                 dnet_cfg_state.removal_delay = value;
 111         else if (!strcmp(key, "server_net_prio"))
 112                 dnet_cfg_state.server_prio = value;
 113         else if (!strcmp(key, "client_net_prio"))
 114                 dnet_cfg_state.client_prio = value;
 115         else if (!strcmp(key, "oplock_num"))
 116                 dnet_cfg_state.oplock_num = value;
 117         else
 118                 return -1;
 119
 120         return 0;
 121 }
 122
 123 static int dnet_set_group(struct dnet_config_backend *b __unused, char *key __unused, char *value)
 124 {
 125         dnet_cfg_state.group_id = strtoul(value, NULL, 0);
 126         return 0;
 127 }
 128
 129 static int dnet_set_addr(struct dnet_config_backend *b __unused, char *key __unused, char *value)
 130 {
 131         return dnet_parse_addr(value, &dnet_cfg_state);
 132 }
 133
 134 static int dnet_set_remote_addrs(struct dnet_config_backend *b __unused, char *key __unused, char *value)
 135 {
 136         dnet_cfg_remotes = strdup(value);
 137         if (!dnet_cfg_remotes)
 138                 return -ENOMEM;
 139
 140         return 0;
 141 }
 142
 143 static int dnet_set_srw(struct dnet_config_backend *b __unused, char *key, char *value)
 144 {
 145         char **ptr = NULL;
 146
 147         if (!strcmp(key, "srw_config"))
 148                 ptr = &dnet_cfg_state.srw.config;
 149
 150         if (ptr) {
 151                 free(*ptr);
 152                 *ptr = strdup(value);
 153                 if (!*ptr)
 154                         return -ENOMEM;
 155         }
 156
 157         return 0;
 158 }
 159
 160 static int dnet_set_malloc_options(struct dnet_config_backend *b __unused, char *key __unused, char *value)
 161 {
 162         int err, thr = atoi(value);
 163
 164         err = mallopt(M_MMAP_THRESHOLD, thr);
 165         if (err < 0) {
 166                 dnet_backend_log(DNET_LOG_ERROR, "Failed to set mmap threshold to %d: %s\n", thr, strerror(errno));
 167                 return err;
 168         }
 169
 170         dnet_backend_log(DNET_LOG_INFO, "Set mmap threshold to %d.\n", thr);
 171         return 0;
 172 }
 173
 174 static int dnet_set_auth_cookie(struct dnet_config_backend *b __unused, char *key __unused, char *value)
 175 {
 176         snprintf(dnet_cfg_state.cookie, DNET_AUTH_COOKIE_SIZE, "%s", value);
 177         return 0;
 178 }
 179
 180 static int dnet_set_backend(struct dnet_config_backend *b, char *key __unused, char *value);
 181
 182 int dnet_set_log(struct dnet_config_backend *b __unused, char *key __unused, char *value)
 183 {
 184         char *tmp;
 185
 186         tmp = strdup(value);
 187         if (!tmp)
 188                 return -ENOMEM;
 189
 190         if (dnet_logger_value)
 191                 free(dnet_logger_value);
 192
 193         dnet_logger_value = tmp;
 194
 195         if (!strcmp(dnet_logger_value, "syslog")) {
 196                 openlog("elliptics", 0, LOG_USER);
 197
 198                 dnet_backend_logger.log_private = NULL;
 199                 dnet_backend_logger.log = dnet_syslog;
 200         } else {
 201                 FILE *log, *old = dnet_backend_logger.log_private;
 202                 int err;
 203
 204                 log = fopen(dnet_logger_value, "a");
 205                 if (!log) {
 206                         err = -errno;
 207                         fprintf(stderr, "cnf: failed to open log file '%s': %s\n", dnet_logger_value, strerror(errno));
 208                         return err;
 209                 }
 210
 211                 dnet_backend_logger.log_private = log;
 212                 dnet_backend_logger.log = dnet_common_log;
 213
 214                 dnet_common_log(log, 0xff, "Reopened log file\n");
 215
 216                 if (old) {
 217                         dnet_common_log(old, 0xff, "Reopened log file\n");
 218                         fclose(old);
 219                 }
 220         }
 221
 222         dnet_cfg_state.log = &dnet_backend_logger;
 223         return 0;
 224 }
 225
 226 static int dnet_set_history_env(struct dnet_config_backend *b __unused, char *key __unused, char *value)
 227 {
 228         snprintf(dnet_cfg_state.history_env, sizeof(dnet_cfg_state.history_env), "%s", value);
 229         return 0;
 230 }
 231
 232 static int dnet_set_cache_size(struct dnet_config_backend *b __unused, char *key __unused, char *value)
 233 {
 234         dnet_cfg_state.cache_size = strtoull(value, NULL, 0);
 235         return 0;
 236 }
 237
 238 static struct dnet_config_entry dnet_cfg_entries[] = {
 239         {"mallopt_mmap_threshold", dnet_set_malloc_options},
 240         {"log_level", dnet_simple_set},
 241         {"wait_timeout", dnet_simple_set},
 242         {"check_timeout", dnet_simple_set},
 243         {"stall_count", dnet_simple_set},
 244         {"group", dnet_set_group},
 245         {"addr", dnet_set_addr},
 246         {"remote", dnet_set_remote_addrs},
 247         {"join", dnet_simple_set},
 248         {"flags", dnet_simple_set},
 249         {"backend", dnet_set_backend},
 250         {"daemon", dnet_simple_set},
 251         {"log", dnet_set_log},
 252         {"history", dnet_set_history_env},
 253         {"io_thread_num", dnet_simple_set},
 254         {"nonblocking_io_thread_num", dnet_simple_set},
 255         {"net_thread_num", dnet_simple_set},
 256         {"bg_ionice_class", dnet_simple_set},
 257         {"bg_ionice_prio", dnet_simple_set},
 258         {"removal_delay", dnet_simple_set},
 259         {"auth_cookie", dnet_set_auth_cookie},
 260         {"server_net_prio", dnet_simple_set},
 261         {"client_net_prio", dnet_simple_set},
 262         {"oplock_num", dnet_simple_set},
 263         {"srw_config", dnet_set_srw},
 264         {"cache_size", dnet_set_cache_size},
 265 };
 266
 267 static struct dnet_config_entry *dnet_cur_cfg_entries = dnet_cfg_entries;
 268 static int dnet_cur_cfg_size = ARRAY_SIZE(dnet_cfg_entries);
 269
 270 static struct dnet_config_backend *dnet_cfg_backend, *dnet_cfg_current_backend;
 271 static int dnet_cfg_backend_num;
 272
 273 static int dnet_set_backend(struct dnet_config_backend *current_backend __unused, char *key __unused, char *value)
 274 {
 275         struct dnet_config_backend *b;
 276         int i;
 277
 278         for (i=0; i<dnet_cfg_backend_num; ++i) {
 279                 b = &dnet_cfg_backend[i];
 280
 281                 if (!strcmp(value, b->name)) {
 282                         if (b->size) {
 283                                 b->data = malloc(b->size);
 284                                 if (!b->data)
 285                                         return -ENOMEM;
 286                                 memset(b->data, 0, b->size);
 287                         }
 288
 289                         b->log = dnet_cfg_state.log;
 290
 291                         dnet_cur_cfg_entries = b->ent;
 292                         dnet_cur_cfg_size = b->num;
 293                         dnet_cfg_current_backend = b;
 294
 295                         return 0;
 296                 }
 297         }
 298
 299         return -ENOENT;
 300 }
 301
 302 int dnet_backend_register(struct dnet_config_backend *b)
 303 {
 304         dnet_cfg_backend = realloc(dnet_cfg_backend, (dnet_cfg_backend_num + 1) * sizeof(struct dnet_config_backend));
 305         if (!dnet_cfg_backend)
 306                 return -ENOMEM;
 307
 308         memcpy(&dnet_cfg_backend[dnet_cfg_backend_num], b, sizeof(struct dnet_config_backend));
 309         dnet_cfg_backend_num++;
 310
 311         return 0;
 312 }
 313
 314 struct dnet_node *dnet_parse_config(char *file, int mon)
 315 {
 316         FILE *f;
 317         int buf_size = 1024 * 1024;
 318         char *buf, *ptr, *value, *key;
 319         int err, i, len;
 320         int line_num = 0;
 321         struct dnet_node *n;
 322
 323         sigset_t sig;
 324         sigfillset(&sig);
 325         pthread_sigmask(SIG_BLOCK, &sig, NULL);
 326         sigprocmask(SIG_BLOCK, &sig, NULL);
 327
 328         f = fopen(file, "r");
 329         if (!f) {
 330                 err = -errno;
 331                 fprintf(stderr, "cnf: failed to open config file '%s': %s.\n", file, strerror(errno));
 332                 goto err_out_exit;
 333         }
 334
 335         buf = malloc(buf_size);
 336         if (!buf) {
 337                 err = -ENOMEM;
 338                 goto err_out_close;
 339         }
 340
 341         dnet_backend_logger.log_level = DNET_LOG_ERROR;
 342         dnet_backend_logger.log = dnet_common_log;
 343         dnet_cfg_state.log = &dnet_backend_logger;
 344
 345         err = dnet_file_backend_init();
 346         if (err)
 347                 goto err_out_free_buf;
 348
 349         err = dnet_eblob_backend_init();
 350         if (err)
 351                 goto err_out_file_exit;
 352
 353 #ifdef HAVE_SMACK_SUPPORT
 354         err = dnet_smack_backend_init();
 355         if (err)
 356                 goto err_out_eblob_exit;
 357 #endif
 358         while (1) {
 359                 ptr = fgets(buf, buf_size, f);
 360                 if (!ptr) {
 361                         if (feof(f))
 362                                 break;
 363
 364                         err = -errno;
 365                         dnet_backend_log(DNET_LOG_ERROR, "cnf: failed to read config file '%s': %s.\n", file, strerror(errno));
 366                         goto err_out_free;
 367                 }
 368
 369                 line_num++;
 370
 371                 ptr = dnet_skip_line(ptr);
 372                 if (!ptr)
 373                         continue;
 374
 375                 len = strlen(ptr);
 376
 377                 if (len > 1) {
 378                         if (ptr[len - 1] == '\r' || ptr[len - 1] == '\n') {
 379                                 ptr[len - 1] = '\0';
 380                                 len--;
 381                         }
 382                 }
 383
 384                 if (len > 2) {
 385                         if (ptr[len - 2] == '\r' || ptr[len - 2] == '\n') {
 386                                 ptr[len - 2] = '\0';
 387                                 len--;
 388                         }
 389                 }
 390
 391                 key = value = NULL;
 392                 err = 0;
 393                 for (i=0; i<len; ++i) {
 394                         if (isspace(ptr[i])) {
 395                                 if (key)
 396                                         ptr[i] = '\0';
 397                                 continue;
 398                         }
 399
 400                         if (!key) {
 401                                 key = ptr + i;
 402                                 continue;
 403                         }
 404
 405                         if (!value) {
 406                                 if (ptr[i] == DNET_CONF_DELIMITER) {
 407                                         value = ptr;
 408                                         ptr[i] = '\0';
 409                                         continue;
 410                                 }
 411
 412                                 if (ptr[i] ==  DNET_CONF_COMMENT) {
 413                                         key = value = NULL;
 414                                         break;
 415                                 }
 416
 417                                 continue;
 418                         } else {
 419                                 value = ptr + i;
 420                                 break;
 421                         }
 422
 423                         key = value = NULL;
 424                         err = -EINVAL;
 425                         fprintf(stderr, "cnf: error in line %d: %s.\n", line_num, ptr);
 426                         goto err_out_free;
 427                 }
 428
 429                 if (err)
 430                         goto err_out_free;
 431                 if (!key || !value)
 432                         continue;
 433
 434                 for (i=0; i<dnet_cur_cfg_size; ++i) {
 435                         if (!strcmp(key, dnet_cur_cfg_entries[i].key)) {
 436                                 err = dnet_cur_cfg_entries[i].callback(dnet_cfg_current_backend, key, value);
 437                                 dnet_backend_log(DNET_LOG_INFO, "backend: %s, key: %s, value: %s, err: %d\n",
 438                                                 (dnet_cfg_current_backend) ? dnet_cfg_current_backend->name : "root level",
 439                                                 ptr, value, err);
 440                                 if (err)
 441                                         goto err_out_free;
 442
 443                                 break;
 444                         }
 445                 }
 446         }
 447
 448         if (!dnet_cfg_current_backend) {
 449                 err = -EINVAL;
 450                 goto err_out_free;
 451         }
 452
 453         if (dnet_daemon_mode && !mon)
 454                 dnet_background();
 455
 456         err = dnet_cfg_current_backend->init(dnet_cfg_current_backend, &dnet_cfg_state);
 457         if (err)
 458                 goto err_out_free;
 459
 460         fclose(f);
 461         f = NULL;
 462
 463         n = dnet_server_node_create(&dnet_cfg_state);
 464         if (!n) {
 465                 /* backend cleanup is already called */
 466                 goto err_out_free;
 467         }
 468
 469         err = dnet_common_add_remote_addr(n, &dnet_cfg_state, dnet_cfg_remotes);
 470         if (err)
 471                 goto err_out_node_destroy;
 472
 473         return n;
 474
 475 err_out_node_destroy:
 476         dnet_server_node_destroy(n);
 477 err_out_free:
 478         free(dnet_cfg_remotes);
 479
 480 #ifdef HAVE_SMACK_SUPPORT
 481         dnet_smack_backend_exit();
 482 err_out_eblob_exit:
 483 #endif
 484         dnet_eblob_backend_exit();
 485 err_out_file_exit:
 486         dnet_file_backend_exit();
 487 err_out_free_buf:
 488         free(buf);
 489 err_out_close:
 490         if (f)
 491                 fclose(f);
 492 err_out_exit:
 493         return NULL;
 494 }
 495
 496 int dnet_backend_check_log_level(int level)
 497 {
 498         struct dnet_log *l = dnet_cfg_state.log;
 499
 500         return (l->log && (l->log_level >= level));
 501 }
 502
 503 void dnet_backend_log_raw(int level, const char *format, ...)
 504 {
 505         va_list args;
 506         char buf[1024];
 507         struct dnet_log *l = dnet_cfg_state.log;
 508         int buflen = sizeof(buf);
 509
 510         if (!l->log || !(l->log_level < level))
 511                 return;
 512
 513         va_start(args, format);
 514         vsnprintf(buf, buflen, format, args);
 515         buf[buflen-1] = '\0';
 516         l->log(l->log_private, level, buf);
 517         va_end(args);
 518 }