sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2024-12-23 17:34:34 +03:00
Code

messaging_dgm: Don't expose the messaging_dgm_context

Browse Source 
Right now we can only support one messaging_dgm_context per process
anyway, the code has checks for this. I would like to keep it that
way, in the future we will have multiple messaging_context's or
imessaging_context's filtering based upon the dst server_id.

Why this change? messaging_dgm's lockfile contains the
serverid->unique_id. When designing messaging_dgm, I had in mind to
remove the serverid.tdb and replace it with the dgm lockfiles for server
lookup and enumeration. I have a WIP-patchset that gets rid of almost
all users of serverid.tdb. The problem is serverid_exists. Here we don't
have a messaging_context available, and it would be pretty intrusive
to make it so. This problem has plagued us since ctdb was developed,
see for example the comment

/*
 * This is a Samba3 hack/optimization. Routines like process_exists need to
 * talk to ctdbd, and they don't get handed a messaging context.
 */

in messaging_ctdb.c. This patchset removes this problem in a radical way:
Treat the messaging_dgm context as one globally available structure and
be done with it. The ctdb socket could go the same way in the future.

Signed-off-by: Volker Lendecke <vl@samba.org>
Reviewed-by: Stefan Metzmacher <metze@samba.org>

Autobuild-User(master): Stefan Metzmacher <metze@samba.org>
Autobuild-Date(master): Sun Sep 14 16:29:30 CEST 2014 on sn-devel-104
This commit is contained in:
Volker Lendecke 2014-09-10 16:13:18 +02:00 committed by Stefan Metzmacher
parent 9269a8e5d4
commit 7bc2e2d0d4
3 changed files with 59 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
source3/lib/messages.c
View File

