diff options
Diffstat (limited to '')
| -rw-r--r-- | source3/smbd/scavenger.c | 730 |
1 files changed, 730 insertions, 0 deletions
diff --git a/source3/smbd/scavenger.c b/source3/smbd/scavenger.c new file mode 100644 index 0000000..59b84cc --- /dev/null +++ b/source3/smbd/scavenger.c @@ -0,0 +1,730 @@ +/* + Unix SMB/CIFS implementation. + smbd scavenger daemon + + Copyright (C) Gregor Beck 2013 + + 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 "messages.h" +#include "serverid.h" +#include "smbd/globals.h" +#include "smbd/smbXsrv_open.h" +#include "smbd/scavenger.h" +#include "locking/share_mode_lock.h" +#include "locking/leases_db.h" +#include "locking/proto.h" +#include "librpc/gen_ndr/open_files.h" +#include "lib/util/server_id.h" +#include "lib/util/util_process.h" +#include "lib/util/sys_rw_data.h" + +#undef DBGC_CLASS +#define DBGC_CLASS DBGC_SCAVENGER + +struct smbd_scavenger_state { + struct tevent_context *ev; + struct messaging_context *msg; + struct server_id parent_id; + struct server_id *scavenger_id; + bool am_scavenger; +}; + +static struct smbd_scavenger_state *smbd_scavenger_state = NULL; + +struct scavenger_message { + struct file_id file_id; + uint64_t open_persistent_id; + NTTIME until; +}; + +static int smbd_scavenger_main(struct smbd_scavenger_state *state) +{ + struct server_id_buf tmp1, tmp2; + + DEBUG(10, ("scavenger: %s started, parent: %s\n", + server_id_str_buf(*state->scavenger_id, &tmp1), + server_id_str_buf(state->parent_id, &tmp2))); + + while (true) { + TALLOC_CTX *frame = talloc_stackframe(); + int ret; + + ret = tevent_loop_once(state->ev); + if (ret != 0) { + DEBUG(2, ("tevent_loop_once failed: %s\n", + strerror(errno))); + TALLOC_FREE(frame); + return 1; + } + + DEBUG(10, ("scavenger: %s event loop iteration\n", + server_id_str_buf(*state->scavenger_id, &tmp1))); + TALLOC_FREE(frame); + } + + return 0; +} + +static void smbd_scavenger_done(struct tevent_context *event_ctx, struct tevent_fd *fde, + uint16_t flags, void *private_data) +{ + struct smbd_scavenger_state *state = talloc_get_type_abort( + private_data, struct smbd_scavenger_state); + struct server_id_buf tmp; + + DEBUG(2, ("scavenger: %s died\n", + server_id_str_buf(*state->scavenger_id, &tmp))); + + TALLOC_FREE(state->scavenger_id); +} + +static void smbd_scavenger_parent_dead(struct tevent_context *event_ctx, + struct tevent_fd *fde, + uint16_t flags, void *private_data) +{ + struct smbd_scavenger_state *state = talloc_get_type_abort( + private_data, struct smbd_scavenger_state); + struct server_id_buf tmp1, tmp2; + + DEBUG(2, ("scavenger: %s parent %s died\n", + server_id_str_buf(*state->scavenger_id, &tmp1), + server_id_str_buf(state->parent_id, &tmp2))); + + exit_server_cleanly("smbd_scavenger_parent_dead"); +} + +static void scavenger_sig_term_handler(struct tevent_context *ev, + struct tevent_signal *se, + int signum, + int count, + void *siginfo, + void *private_data) +{ + exit_server_cleanly("termination signal"); +} + +static void scavenger_setup_sig_term_handler(struct tevent_context *ev_ctx) +{ + struct tevent_signal *se; + + se = tevent_add_signal(ev_ctx, + ev_ctx, + SIGTERM, 0, + scavenger_sig_term_handler, + NULL); + if (se == NULL) { + exit_server("failed to setup SIGTERM handler"); + } +} + +static bool smbd_scavenger_running(struct smbd_scavenger_state *state) +{ + if (state->scavenger_id == NULL) { + return false; + } + + return serverid_exists(state->scavenger_id); +} + +static int smbd_scavenger_server_id_destructor(struct server_id *id) +{ + return 0; +} + +static bool scavenger_say_hello(int fd, struct server_id self) +{ + ssize_t ret; + struct server_id_buf tmp; + + ret = write_data(fd, &self, sizeof(self)); + if (ret == -1) { + DEBUG(2, ("Failed to write to pipe: %s\n", strerror(errno))); + return false; + } + if (ret < sizeof(self)) { + DBG_WARNING("Could not write serverid\n"); + return false; + } + + DEBUG(4, ("scavenger_say_hello: self[%s]\n", + server_id_str_buf(self, &tmp))); + return true; +} + +static bool scavenger_wait_hello(int fd, struct server_id *child) +{ + struct server_id_buf tmp; + ssize_t ret; + + ret = read_data(fd, child, sizeof(struct server_id)); + if (ret == -1) { + DEBUG(2, ("Failed to read from pipe: %s\n", + strerror(errno))); + return false; + } + if (ret < sizeof(struct server_id)) { + DBG_WARNING("Could not read serverid\n"); + return false; + } + + DEBUG(4, ("scavenger_say_hello: child[%s]\n", + server_id_str_buf(*child, &tmp))); + return true; +} + +static bool smbd_scavenger_start(struct smbd_scavenger_state *state) +{ + struct server_id self = messaging_server_id(state->msg); + struct tevent_fd *fde = NULL; + int fds[2]; + int ret; + bool ok; + + SMB_ASSERT(server_id_equal(&state->parent_id, &self)); + + if (smbd_scavenger_running(state)) { + struct server_id_buf tmp; + DEBUG(10, ("scavenger %s already running\n", + server_id_str_buf(*state->scavenger_id, + &tmp))); + return true; + } + + if (state->scavenger_id != NULL) { + struct server_id_buf tmp; + DEBUG(10, ("scavenger zombie %s, cleaning up\n", + server_id_str_buf(*state->scavenger_id, + &tmp))); + TALLOC_FREE(state->scavenger_id); + } + + state->scavenger_id = talloc_zero(state, struct server_id); + if (state->scavenger_id == NULL) { + DEBUG(2, ("Out of memory\n")); + goto fail; + } + talloc_set_destructor(state->scavenger_id, + smbd_scavenger_server_id_destructor); + + ret = socketpair(AF_UNIX, SOCK_STREAM, 0, fds); + if (ret == -1) { + DEBUG(2, ("socketpair failed: %s", strerror(errno))); + goto fail; + } + + smb_set_close_on_exec(fds[0]); + smb_set_close_on_exec(fds[1]); + + ret = fork(); + if (ret == -1) { + int err = errno; + close(fds[0]); + close(fds[1]); + DEBUG(0, ("fork failed: %s", strerror(err))); + goto fail; + } + + if (ret == 0) { + /* child */ + + NTSTATUS status; + + close(fds[0]); + + status = smbd_reinit_after_fork(state->msg, state->ev, + true, "smbd-scavenger"); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(2, ("reinit_after_fork failed: %s\n", + nt_errstr(status))); + exit_server("reinit_after_fork failed"); + return false; + } + + reopen_logs(); + + state->am_scavenger = true; + *state->scavenger_id = messaging_server_id(state->msg); + + scavenger_setup_sig_term_handler(state->ev); + + ok = scavenger_say_hello(fds[1], *state->scavenger_id); + if (!ok) { + DEBUG(2, ("scavenger_say_hello failed\n")); + exit_server("scavenger_say_hello failed"); + return false; + } + + fde = tevent_add_fd(state->ev, state->scavenger_id, + fds[1], TEVENT_FD_READ, + smbd_scavenger_parent_dead, state); + if (fde == NULL) { + DEBUG(2, ("tevent_add_fd(smbd_scavenger_parent_dead) " + "failed\n")); + exit_server("tevent_add_fd(smbd_scavenger_parent_dead) " + "failed"); + return false; + } + tevent_fd_set_auto_close(fde); + + ret = smbd_scavenger_main(state); + + DEBUG(10, ("scavenger ended: %d\n", ret)); + exit_server_cleanly("scavenger ended"); + return false; + } + + /* parent */ + close(fds[1]); + + ok = scavenger_wait_hello(fds[0], state->scavenger_id); + if (!ok) { + close(fds[0]); + goto fail; + } + + fde = tevent_add_fd(state->ev, state->scavenger_id, + fds[0], TEVENT_FD_READ, + smbd_scavenger_done, state); + if (fde == NULL) { + close(fds[0]); + goto fail; + } + tevent_fd_set_auto_close(fde); + + return true; +fail: + TALLOC_FREE(state->scavenger_id); + return false; +} + +static void scavenger_add_timer(struct smbd_scavenger_state *state, + struct scavenger_message *msg); + +static void smbd_scavenger_msg(struct messaging_context *msg_ctx, + void *private_data, + uint32_t msg_type, + struct server_id src, + DATA_BLOB *data) +{ + struct smbd_scavenger_state *state = + talloc_get_type_abort(private_data, + struct smbd_scavenger_state); + TALLOC_CTX *frame = talloc_stackframe(); + struct server_id self = messaging_server_id(msg_ctx); + struct scavenger_message *msg = NULL; + struct server_id_buf tmp1, tmp2; + + DEBUG(10, ("smbd_scavenger_msg: %s got message from %s\n", + server_id_str_buf(self, &tmp1), + server_id_str_buf(src, &tmp2))); + + if (server_id_equal(&state->parent_id, &self)) { + NTSTATUS status; + + if (!smbd_scavenger_running(state) && + !smbd_scavenger_start(state)) + { + DEBUG(2, ("Failed to start scavenger\n")); + goto done; + } + DEBUG(10, ("forwarding message to scavenger\n")); + + status = messaging_send(msg_ctx, + *state->scavenger_id, msg_type, data); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(2, ("forwarding message to scavenger failed: " + "%s\n", nt_errstr(status))); + goto done; + } + goto done; + } + + if (!state->am_scavenger) { + DEBUG(10, ("im not the scavenger: ignore message\n")); + goto done; + } + + if (!server_id_equal(&state->parent_id, &src)) { + DEBUG(10, ("scavenger: ignore spurious message\n")); + goto done; + } + + DEBUG(10, ("scavenger: got a message\n")); + msg = (struct scavenger_message*)data->data; + scavenger_add_timer(state, msg); +done: + talloc_free(frame); +} + +bool smbd_scavenger_init(TALLOC_CTX *mem_ctx, + struct messaging_context *msg, + struct tevent_context *ev) +{ + struct smbd_scavenger_state *state; + NTSTATUS status; + + if (smbd_scavenger_state) { + DEBUG(10, ("smbd_scavenger_init called again\n")); + return true; + } + + state = talloc_zero(mem_ctx, struct smbd_scavenger_state); + if (state == NULL) { + DEBUG(2, ("Out of memory\n")); + return false; + } + + state->msg = msg; + state->ev = ev; + state->parent_id = messaging_server_id(msg); + + status = messaging_register(msg, state, MSG_SMB_SCAVENGER, + smbd_scavenger_msg); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(2, ("failed to register message handler: %s\n", + nt_errstr(status))); + goto fail; + } + + smbd_scavenger_state = state; + return true; +fail: + talloc_free(state); + return false; +} + +void scavenger_schedule_disconnected(struct files_struct *fsp) +{ + NTSTATUS status; + struct server_id self = messaging_server_id(fsp->conn->sconn->msg_ctx); + struct timeval disconnect_time, until; + uint64_t timeout_usec; + struct scavenger_message msg; + DATA_BLOB msg_blob; + struct server_id_buf tmp; + struct file_id_buf idbuf; + + if (fsp->op == NULL) { + return; + } + nttime_to_timeval(&disconnect_time, fsp->op->global->disconnect_time); + timeout_usec = 1000 * fsp->op->global->durable_timeout_msec; + until = timeval_add(&disconnect_time, + timeout_usec / 1000000, + timeout_usec % 1000000); + + ZERO_STRUCT(msg); + msg.file_id = fsp->file_id; + msg.open_persistent_id = fsp->op->global->open_persistent_id; + msg.until = timeval_to_nttime(&until); + + DEBUG(10, ("smbd: %s mark file %s as disconnected at %s with timeout " + "at %s in %fs\n", + server_id_str_buf(self, &tmp), + file_id_str_buf(fsp->file_id, &idbuf), + timeval_string(talloc_tos(), &disconnect_time, true), + timeval_string(talloc_tos(), &until, true), + fsp->op->global->durable_timeout_msec/1000.0)); + + SMB_ASSERT(server_id_is_disconnected(&fsp->op->global->server_id)); + SMB_ASSERT(!server_id_equal(&self, &smbd_scavenger_state->parent_id)); + SMB_ASSERT(!smbd_scavenger_state->am_scavenger); + + msg_blob = data_blob_const(&msg, sizeof(msg)); + DEBUG(10, ("send message to scavenger\n")); + + status = messaging_send(smbd_scavenger_state->msg, + smbd_scavenger_state->parent_id, + MSG_SMB_SCAVENGER, + &msg_blob); + if (!NT_STATUS_IS_OK(status)) { + struct server_id_buf tmp1, tmp2; + DEBUG(2, ("Failed to send message to parent smbd %s " + "from %s: %s\n", + server_id_str_buf(smbd_scavenger_state->parent_id, + &tmp1), + server_id_str_buf(self, &tmp2), + nt_errstr(status))); + } +} + +struct scavenger_timer_context { + struct smbd_scavenger_state *state; + struct scavenger_message msg; +}; + +struct cleanup_disconnected_state { + struct file_id fid; + struct share_mode_lock *lck; + uint64_t open_persistent_id; + size_t num_disconnected; + bool found_connected; +}; + +static bool cleanup_disconnected_lease(struct share_mode_entry *e, + void *private_data) +{ + struct cleanup_disconnected_state *state = private_data; + NTSTATUS status; + + status = leases_db_del(&e->client_guid, &e->lease_key, &state->fid); + + if (!NT_STATUS_IS_OK(status)) { + DBG_DEBUG("leases_db_del failed: %s\n", + nt_errstr(status)); + } + + return false; +} + +static bool share_mode_find_connected_fn( + struct share_mode_entry *e, + bool *modified, + void *private_data) +{ + struct cleanup_disconnected_state *state = private_data; + bool disconnected; + + disconnected = server_id_is_disconnected(&e->pid); + if (!disconnected) { + char *name = share_mode_filename(talloc_tos(), state->lck); + struct file_id_buf tmp1; + struct server_id_buf tmp2; + DBG_INFO("file (file-id='%s', servicepath='%s', name='%s') " + "is used by server %s ==> do not cleanup\n", + file_id_str_buf(state->fid, &tmp1), + share_mode_servicepath(state->lck), + name, + server_id_str_buf(e->pid, &tmp2)); + TALLOC_FREE(name); + state->found_connected = true; + return true; + } + + if (state->open_persistent_id != e->share_file_id) { + char *name = share_mode_filename(talloc_tos(), state->lck); + struct file_id_buf tmp; + DBG_INFO("entry for file " + "(file-id='%s', servicepath='%s', name='%s') " + "has share_file_id %"PRIu64" but expected " + "%"PRIu64"==> do not cleanup\n", + file_id_str_buf(state->fid, &tmp), + share_mode_servicepath(state->lck), + name, + e->share_file_id, + state->open_persistent_id); + TALLOC_FREE(name); + state->found_connected = true; + return true; + } + + state->num_disconnected += 1; + + return false; +} + +static bool cleanup_disconnected_share_mode_entry_fn( + struct share_mode_entry *e, + bool *modified, + void *private_data) +{ + struct cleanup_disconnected_state *state = private_data; + + bool disconnected; + + disconnected = server_id_is_disconnected(&e->pid); + if (!disconnected) { + char *name = share_mode_filename(talloc_tos(), state->lck); + struct file_id_buf tmp1; + struct server_id_buf tmp2; + DBG_ERR("file (file-id='%s', servicepath='%s', name='%s') " + "is used by server %s ==> internal error\n", + file_id_str_buf(state->fid, &tmp1), + share_mode_servicepath(state->lck), + name, + server_id_str_buf(e->pid, &tmp2)); + TALLOC_FREE(name); + smb_panic(__location__); + } + + /* + * Setting e->stale = true is + * the indication to delete the entry. + */ + e->stale = true; + return false; +} + +static bool share_mode_cleanup_disconnected( + struct file_id fid, uint64_t open_persistent_id) +{ + struct cleanup_disconnected_state state = { + .fid = fid, + .open_persistent_id = open_persistent_id + }; + bool ret = false; + TALLOC_CTX *frame = talloc_stackframe(); + char *name = NULL; + struct file_id_buf idbuf; + bool ok; + + state.lck = get_existing_share_mode_lock(frame, fid); + if (state.lck == NULL) { + DBG_INFO("Could not fetch share mode entry for %s\n", + file_id_str_buf(fid, &idbuf)); + goto done; + } + name = share_mode_filename(frame, state.lck); + + ok = share_mode_forall_entries( + state.lck, share_mode_find_connected_fn, &state); + if (!ok) { + DBG_DEBUG("share_mode_forall_entries failed\n"); + goto done; + } + if (state.found_connected) { + DBG_DEBUG("Found connected entry\n"); + goto done; + } + + ok = share_mode_forall_leases( + state.lck, cleanup_disconnected_lease, &state); + if (!ok) { + DBG_DEBUG("failed to clean up leases associated " + "with file (file-id='%s', servicepath='%s', " + "name='%s') and open_persistent_id %"PRIu64" " + "==> do not cleanup\n", + file_id_str_buf(fid, &idbuf), + share_mode_servicepath(state.lck), + name, + open_persistent_id); + goto done; + } + + ok = brl_cleanup_disconnected(fid, open_persistent_id); + if (!ok) { + DBG_DEBUG("failed to clean up byte range locks associated " + "with file (file-id='%s', servicepath='%s', " + "name='%s') and open_persistent_id %"PRIu64" " + "==> do not cleanup\n", + file_id_str_buf(fid, &idbuf), + share_mode_servicepath(state.lck), + name, + open_persistent_id); + goto done; + } + + DBG_DEBUG("cleaning up %zu entries for file " + "(file-id='%s', servicepath='%s', name='%s') " + "from open_persistent_id %"PRIu64"\n", + state.num_disconnected, + file_id_str_buf(fid, &idbuf), + share_mode_servicepath(state.lck), + name, + open_persistent_id); + + ok = share_mode_forall_entries( + state.lck, cleanup_disconnected_share_mode_entry_fn, &state); + if (!ok) { + DBG_DEBUG("failed to clean up %zu entries associated " + "with file (file-id='%s', servicepath='%s', " + "name='%s') and open_persistent_id %"PRIu64" " + "==> do not cleanup\n", + state.num_disconnected, + file_id_str_buf(fid, &idbuf), + share_mode_servicepath(state.lck), + name, + open_persistent_id); + goto done; + } + + ret = true; +done: + talloc_free(frame); + return ret; +} + +static void scavenger_timer(struct tevent_context *ev, + struct tevent_timer *te, + struct timeval t, void *data) +{ + struct scavenger_timer_context *ctx = + talloc_get_type_abort(data, struct scavenger_timer_context); + struct file_id_buf idbuf; + NTSTATUS status; + bool ok; + + DBG_DEBUG("do cleanup for file %s at %s\n", + file_id_str_buf(ctx->msg.file_id, &idbuf), + timeval_string(talloc_tos(), &t, true)); + + ok = share_mode_cleanup_disconnected(ctx->msg.file_id, + ctx->msg.open_persistent_id); + if (!ok) { + DBG_WARNING("Failed to cleanup share modes and byte range " + "locks for file %s open %"PRIu64"\n", + file_id_str_buf(ctx->msg.file_id, &idbuf), + ctx->msg.open_persistent_id); + } + + status = smbXsrv_open_cleanup(ctx->msg.open_persistent_id); + if (!NT_STATUS_IS_OK(status)) { + DBG_WARNING("Failed to cleanup open global for file %s open " + "%"PRIu64": %s\n", + file_id_str_buf(ctx->msg.file_id, &idbuf), + ctx->msg.open_persistent_id, + nt_errstr(status)); + } +} + +static void scavenger_add_timer(struct smbd_scavenger_state *state, + struct scavenger_message *msg) +{ + struct tevent_timer *te; + struct scavenger_timer_context *ctx; + struct timeval until; + struct file_id_buf idbuf; + + nttime_to_timeval(&until, msg->until); + + DBG_DEBUG("schedule file %s for cleanup at %s\n", + file_id_str_buf(msg->file_id, &idbuf), + timeval_string(talloc_tos(), &until, true)); + + ctx = talloc_zero(state, struct scavenger_timer_context); + if (ctx == NULL) { + DEBUG(2, ("Failed to talloc_zero(scavenger_timer_context)\n")); + return; + } + + ctx->state = state; + ctx->msg = *msg; + + te = tevent_add_timer(state->ev, + state, + until, + scavenger_timer, + ctx); + if (te == NULL) { + DEBUG(2, ("Failed to add scavenger_timer event\n")); + talloc_free(ctx); + return; + } + + /* delete context after handler was running */ + talloc_steal(te, ctx); +} |