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