4 Copyright (C) Andrew Tridgell 2006
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.
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.
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/>.
21 #include "system/filesys.h"
22 #include "system/time.h"
23 #include "system/wait.h"
24 #include "system/network.h"
25 #include "system/syslog.h"
29 /* Allow use of deprecated function tevent_loop_allow_nesting() */
30 #define TEVENT_DEPRECATED
33 #include "lib/util/debug.h"
34 #include "lib/util/samba_util.h"
36 #include "ctdb_private.h"
38 #include "common/reqid.h"
39 #include "common/system.h"
40 #include "common/common.h"
41 #include "common/logging.h"
44 const char *debuglevel
;
45 const char *transport
;
46 const char *myaddress
;
48 const char *recovery_lock
;
50 const char *db_dir_persistent
;
51 const char *db_dir_state
;
53 int start_as_disabled
;
58 int max_persistent_check_errors
;
60 .debuglevel
= "NOTICE",
62 .logging
= "file:" LOGDIR
"/log.ctdb",
63 .db_dir
= CTDB_VARDIR
"/volatile",
64 .db_dir_persistent
= CTDB_VARDIR
"/persistent",
65 .db_dir_state
= CTDB_VARDIR
"/state",
66 .script_log_level
= DEBUG_ERR
,
73 called by the transport layer when a packet comes in
75 static void ctdb_recv_pkt(struct ctdb_context
*ctdb
, uint8_t *data
, uint32_t length
)
77 struct ctdb_req_header
*hdr
= (struct ctdb_req_header
*)data
;
79 CTDB_INCREMENT_STAT(ctdb
, node_packets_recv
);
81 /* up the counter for this source node, so we know its alive */
82 if (ctdb_validate_pnn(ctdb
, hdr
->srcnode
)) {
83 /* as a special case, redirected calls don't increment the rx_cnt */
84 if (hdr
->operation
!= CTDB_REQ_CALL
||
85 ((struct ctdb_req_call_old
*)hdr
)->hopcount
== 0) {
86 ctdb
->nodes
[hdr
->srcnode
]->rx_cnt
++;
90 ctdb_input_pkt(ctdb
, hdr
);
93 static const struct ctdb_upcalls ctdb_upcalls
= {
94 .recv_pkt
= ctdb_recv_pkt
,
95 .node_dead
= ctdb_node_dead
,
96 .node_connected
= ctdb_node_connected
99 static struct ctdb_context
*ctdb_init(struct tevent_context
*ev
)
102 struct ctdb_context
*ctdb
;
104 ctdb
= talloc_zero(ev
, struct ctdb_context
);
106 DBG_ERR("Memory error\n");
111 /* Wrap early to exercise code. */
112 ret
= reqid_init(ctdb
, INT_MAX
-200, &ctdb
->idr
);
114 D_ERR("reqid_init failed (%s)\n", strerror(ret
));
119 ret
= srvid_init(ctdb
, &ctdb
->srv
);
121 D_ERR("srvid_init failed (%s)\n", strerror(ret
));
126 ret
= ctdb_set_socketname(ctdb
, CTDB_SOCKET
);
128 DBG_ERR("ctdb_set_socketname failed.\n");
133 gettimeofday(&ctdb
->ctdbd_start_time
, NULL
);
135 gettimeofday(&ctdb
->last_recovery_started
, NULL
);
136 gettimeofday(&ctdb
->last_recovery_finished
, NULL
);
138 ctdb
->recovery_mode
= CTDB_RECOVERY_NORMAL
;
139 ctdb
->recovery_master
= (uint32_t)-1;
141 ctdb
->upcalls
= &ctdb_upcalls
;
143 ctdb
->statistics
.statistics_start_time
= timeval_current();
145 ctdb
->capabilities
= CTDB_CAP_DEFAULT
;
148 * Initialise this node's PNN to the unknown value. This will
149 * be set to the correct value by either ctdb_add_node() as
150 * part of loading the nodes file or by
151 * ctdb_tcp_listen_automatic() when the transport is
152 * initialised. At some point we should de-optimise this and
153 * pull it out into ctdb_start_daemon() so it is done clearly
154 * and only in one place.
156 ctdb
->pnn
= CTDB_UNKNOWN_PNN
;
158 ctdb
->do_checkpublicip
= true;
167 int main(int argc
, const char *argv
[])
169 struct ctdb_context
*ctdb
= NULL
;
171 const char *ctdb_socket
;
173 struct poptOption popt_options
[] = {
175 { "debug", 'd', POPT_ARG_STRING
, &options
.debuglevel
, 0, "debug level", NULL
},
176 { "interactive", 'i', POPT_ARG_NONE
, &interactive
, 0, "don't fork", NULL
},
177 { "logging", 0, POPT_ARG_STRING
, &options
.logging
, 0, "logging method to be used", NULL
},
178 { "listen", 0, POPT_ARG_STRING
, &options
.myaddress
, 0, "address to listen on", "address" },
179 { "transport", 0, POPT_ARG_STRING
, &options
.transport
, 0, "protocol transport", NULL
},
180 { "dbdir", 0, POPT_ARG_STRING
, &options
.db_dir
, 0, "directory for the tdb files", NULL
},
181 { "dbdir-persistent", 0, POPT_ARG_STRING
, &options
.db_dir_persistent
, 0, "directory for persistent tdb files", NULL
},
182 { "dbdir-state", 0, POPT_ARG_STRING
, &options
.db_dir_state
, 0, "directory for internal state tdb files", NULL
},
183 { "reclock", 0, POPT_ARG_STRING
, &options
.recovery_lock
, 0, "recovery lock", "lock" },
184 { "nosetsched", 0, POPT_ARG_NONE
, &options
.nosetsched
, 0, "disable setscheduler SCHED_FIFO call, use mmap for tdbs", NULL
},
185 { "start-as-disabled", 0, POPT_ARG_NONE
, &options
.start_as_disabled
, 0, "Node starts in disabled state", NULL
},
186 { "start-as-stopped", 0, POPT_ARG_NONE
, &options
.start_as_stopped
, 0, "Node starts in stopped state", NULL
},
187 { "no-lmaster", 0, POPT_ARG_NONE
, &options
.no_lmaster
, 0, "disable lmaster role on this node", NULL
},
188 { "no-recmaster", 0, POPT_ARG_NONE
, &options
.no_recmaster
, 0, "disable recmaster role on this node", NULL
},
189 { "script-log-level", 0, POPT_ARG_INT
, &options
.script_log_level
, 0, "log level of event script output", NULL
},
190 { "max-persistent-check-errors", 0, POPT_ARG_INT
,
191 &options
.max_persistent_check_errors
, 0,
192 "max allowed persistent check errors (default 0)", NULL
},
196 const char **extra_argv
;
198 struct tevent_context
*ev
;
199 const char *ctdb_base
;
206 talloc_enable_null_tracking();
210 ev
= tevent_context_init(NULL
);
212 fprintf(stderr
, "tevent_context_init() failed\n");
215 tevent_loop_allow_nesting(ev
);
217 ctdb
= ctdb_init(ev
);
219 fprintf(stderr
, "Failed to init ctdb\n");
223 /* Default value for CTDB_BASE - don't override */
224 setenv("CTDB_BASE", CTDB_ETCDIR
, 0);
225 ctdb_base
= getenv("CTDB_BASE");
226 if (ctdb_base
== NULL
) {
227 D_ERR("CTDB_BASE not set\n");
232 * Command-line option handling
235 pc
= poptGetContext(argv
[0], argc
, argv
, popt_options
, POPT_CONTEXT_KEEP_FIRST
);
237 while ((opt
= poptGetNextOpt(pc
)) != -1) {
240 fprintf(stderr
, "Invalid option %s: %s\n",
241 poptBadOption(pc
, 0), poptStrerror(opt
));
246 /* If there are extra arguments then exit with usage message */
247 extra_argv
= poptGetArgs(pc
);
251 poptPrintHelp(pc
, stdout
, 0);
257 * Logging setup/options
260 /* Log to stderr when running as interactive */
262 options
.logging
= "file:";
265 if (strcmp(options
.logging
, "syslog") != 0) {
266 /* This can help when CTDB logging is misconfigured */
267 syslog(LOG_DAEMON
|LOG_NOTICE
,
268 "CTDB logging to location %s",
272 /* Initialize logging and set the debug level */
273 if (!ctdb_logging_init(ctdb
, options
.logging
, options
.debuglevel
)) {
276 setenv("CTDB_LOGGING", options
.logging
, 1);
277 setenv("CTDB_DEBUGLEVEL", debug_level_to_string(DEBUGLEVEL
), 1);
279 script_log_level
= options
.script_log_level
;
281 D_NOTICE("CTDB starting on node\n");
284 * Cluster setup/options
287 ret
= ctdb_set_transport(ctdb
, options
.transport
);
289 D_ERR("ctdb_set_transport failed - %s\n", ctdb_errstr(ctdb
));
293 if (options
.recovery_lock
== NULL
) {
294 D_WARNING("Recovery lock not set\n");
296 ctdb
->recovery_lock
= options
.recovery_lock
;
298 /* tell ctdb what address to listen on */
299 if (options
.myaddress
) {
300 ret
= ctdb_set_address(ctdb
, options
.myaddress
);
302 D_ERR("ctdb_set_address failed - %s\n",
308 /* tell ctdb what nodes are available */
309 ctdb
->nodes_file
= talloc_asprintf(ctdb
, "%s/nodes", ctdb_base
);
310 if (ctdb
->nodes_file
== NULL
) {
311 DBG_ERR(" Out of memory\n");
314 ctdb_load_nodes_file(ctdb
);
317 * Database setup/options
320 ctdb
->db_directory
= options
.db_dir
;
321 mkdir_p_or_die(ctdb
->db_directory
, 0700);
323 ctdb
->db_directory_persistent
= options
.db_dir_persistent
;
324 mkdir_p_or_die(ctdb
->db_directory_persistent
, 0700);
326 ctdb
->db_directory_state
= options
.db_dir_state
;
327 mkdir_p_or_die(ctdb
->db_directory_state
, 0700);
329 if (options
.max_persistent_check_errors
< 0) {
330 ctdb
->max_persistent_check_errors
= 0xFFFFFFFFFFFFFFFFLL
;
332 ctdb
->max_persistent_check_errors
=
333 (uint64_t)options
.max_persistent_check_errors
;
337 * Legacy setup/options
340 ctdb
->start_as_disabled
= options
.start_as_disabled
;
341 ctdb
->start_as_stopped
= options
.start_as_stopped
;
343 /* set ctdbd capabilities */
344 if (options
.no_lmaster
!= 0) {
345 ctdb
->capabilities
&= ~CTDB_CAP_LMASTER
;
347 if (options
.no_recmaster
!= 0) {
348 ctdb
->capabilities
&= ~CTDB_CAP_RECMASTER
;
351 ctdb
->do_setsched
= (options
.nosetsched
!= 1);
354 * Miscellaneous setup
357 ctdb_tunables_set_defaults(ctdb
);
359 ctdb
->event_script_dir
= talloc_asprintf(ctdb
,
362 if (ctdb
->event_script_dir
== NULL
) {
363 DBG_ERR("Out of memory\n");
367 ctdb
->notification_script
= talloc_asprintf(ctdb
,
370 if (ctdb
->notification_script
== NULL
) {
371 D_ERR("Unable to set notification script\n");
376 * Testing and debug options
379 /* Environment variable overrides default */
380 ctdbd_pidfile
= getenv("CTDB_PIDFILE");
381 if (ctdbd_pidfile
== NULL
) {
382 ctdbd_pidfile
= CTDB_RUNDIR
"/ctdbd.pid";
385 /* Environment variable overrides default */
386 ctdb_socket
= getenv("CTDB_SOCKET");
387 if (ctdb_socket
== NULL
) {
388 ctdb_socket
= CTDB_SOCKET
;
390 ret
= ctdb_set_socketname(ctdb
, ctdb_socket
);
392 D_ERR("ctdb_set_socketname() failed\n");
396 t
= getenv("CTDB_TEST_MODE");
398 ctdb
->do_setsched
= false;
399 ctdb
->do_checkpublicip
= false;
403 /* start the protocol running (as a child) */
404 return ctdb_start_daemon(ctdb
, interactive
?false:true);