ctdb/server/ctdb_tunables.c

   1 /*
   2    ctdb tunables code
   3
   4    Copyright (C) Andrew Tridgell  2007
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, see <http://www.gnu.org/licenses/>.
  18 */
  19 #include "replace.h"
  20 #include "system/network.h"
  21
  22 #include <talloc.h>
  23 #include <tdb.h>
  24
  25 #include "lib/util/debug.h"
  26
  27 #include "ctdb_private.h"
  28
  29 #include "common/common.h"
  30 #include "common/logging.h"
  31 #include "common/path.h"
  32 #include "common/tunable.h"
  33
  34 /*
  35   set all tunables to defaults
  36  */
  37 void ctdb_tunables_set_defaults(struct ctdb_context *ctdb)
  38 {
  39         ctdb_tunable_set_defaults(&ctdb->tunable);
  40 }
  41
  42
  43 /*
  44   get a tunable
  45  */
  46 int32_t ctdb_control_get_tunable(struct ctdb_context *ctdb, TDB_DATA indata,
  47                                  TDB_DATA *outdata)
  48 {
  49         struct ctdb_control_get_tunable *t =
  50                 (struct ctdb_control_get_tunable *)indata.dptr;
  51         char *name;
  52         uint32_t val;
  53         bool ret;
  54
  55         if (indata.dsize < sizeof(*t) ||
  56             t->length > indata.dsize - offsetof(struct ctdb_control_get_tunable, name)) {
  57                 DEBUG(DEBUG_ERR,("Bad indata in ctdb_control_get_tunable\n"));
  58                 return -1;
  59         }
  60
  61         name = talloc_strndup(ctdb, (char*)t->name, t->length);
  62         CTDB_NO_MEMORY(ctdb, name);
  63
  64         ret = ctdb_tunable_get_value(&ctdb->tunable, name, &val);
  65         talloc_free(name);
  66         if (! ret) {
  67                 return -EINVAL;
  68         }
  69
  70         outdata->dptr = (uint8_t *)talloc(outdata, uint32_t);
  71         CTDB_NO_MEMORY(ctdb, outdata->dptr);
  72
  73         *(uint32_t *)outdata->dptr = val;
  74         outdata->dsize = sizeof(uint32_t);
  75
  76         return 0;
  77 }
  78
  79
  80 /*
  81   set a tunable
  82  */
  83 int32_t ctdb_control_set_tunable(struct ctdb_context *ctdb, TDB_DATA indata)
  84 {
  85         struct ctdb_tunable_old *t =
  86                 (struct ctdb_tunable_old *)indata.dptr;
  87         char *name;
  88         int ret;
  89         bool obsolete;
  90
  91         if (indata.dsize < sizeof(*t) ||
  92             t->length > indata.dsize - offsetof(struct ctdb_tunable_old, name)) {
  93                 DEBUG(DEBUG_ERR,("Bad indata in ctdb_control_set_tunable\n"));
  94                 return -1;
  95         }
  96
  97         name = talloc_strndup(ctdb, (char *)t->name, t->length);
  98         CTDB_NO_MEMORY(ctdb, name);
  99
 100         ret = ctdb_tunable_set_value(&ctdb->tunable, name, t->value,
 101                                      &obsolete);
 102         if (! ret) {
 103                 talloc_free(name);
 104                 return -1;
 105         }
 106
 107         if (obsolete) {
 108                 DEBUG(DEBUG_WARNING,
 109                       ("Setting obsolete tunable \"%s\"\n", name));
 110                 talloc_free(name);
 111                 return 1;
 112         }
 113
 114         talloc_free(name);
 115         return 0;
 116 }
 117
 118 /*
 119   list tunables
 120  */
 121 int32_t ctdb_control_list_tunables(struct ctdb_context *ctdb, TDB_DATA *outdata)
 122 {
 123         char *list = NULL;
 124         struct ctdb_control_list_tunable *t;
 125
 126         list = ctdb_tunable_names_to_string(outdata);
 127         CTDB_NO_MEMORY(ctdb, list);
 128
 129         outdata->dsize = offsetof(struct ctdb_control_list_tunable, data) +
 130                 strlen(list) + 1;
 131         outdata->dptr = talloc_size(outdata, outdata->dsize);
 132         CTDB_NO_MEMORY(ctdb, outdata->dptr);
 133
 134         t = (struct ctdb_control_list_tunable *)outdata->dptr;
 135         t->length = strlen(list)+1;
 136
 137         memcpy(t->data, list, t->length);
 138         talloc_free(list);
 139
 140         return 0;
 141 }
 142
 143 bool ctdb_tunables_load(struct ctdb_context *ctdb)
 144 {
 145         bool status;
 146         TALLOC_CTX *tmp_ctx;
 147         char *file = NULL;
 148
 149         /* Fail by default */
 150         status = false;
 151
 152         tmp_ctx = talloc_new(ctdb);
 153         if (tmp_ctx == NULL) {
 154                 DBG_ERR("Memory allocation error\n");
 155                 goto done;
 156         }
 157
 158         file = path_etcdir_append(tmp_ctx, "ctdb.tunables");
 159         if (file == NULL) {
 160                 D_ERR("Failed to construct path for ctdb.tunables\n");
 161                 goto done;
 162         }
 163
 164         status = ctdb_tunable_load_file(tmp_ctx, &ctdb->tunable, file);
 165         /* No need to log error, already logged above */
 166
 167 done:
 168         talloc_free(tmp_ctx);
 169         return status;
 170 }