lib/interfaces.o lib/memcache.o \
lib/util_transfer_file.o ../lib/async_req/async_req.o \
../lib/async_req/async_sock.o ../lib/async_req/async_req_ntstatus.o \
+ lib/serverid.o \
$(TDB_LIB_OBJ) \
$(VERSION_OBJ) lib/charcnv.o lib/debug.o lib/fault.o \
lib/interface.o lib/pidfile.o \
#include "../lib/util/talloc_stack.h"
#include "memcache.h"
#include "../lib/async_req/async_req_ntstatus.h"
+#include "serverid.h"
#include "async_smb.h"
#include "../lib/async_req/async_sock.h"
#include "services.h"
#ifdef CLUSTER_SUPPORT
uint32 vnn;
#endif
+ uint64_t unique_id;
};
#ifdef CLUSTER_SUPPORT
pid_t procid_to_pid(const struct server_id *proc);
void set_my_vnn(uint32 vnn);
uint32 get_my_vnn(void);
+void set_my_unique_id(uint64_t unique_id);
struct server_id pid_to_procid(pid_t pid);
struct server_id procid_self(void);
struct server_id server_id_self(void);
--- /dev/null
+/*
+ Unix SMB/CIFS implementation.
+ Implementation of a reliable server_exists()
+ Copyright (C) Volker Lendecke 2010
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __SERVERID_H__
+#define __SERVERID_H__
+
+#include "includes.h"
+
+/*
+ * Register a server with its unique id
+ */
+bool serverid_register(const struct server_id id, uint32_t msg_flags);
+
+/*
+ * De-register a server with its unique id
+ */
+bool serverid_deregister(const struct server_id id);
+
+/*
+ * Check existence of a server id
+ */
+bool serverid_exists(const struct server_id *id);
+
+/*
+ * Walk the list of server_ids registered
+ */
+bool serverid_traverse(int (*fn)(struct db_record *rec,
+ const struct server_id *id,
+ uint32_t msg_flags,
+ void *private_data),
+ void *private_data);
+
+/*
+ * Walk the list of server_ids registered read-only
+ */
+bool serverid_traverse_read(int (*fn)(const struct server_id *id,
+ uint32_t msg_flags,
+ void *private_data),
+ void *private_data);
+#endif
Send one of the messages for the broadcast.
****************************************************************************/
-static int traverse_fn(struct db_record *rec,
- const struct connections_key *ckey,
- const struct connections_data *crec,
- void *state)
+static int traverse_fn(struct db_record *rec, const struct server_id *id,
+ uint32_t msg_flags, void *state)
{
struct msg_all *msg_all = (struct msg_all *)state;
NTSTATUS status;
- if (crec->cnum != -1)
- return 0;
-
/* Don't send if the receiver hasn't registered an interest. */
- if(!(crec->bcast_msg_flags & msg_all->msg_flag))
+ if((msg_flags & msg_all->msg_flag) == 0) {
return 0;
+ }
/* If the msg send fails because the pid was not found (i.e. smbd died),
* the msg has already been deleted from the messages.tdb.*/
- status = messaging_send_buf(msg_all->msg_ctx,
- crec->pid, msg_all->msg_type,
+ status = messaging_send_buf(msg_all->msg_ctx, *id, msg_all->msg_type,
(uint8 *)msg_all->buf, msg_all->len);
if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) {
/* If the pid was not found delete the entry from connections.tdb */
- DEBUG(2,("pid %s doesn't exist - deleting connections %d [%s]\n",
- procid_str_static(&crec->pid), crec->cnum,
- crec->servicename));
+ DEBUG(2, ("pid %s doesn't exist\n", procid_str_static(id)));
rec->delete_rec(rec);
}
msg_all.n_sent = 0;
msg_all.msg_ctx = msg_ctx;
- connections_forall(traverse_fn, &msg_all);
+ serverid_traverse(traverse_fn, &msg_all);
if (n_sent)
*n_sent = msg_all.n_sent;
return True;
--- /dev/null
+/*
+ Unix SMB/CIFS implementation.
+ Implementation of a reliable server_exists()
+ Copyright (C) Volker Lendecke 2010
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "includes.h"
+#include "serverid.h"
+
+struct serverid_key {
+ pid_t pid;
+#ifdef CLUSTER_SUPPORT
+ uint32_t vnn;
+#endif
+};
+
+struct serverid_data {
+ uint64_t unique_id;
+ uint32_t msg_flags;
+};
+
+static struct db_context *serverid_db(void)
+{
+ static struct db_context *db;
+
+ if (db != NULL) {
+ return db;
+ }
+ db = db_open(talloc_autofree_context(), lock_path("serverid.tdb"),
+ 0, TDB_DEFAULT|TDB_CLEAR_IF_FIRST, O_RDWR|O_CREAT, 0644);
+ return db;
+}
+
+static void serverid_fill_key(const struct server_id *id,
+ struct serverid_key *key)
+{
+ ZERO_STRUCTP(key);
+ key->pid = id->pid;
+#ifdef CLUSTER_SUPPORT
+ key->vnn = id->vnn;
+#endif
+}
+
+bool serverid_register(const struct server_id id, uint32_t msg_flags)
+{
+ struct db_context *db;
+ struct serverid_key key;
+ struct serverid_data data;
+ struct db_record *rec;
+ TDB_DATA tdbkey, tdbdata;
+ NTSTATUS status;
+ bool ret = false;
+
+ db = serverid_db();
+ if (db == NULL) {
+ return false;
+ }
+
+ serverid_fill_key(&id, &key);
+ tdbkey = make_tdb_data((uint8_t *)&key, sizeof(key));
+
+ rec = db->fetch_locked(db, talloc_tos(), tdbkey);
+ if (rec == NULL) {
+ DEBUG(1, ("Could not fetch_lock serverid.tdb record\n"));
+ return false;
+ }
+
+ ZERO_STRUCT(data);
+ data.unique_id = id.unique_id;
+ data.msg_flags = msg_flags;
+
+ tdbdata = make_tdb_data((uint8_t *)&data, sizeof(data));
+ status = rec->store(rec, tdbdata, 0);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(1, ("Storing serverid.tdb record failed: %s\n",
+ nt_errstr(status)));
+ goto done;
+ }
+ ret = true;
+done:
+ TALLOC_FREE(rec);
+ return ret;
+}
+
+bool serverid_deregister(const struct server_id id)
+{
+ struct db_context *db;
+ struct serverid_key key;
+ struct db_record *rec;
+ TDB_DATA tdbkey;
+ NTSTATUS status;
+ bool ret = false;
+
+ db = serverid_db();
+ if (db == NULL) {
+ return false;
+ }
+
+ serverid_fill_key(&id, &key);
+ tdbkey = make_tdb_data((uint8_t *)&key, sizeof(key));
+
+ rec = db->fetch_locked(db, talloc_tos(), tdbkey);
+ if (rec == NULL) {
+ DEBUG(1, ("Could not fetch_lock serverid.tdb record\n"));
+ return false;
+ }
+
+ status = rec->delete_rec(rec);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(1, ("Deleting serverid.tdb record failed: %s\n",
+ nt_errstr(status)));
+ goto done;
+ }
+ ret = true;
+done:
+ TALLOC_FREE(rec);
+ return ret;
+}
+
+struct serverid_exists_state {
+ const struct server_id *id;
+ bool exists;
+};
+
+static int server_exists_parse(TDB_DATA key, TDB_DATA data, void *priv)
+{
+ struct serverid_exists_state *state =
+ (struct serverid_exists_state *)priv;
+ uint64_t unique_id;
+
+ if (data.dsize != sizeof(struct serverid_data)) {
+ return -1;
+ }
+
+ /* memcpy, data.dptr might not be aligned */
+ memcpy(&unique_id, data.dptr, sizeof(unique_id));
+
+ state->exists = (state->id->unique_id == unique_id);
+ return 0;
+}
+
+bool serverid_exists(const struct server_id *id)
+{
+ struct db_context *db;
+ struct serverid_exists_state state;
+ struct serverid_key key;
+ TDB_DATA tdbkey;
+
+ db = serverid_db();
+ if (db == NULL) {
+ return false;
+ }
+
+ serverid_fill_key(id, &key);
+ tdbkey = make_tdb_data((uint8_t *)&key, sizeof(key));
+
+ state.id = id;
+ state.exists = false;
+
+ if (db->parse_record(db, tdbkey, server_exists_parse, &state) == -1) {
+ return false;
+ }
+ return state.exists;
+}
+
+static bool serverid_rec_parse(const struct db_record *rec,
+ struct server_id *id, uint32_t *msg_flags)
+{
+ struct serverid_key key;
+ struct serverid_data data;
+
+ if (rec->key.dsize != sizeof(key)) {
+ DEBUG(1, ("Found invalid key length %d in serverid.tdb\n",
+ (int)rec->key.dsize));
+ return false;
+ }
+ if (rec->value.dsize != sizeof(data)) {
+ DEBUG(1, ("Found invalid value length %d in serverid.tdb\n",
+ (int)rec->value.dsize));
+ return false;
+ }
+
+ memcpy(&key, rec->key.dptr, sizeof(key));
+ memcpy(&data, rec->value.dptr, sizeof(data));
+
+ id->pid = key.pid;
+#ifdef CLUSTER_SUPPORT
+ id->vnn = key.vnn;
+#endif
+ id->unique_id = data.unique_id;
+ *msg_flags = data.msg_flags;
+ return true;
+}
+
+struct serverid_traverse_read_state {
+ int (*fn)(const struct server_id *id, uint32_t msg_flags,
+ void *private_data);
+ void *private_data;
+};
+
+static int serverid_traverse_read_fn(struct db_record *rec, void *private_data)
+{
+ struct serverid_traverse_read_state *state =
+ (struct serverid_traverse_read_state *)private_data;
+ struct server_id id;
+ uint32_t msg_flags;
+
+ if (!serverid_rec_parse(rec, &id, &msg_flags)) {
+ return 0;
+ }
+ return state->fn(&id, msg_flags,state->private_data);
+}
+
+bool serverid_traverse_read(int (*fn)(const struct server_id *id,
+ uint32_t msg_flags, void *private_data),
+ void *private_data)
+{
+ struct db_context *db;
+ struct serverid_traverse_read_state state;
+
+ db = serverid_db();
+ if (db == NULL) {
+ return false;
+ }
+ state.fn = fn;
+ state.private_data = private_data;
+ return db->traverse_read(db, serverid_traverse_read_fn, &state);
+}
+
+struct serverid_traverse_state {
+ int (*fn)(struct db_record *rec, const struct server_id *id,
+ uint32_t msg_flags, void *private_data);
+ void *private_data;
+};
+
+static int serverid_traverse_fn(struct db_record *rec, void *private_data)
+{
+ struct serverid_traverse_state *state =
+ (struct serverid_traverse_state *)private_data;
+ struct server_id id;
+ uint32_t msg_flags;
+
+ if (!serverid_rec_parse(rec, &id, &msg_flags)) {
+ return 0;
+ }
+ return state->fn(rec, &id, msg_flags, state->private_data);
+}
+
+bool serverid_traverse(int (*fn)(struct db_record *rec,
+ const struct server_id *id,
+ uint32_t msg_flags, void *private_data),
+ void *private_data)
+{
+ struct db_context *db;
+ struct serverid_traverse_state state;
+
+ db = serverid_db();
+ if (db == NULL) {
+ return false;
+ }
+ state.fn = fn;
+ state.private_data = private_data;
+ return db->traverse(db, serverid_traverse_fn, &state);
+}
return my_vnn;
}
+static uint64_t my_unique_id = 0;
+
+void set_my_unique_id(uint64_t unique_id)
+{
+ my_unique_id = unique_id;
+}
+
struct server_id pid_to_procid(pid_t pid)
{
struct server_id result;
result.pid = pid;
+ result.unique_id = my_unique_id;
#ifdef CLUSTER_SUPPORT
result.vnn = my_vnn;
#endif
if (result.pid < 0) {
result.pid = -1;
}
+ result.unique_id = 0;
return result;
}
for (i = 0; i < *pnum_entries; i++) {
struct lock_struct *lock_data = &locks[i];
- if (!process_exists(lock_data->context.pid)) {
+ if (!serverid_exists(&lock_data->context.pid)) {
/* This process no longer exists - mark this
entry as invalid by zeroing it. */
ZERO_STRUCTP(lock_data);
}
DEBUG(10,("parse_share_modes: %s\n",
str ? str : ""));
- if (!process_exists(entry_p->pid)) {
+ if (!serverid_exists(&entry_p->pid)) {
DEBUG(10,("parse_share_modes: deleted %s\n",
str ? str : ""));
entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
exit(1);
/* get broadcast messages */
- claim_connection(NULL,"",FLAG_MSG_GENERAL|FLAG_MSG_DBWRAP);
+
+ if (!serverid_register(procid_self(),
+ FLAG_MSG_GENERAL|FLAG_MSG_DBWRAP)) {
+ DEBUG(1, ("Could not register myself in serverid.tdb\n"));
+ exit(1);
+ }
messaging_register(nmbd_messaging_context(), NULL,
MSG_FORCE_ELECTION, nmbd_message_election);
/* of course, none of the message callbacks matter if you don't
tell messages.c that you interested in receiving PRINT_GENERAL
- msgs. This is done in claim_connection() */
+ msgs. This is done in serverid_register() */
if ( lp_security() == SEC_ADS ) {
smbd_setup_sig_term_handler();
smbd_setup_sig_hup_handler();
- claim_connection( NULL, "smbd lpq backend",
- FLAG_MSG_GENERAL|FLAG_MSG_SMBD|FLAG_MSG_PRINT_GENERAL);
+ if (!serverid_register(procid_self(),
+ FLAG_MSG_GENERAL|FLAG_MSG_SMBD
+ |FLAG_MSG_PRINT_GENERAL)) {
+ exit(1);
+ }
if (!locking_init()) {
exit(1);
when the client connects to port 445. Of course there is a small
window where we are listening to messages -- jerry */
- claim_connection(
- NULL,"",FLAG_MSG_GENERAL|FLAG_MSG_SMBD|FLAG_MSG_PRINT_GENERAL);
+ serverid_register(procid_self(), FLAG_MSG_GENERAL|FLAG_MSG_SMBD
+ |FLAG_MSG_PRINT_GENERAL);
/* Check for protocols, most desirable first */
for (protocol = 0; supported_protocols[protocol].proto_name; protocol++) {
{
struct child_pid *child;
static struct timed_event *cleanup_te;
+ struct server_id child_id;
if (unclean_shutdown) {
/* a child terminated uncleanly so tickle all
}
}
+ child_id = procid_self(); /* Just initialize pid and potentially vnn */
+ child_id.pid = pid;
+
+ if (!serverid_deregister(child_id)) {
+ DEBUG(1, ("Could not remove pid %d from serverid.tdb\n",
+ (int)pid));
+ }
+
if (lp_max_smbd_processes() == 0) {
/* Don't bother with the child list if we don't care anyway */
return;
struct sockaddr_storage addr;
socklen_t in_addrlen = sizeof(addr);
pid_t pid = 0;
+ uint64_t unique_id;
smbd_set_server_fd(accept(s->fd,(struct sockaddr *)&addr,&in_addrlen));
return;
}
+ /*
+ * Generate a unique id in the parent process so that we use
+ * the global random state in the parent.
+ */
+ generate_random_buffer((uint8_t *)&unique_id, sizeof(unique_id));
+
pid = sys_fork();
if (pid == 0) {
NTSTATUS status = NT_STATUS_OK;
+
/* Child code ... */
am_parent = 0;
+ set_my_unique_id(unique_id);
+
/* Stop zombies, the parent explicitly handles
* them, counting worker smbds. */
CatchChild();
smbd_setup_sig_term_handler();
smbd_setup_sig_hup_handler();
+ if (!serverid_register(procid_self(),
+ FLAG_MSG_GENERAL|FLAG_MSG_SMBD
+ |FLAG_MSG_DBWRAP
+ |FLAG_MSG_PRINT_GENERAL)) {
+ exit_server_cleanly("Could not register myself in "
+ "serverid.tdb");
+ }
+
smbd_process();
exit:
exit_server_cleanly("end of child");
clustered mode, ctdb won't allow us to start doing database
operations until it has gone thru a full startup, which
includes checking to see that smbd is listening. */
- claim_connection(NULL,"",
- FLAG_MSG_GENERAL|FLAG_MSG_SMBD|FLAG_MSG_DBWRAP);
+
+ if (!serverid_register(procid_self(),
+ FLAG_MSG_GENERAL|FLAG_MSG_SMBD
+ |FLAG_MSG_DBWRAP)) {
+ DEBUG(0, ("open_sockets_smbd: Failed to register "
+ "myself in serverid.tdb\n"));
+ return false;
+ }
/* Listen to messages */
}
/* get broadcast messages */
- claim_connection(NULL,"",FLAG_MSG_GENERAL|FLAG_MSG_DBWRAP);
+
+ if (!serverid_register(procid_self(),
+ FLAG_MSG_GENERAL|FLAG_MSG_DBWRAP)) {
+ DEBUG(1, ("Could not register myself in serverid.tdb\n"));
+ exit(1);
+ }
/* React on 'smbcontrol winbindd reload-config' in the same way
as to SIGHUP signal */
bool yield_connection(connection_struct *conn, const char *name);
int count_current_connections( const char *sharename, bool clear );
-int count_all_current_connections(void);
-bool claim_connection(connection_struct *conn, const char *name,
- uint32 msg_flags);
bool register_message_flags(bool doreg, uint32 msg_flags);
/* The following definitions come from winbindd/winbindd.c */
git.samba.org / obnox / samba-ctdb.git / commitdiff