@ -73,8 +73,6 @@ struct messaging_context {
struct tevent_req **waiters;
unsigned num_waiters;
struct messaging_dgm_context *local;
struct messaging_backend *remote;
};
@ -240,6 +238,12 @@ static void messaging_recv_cb(const uint8_t *msg, size_t msg_len,
messaging_dispatch_rec(msg_ctx, &rec);
}
static int messaging_context_destructor(struct messaging_context *ctx)
{
messaging_dgm_destroy();
return 0;
}
struct messaging_context *messaging_init(TALLOC_CTX *mem_ctx,
struct tevent_context *ev)
{
@ -256,9 +260,9 @@ struct messaging_context *messaging_init(TALLOC_CTX *mem_ctx,
sec_init();
ret = messaging_dgm_init(ctx, ctx->event_ctx, ctx->id,
ret = messaging_dgm_init(ctx->event_ctx, ctx->id,
lp_cache_directory(), sec_initial_uid(),
messaging_recv_cb, ctx, &ctx->local);
messaging_recv_cb, ctx);
if (ret != 0) {
DEBUG(2, ("messaging_dgm_init failed: %s\n", strerror(ret)));
@ -266,6 +270,8 @@ struct messaging_context *messaging_init(TALLOC_CTX *mem_ctx,
return NULL;
}
talloc_set_destructor(ctx, messaging_context_destructor);
if (lp_clustering()) {
status = messaging_ctdbd_init(ctx, ctx, &ctx->remote);
@ -302,14 +308,13 @@ NTSTATUS messaging_reinit(struct messaging_context *msg_ctx)
NTSTATUS status;
int ret;
TALLOC_FREE(msg_ctx->local);
messaging_dgm_destroy();
msg_ctx->id = procid_self();
ret = messaging_dgm_init(msg_ctx, msg_ctx->event_ctx, msg_ctx->id,
ret = messaging_dgm_init(msg_ctx->event_ctx, msg_ctx->id,
lp_cache_directory(), sec_initial_uid(),
messaging_recv_cb, msg_ctx,
&msg_ctx->local);
messaging_recv_cb, msg_ctx);
if (ret != 0) {
DEBUG(0, ("messaging_dgm_init failed: %s\n", strerror(errno)));
return map_nt_error_from_unix(ret);
@ -480,7 +485,7 @@ NTSTATUS messaging_send_iov(struct messaging_context *msg_ctx,
memcpy(&iov2[1], iov, iovlen * sizeof(*iov));
become_root();
ret = messaging_dgm_send(msg_ctx->local, server.pid, iov2, iovlen+1);
ret = messaging_dgm_send(server.pid, iov2, iovlen+1);
unbecome_root();
if (ret != 0) {
@ -549,7 +554,7 @@ struct tevent_req *messaging_filtered_read_send(
tevent_req_defer_callback(req, state->ev);
state->tevent_handle = messaging_dgm_register_tevent_context(
state, msg_ctx->local, ev);
state, ev);
if (tevent_req_nomem(state, req)) {
return tevent_req_post(req, ev);
}
@ -908,11 +913,9 @@ bool messaging_parent_dgm_cleanup_init(struct messaging_context *msg)
static int mess_parent_dgm_cleanup(void *private_data)
{
struct messaging_context *msg_ctx = talloc_get_type_abort(
private_data, struct messaging_context);
int ret;
ret = messaging_dgm_wipe(msg_ctx->local);
ret = messaging_dgm_wipe();
DEBUG(10, ("messaging_dgm_wipe returned %s\n",
ret ? strerror(ret) : "ok"));
return lp_parm_int(-1, "messaging", "messaging dgm cleanup interval",
@ -946,9 +949,9 @@ int messaging_cleanup(struct messaging_context *msg_ctx, pid_t pid)
int ret;
if (pid == 0) {
ret = messaging_dgm_wipe(msg_ctx->local);
ret = messaging_dgm_wipe();
} else {
ret = messaging_dgm_cleanup(msg_ctx->local, pid);
ret = messaging_dgm_cleanup(pid);
}
return ret;

47
source3/lib/messages_dgm.c
View File

@ -50,6 +50,8 @@ struct messaging_dgm_context {
bool *have_dgm_context;
};
static struct messaging_dgm_context *global_dgm_context;
static void messaging_dgm_recv(struct unix_msg_ctx *ctx,
uint8_t *msg, size_t msg_len,
void *private_data);
@ -170,16 +172,14 @@ static int messaging_dgm_lockfile_remove(const char *cache_dir, pid_t pid)
return ret;
}
int messaging_dgm_init(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
int messaging_dgm_init(struct tevent_context *ev,
struct server_id pid,
const char *cache_dir,
uid_t dir_owner,
void (*recv_cb)(const uint8_t *msg,
size_t msg_len,
void *private_data),
void *recv_cb_private_data,
struct messaging_dgm_context **pctx)
void *recv_cb_private_data)
{
struct messaging_dgm_context *ctx;
int ret;
@ -194,7 +194,7 @@ int messaging_dgm_init(TALLOC_CTX *mem_ctx,
return EEXIST;
}
ctx = talloc_zero(mem_ctx, struct messaging_dgm_context);
ctx = talloc_zero(NULL, struct messaging_dgm_context);
if (ctx == NULL) {
goto fail_nomem;
}
@ -263,7 +263,7 @@ int messaging_dgm_init(TALLOC_CTX *mem_ctx,
ctx->have_dgm_context = &have_dgm_context;
*pctx = ctx;
global_dgm_context = ctx;
return 0;
fail_nomem:
@ -291,13 +291,22 @@ static int messaging_dgm_context_destructor(struct messaging_dgm_context *c)
return 0;
}
int messaging_dgm_send(struct messaging_dgm_context *ctx, pid_t pid,
const struct iovec *iov, int iovlen)
void messaging_dgm_destroy(void)
{
TALLOC_FREE(global_dgm_context);
}
int messaging_dgm_send(pid_t pid, const struct iovec *iov, int iovlen)
{
struct messaging_dgm_context *ctx = global_dgm_context;
struct sockaddr_un dst;
ssize_t dst_pathlen;
int ret;
if (ctx == NULL) {
return ENOTCONN;
}
dst = (struct sockaddr_un) { .sun_family = AF_UNIX };
dst_pathlen = snprintf(dst.sun_path, sizeof(dst.sun_path),
@ -323,12 +332,17 @@ static void messaging_dgm_recv(struct unix_msg_ctx *ctx,
dgm_ctx->recv_cb(msg, msg_len, dgm_ctx->recv_cb_private_data);
}
int messaging_dgm_cleanup(struct messaging_dgm_context *ctx, pid_t pid)
int messaging_dgm_cleanup(pid_t pid)
{
struct messaging_dgm_context *ctx = global_dgm_context;
struct sun_path_buf lockfile_name, socket_name;
int fd, ret;
struct flock lck = {};
if (ctx == NULL) {
return ENOTCONN;
}
ret = messaging_dgm_lockfile_name(&lockfile_name, ctx->cache_dir.buf,
pid);
if (ret != 0) {
@ -369,14 +383,19 @@ int messaging_dgm_cleanup(struct messaging_dgm_context *ctx, pid_t pid)
return 0;
}
int messaging_dgm_wipe(struct messaging_dgm_context *ctx)
int messaging_dgm_wipe(void)
{
struct messaging_dgm_context *ctx = global_dgm_context;
struct sun_path_buf msgdir_name;
DIR *msgdir;
struct dirent *dp;
pid_t our_pid = getpid();
int ret;
if (ctx == NULL) {
return ENOTCONN;
}
/*
* We scan the socket directory and not the lock directory. Otherwise
* we would race against messaging_dgm_lockfile_create's open(O_CREAT)
@ -413,7 +432,7 @@ int messaging_dgm_wipe(struct messaging_dgm_context *ctx)
continue;
}
ret = messaging_dgm_cleanup(ctx, pid);
ret = messaging_dgm_cleanup(pid);
DEBUG(10, ("messaging_dgm_cleanup(%lu) returned %s\n",
pid, ret ? strerror(ret) : "ok"));
}
@ -423,8 +442,12 @@ int messaging_dgm_wipe(struct messaging_dgm_context *ctx)
}
void *messaging_dgm_register_tevent_context(TALLOC_CTX *mem_ctx,
struct messaging_dgm_context *ctx,
struct tevent_context *ev)
{
struct messaging_dgm_context *ctx = global_dgm_context;
if (ctx == NULL) {
return NULL;
}
return poll_funcs_tevent_register(mem_ctx, ctx->msg_callbacks, ev);
}

16
source3/lib/messages_dgm.h
View File

@ -20,23 +20,19 @@
#ifndef _MESSAGES_DGM_H_
#define _MESSAGES_DGM_H_
struct messaging_dgm_context;
int messaging_dgm_init(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
int messaging_dgm_init(struct tevent_context *ev,
struct server_id pid,
const char *cache_dir,
uid_t dir_owner,
void (*recv_cb)(const uint8_t *msg,
size_t msg_len,
void *private_data),
void *recv_cb_private_data,
struct messaging_dgm_context **pctx);
int messaging_dgm_send(struct messaging_dgm_context *ctx, pid_t pid,
const struct iovec *iov, int iovlen);
int messaging_dgm_cleanup(struct messaging_dgm_context *ctx, pid_t pid);
int messaging_dgm_wipe(struct messaging_dgm_context *ctx);
void *recv_cb_private_data);
void messaging_dgm_destroy(void);
int messaging_dgm_send(pid_t pid, const struct iovec *iov, int iovlen);
int messaging_dgm_cleanup(pid_t pid);
int messaging_dgm_wipe(void);
void *messaging_dgm_register_tevent_context(TALLOC_CTX *mem_ctx,
struct messaging_dgm_context *ctx,
struct tevent_context *ev);
#endif