ctdb/server/ctdb_serverids.c

   1 /*
   2    ctdb_control protocol code to manage server ids
   3
   4    Copyright (C) Ronnie Sahlberg 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 "includes.h"
  20 #include "../include/ctdb_private.h"
  21 #include "../common/rb_tree.h"
  22
  23
  24 #define SERVER_ID_KEY_SIZE 3
  25 static uint32_t *get_server_id_key(struct ctdb_server_id *server_id)
  26 {
  27         static uint32_t key[SERVER_ID_KEY_SIZE];
  28
  29         key[0] = server_id->type;
  30         key[1] = server_id->pnn;
  31         key[2] = server_id->server_id;
  32
  33         return &key[0];
  34 }
  35
  36 /* add a server_id to the tree.
  37    if we had already 'data' in the tree then this is a duplicate and we can
  38    just talloc_free the structure in parm and leave data in the tree.
  39    othervise if this is a new node we return parm and that is inserted
  40    into the tree.
  41 */
  42 static void *add_server_id_callback(void *parm, void *data)
  43 {
  44         if (data) {
  45                 talloc_free(parm);
  46                 return data;
  47         }
  48         return parm;
  49 }
  50
  51 /*
  52   register a server id
  53   a serverid that is registered with ctdb will be automatically unregistered
  54   once the client domain socket dissappears.
  55  */
  56 int32_t ctdb_control_register_server_id(struct ctdb_context *ctdb,
  57                                  uint32_t client_id,
  58                                  TDB_DATA indata)
  59 {
  60         struct ctdb_server_id *server_id;
  61         struct ctdb_client *client = ctdb_reqid_find(ctdb, client_id, struct ctdb_client);
  62
  63
  64         if (client == NULL) {
  65                 DEBUG(DEBUG_ERR,(__location__ " Could not find client parent structure. You can not send this control to a remote node\n"));
  66                 return 1;
  67         }
  68
  69         /* hang the server_id structure off client before storing it in the
  70            tree so that is will be automatically destroyed when client
  71            is destroyed.
  72            when the structure is free'd it will be automatically
  73            removed from the tree
  74         */
  75         server_id = talloc_zero(client, struct ctdb_server_id);
  76         CTDB_NO_MEMORY(ctdb, server_id);
  77         memcpy(server_id, indata.dptr, sizeof(struct ctdb_server_id));
  78
  79         trbt_insertarray32_callback(ctdb->server_ids, SERVER_ID_KEY_SIZE,
  80                 get_server_id_key(server_id),
  81                 add_server_id_callback, server_id);
  82
  83         return 0;
  84 }
  85
  86
  87 /*
  88   check whether a server id exists
  89  */
  90 int32_t ctdb_control_check_server_id(struct ctdb_context *ctdb,
  91                                  TDB_DATA indata)
  92 {
  93         struct ctdb_server_id *server_id = (struct ctdb_server_id *)indata.dptr;
  94
  95         return trbt_lookuparray32(ctdb->server_ids,
  96                                   SERVER_ID_KEY_SIZE,
  97                                   get_server_id_key(server_id)) == NULL? 0 : 1;
  98 }
  99
 100 /*
 101   unregisters a server id
 102  */
 103 int32_t ctdb_control_unregister_server_id(struct ctdb_context *ctdb,
 104                                  TDB_DATA indata)
 105 {
 106         struct ctdb_server_id *server_id = (struct ctdb_server_id *)indata.dptr;
 107
 108         talloc_free(trbt_lookuparray32(ctdb->server_ids,
 109                         SERVER_ID_KEY_SIZE,
 110                         get_server_id_key(server_id)));
 111         return 0;
 112 }
 113
 114
 115
 116
 117 struct count_server_ids {
 118         int count;
 119         struct ctdb_server_id_list *list;
 120 };
 121
 122 static int server_id_count(void *param, void *data)
 123 {
 124         struct count_server_ids *svid = talloc_get_type(param,
 125                                                 struct count_server_ids);
 126
 127         if (svid == NULL) {
 128                 DEBUG(DEBUG_ERR, (__location__ " Got null pointer for svid\n"));
 129                 return -1;
 130         }
 131
 132         svid->count++;
 133         return 0;
 134 }
 135
 136 static int server_id_store(void *param, void *data)
 137 {
 138         struct count_server_ids *svid = talloc_get_type(param,
 139                                                 struct count_server_ids);
 140         struct ctdb_server_id *server_id = talloc_get_type(data,
 141                                                 struct ctdb_server_id);
 142
 143         if (svid == NULL) {
 144                 DEBUG(DEBUG_ERR, (__location__ " Got null pointer for svid\n"));
 145                 return -1;
 146         }
 147
 148         if (svid->count >= svid->list->num) {
 149                 DEBUG(DEBUG_ERR, (__location__ " size of server id tree changed during traverse\n"));
 150                 return -1;
 151         }
 152
 153         memcpy(&svid->list->server_ids[svid->count], server_id, sizeof(struct ctdb_server_id));
 154         svid->count++;
 155         return 0;
 156 }
 157
 158 /*
 159    returns a list of all registered server ids for a node
 160 */
 161 int32_t ctdb_control_get_server_id_list(struct ctdb_context *ctdb, TDB_DATA *outdata)
 162 {
 163         struct count_server_ids *svid;
 164
 165
 166         svid = talloc_zero(outdata, struct count_server_ids);
 167         CTDB_NO_MEMORY(ctdb, svid);
 168
 169
 170         /* first we must count how many entries we have */
 171         trbt_traversearray32(ctdb->server_ids, SERVER_ID_KEY_SIZE,
 172                         server_id_count, svid);
 173
 174
 175         outdata->dsize = offsetof(struct ctdb_server_id_list,
 176                                 server_ids)
 177                         + sizeof(struct ctdb_server_id) * svid->count;
 178         outdata->dptr  = talloc_size(outdata, outdata->dsize);
 179         CTDB_NO_MEMORY(ctdb, outdata->dptr);
 180
 181
 182         /* now fill the structure in */
 183         svid->list = (struct ctdb_server_id_list *)(outdata->dptr);
 184         svid->list->num = svid->count;
 185         svid->count=0;
 186         trbt_traversearray32(ctdb->server_ids, SERVER_ID_KEY_SIZE,
 187                         server_id_store, svid);
 188
 189
 190         return 0;
 191 }