e782091eec229967b43cef776b96c6bf65385401
[kai/samba-autobuild/.git] / source4 / cluster / ctdb / ctdb_cluster.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    ctdb clustering hooks
5
6    Copyright (C) Andrew Tridgell 2006
7    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "lib/events/events.h"
24 #include "cluster/cluster.h"
25 #include "system/filesys.h"
26 #include "cluster/cluster_private.h"
27 #include "../tdb/include/tdb.h"
28 #include "include/ctdb.h"
29 #include "tdb_wrap.h"
30 #include "lib/util/dlinklist.h"
31 #include "param/param.h"
32 #include "librpc/gen_ndr/misc.h"
33
34 /* a linked list of messaging handlers, allowing incoming messages
35    to be directed to the right messaging context */
36 struct cluster_messaging_list {
37         struct cluster_messaging_list *next, *prev;
38         struct cluster_state *state;
39         struct messaging_context *msg;
40         struct server_id server;
41         cluster_message_fn_t handler;
42 };
43
44 struct cluster_state {
45         struct ctdb_context *ctdb;
46         struct cluster_messaging_list *list;
47         uint32_t vnn;
48 };
49
50
51
52 /*
53   return a server_id for a ctdb node
54 */
55 static struct server_id ctdb_id(struct cluster_ops *ops, uint64_t id, uint32_t id2)
56 {
57         struct cluster_state *state = (struct cluster_state *)ops->private;
58         struct ctdb_context *ctdb = state->ctdb;
59         struct server_id server_id;
60         server_id.node = ctdb_get_vnn(ctdb);
61         server_id.id = id;
62         server_id.id2 = id2;
63         return server_id;
64 }
65
66
67 /*
68   return a server_id as a string
69 */
70 static const char *ctdb_id_string(struct cluster_ops *ops, 
71                                   TALLOC_CTX *mem_ctx, struct server_id id)
72 {
73         return talloc_asprintf(mem_ctx, "%u.%llu.%u", id.node, (unsigned long long)id.id, id.id2);
74 }
75
76 /*
77   this is an interim method for subsystems that have not yet been
78   converted to use the ctdb api. It opens a shared database in the
79   cluster temporary area, using TDB_CLEAR_IF_FIRST which relies on
80   correct operation of fcntl locks on the shared fileystem.
81 */
82 static struct tdb_wrap *ctdb_tdb_tmp_open(struct cluster_ops *ops,
83                                           TALLOC_CTX *mem_ctx, 
84                                           struct loadparm_context *lp_ctx,
85                                           const char *dbname, int flags)
86 {
87         const char *dir = lp_parm_string(lp_ctx, NULL, "ctdb", "shared data");
88         char *path;
89         struct tdb_wrap *w;
90         if (dir == NULL) {
91                 DEBUG(0,("ERROR: You must set 'ctdb:shared data' to a cluster shared path\n"));
92                 return NULL;
93         }
94         path = talloc_asprintf(mem_ctx, "%s/%s", dir, dbname);
95         w = tdb_wrap_open(mem_ctx, path, 0,  
96                           flags | TDB_CLEAR_IF_FIRST,
97                           O_RDWR|O_CREAT, 0600);
98         talloc_free(path);
99         return w;
100 }
101
102 /*
103   get at the ctdb handle
104 */
105 static void *ctdb_backend_handle(struct cluster_ops *ops)
106 {
107         struct cluster_state *state = (struct cluster_state *)ops->private;
108         return (void *)state->ctdb;
109 }
110
111 struct ctdb_handler_state {
112         struct cluster_state *state;
113         cluster_message_fn_t handler;
114         struct messaging_context *msg;
115 };
116
117 /*
118   dispatch incoming ctdb messages
119 */
120 static void ctdb_message_handler(struct ctdb_context *ctdb, uint64_t srvid, 
121                                  TDB_DATA data, void *private)
122 {
123         struct ctdb_handler_state *s = talloc_get_type(private, 
124                                                        struct ctdb_handler_state);
125         DATA_BLOB blob;
126         blob.data = data.dptr;
127         blob.length = data.dsize;
128         s->handler(s->msg, blob);
129 }
130
131 static int ctdb_handler_destructor(struct ctdb_handler_state *s)
132 {
133         /* XXX - tell ctdb to de-register the message handler */
134         return 0;
135 }
136
137 /*
138   setup a handler for ctdb messages
139 */
140 static NTSTATUS ctdb_message_init(struct cluster_ops *ops,
141                                   struct messaging_context *msg, 
142                                   struct server_id server,
143                                   cluster_message_fn_t handler)
144 {
145         struct cluster_state *state = (struct cluster_state *)ops->private;
146         struct ctdb_handler_state *h;
147         int ret;
148
149         h = talloc(msg, struct ctdb_handler_state);
150         NT_STATUS_HAVE_NO_MEMORY(h);
151
152         h->state = state;
153         h->handler = handler;
154         h->msg = msg;
155
156         talloc_set_destructor(h, ctdb_handler_destructor);
157
158         /* setup a message handler */
159         ret = ctdb_set_message_handler(state->ctdb, server.id, 
160                                        ctdb_message_handler, h);
161         if (ret == -1) {
162                 DEBUG(0,("ctdb_set_message_handler failed - %s\n", 
163                          ctdb_errstr(state->ctdb)));
164                 exit(1);
165         }
166
167         return NT_STATUS_OK;
168 }
169
170 /*
171   send a ctdb message to another node
172 */
173 static NTSTATUS ctdb_message_send(struct cluster_ops *ops,
174                                   struct server_id server, DATA_BLOB *data)
175 {
176         struct cluster_state *state = (struct cluster_state *)ops->private;
177         struct ctdb_context *ctdb = state->ctdb;
178         TDB_DATA tdata;
179         int ret;
180
181         tdata.dptr = data->data;
182         tdata.dsize = data->length;
183
184         ret = ctdb_send_message(ctdb, server.node, server.id, tdata);
185         if (ret != 0) {
186                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
187         }
188         return NT_STATUS_OK;
189 }
190
191 static struct cluster_ops cluster_ctdb_ops = {
192         .cluster_id           = ctdb_id,
193         .cluster_id_string    = ctdb_id_string,
194         .cluster_tdb_tmp_open = ctdb_tdb_tmp_open,
195         .backend_handle       = ctdb_backend_handle,
196         .message_init         = ctdb_message_init,
197         .message_send         = ctdb_message_send,
198         .private           = NULL
199 };
200
201 /* initialise ctdb */
202 void cluster_ctdb_init(struct loadparm_context *lp_ctx, 
203                        struct event_context *ev, const char *model)
204 {
205         struct cluster_state *state;
206         int ret;
207
208         if (!lp_parm_bool(lp_ctx, NULL, "ctdb", "enable", false)) {
209                 return;
210         }
211
212         state = talloc(ev, struct cluster_state);
213         if (state == NULL) goto failed;
214
215         state->ctdb = ctdb_init(ev);
216         if (state->ctdb == NULL) goto failed;
217
218         ret = ctdb_socket_connect(state->ctdb);
219         if (ret == -1) {
220                 DEBUG(0,(__location__ " Failed to connect to ctdb socket\n"));
221                 goto failed;
222         }
223
224         /* get our vnn */
225         state->vnn = ctdb_ctrl_getvnn(state->ctdb, timeval_zero(), CTDB_CURRENT_NODE);
226         if (state->vnn == (uint32_t)-1) {
227                 DEBUG(0,(__location__ " Failed to get ctdb vnn\n"));
228                 goto failed;
229         }
230
231         state->list = NULL;
232
233         cluster_ctdb_ops.private = state;
234
235         cluster_set_ops(&cluster_ctdb_ops);
236
237 #if 0
238         /* nasty hack for now ... */
239         {
240                 void brl_ctdb_init_ops(void);
241                 brl_ctdb_init_ops();
242         }
243 #endif
244
245         return;
246         
247 failed:
248         DEBUG(0,("cluster_ctdb_init failed\n"));
249         talloc_free(state);
250 }