2 Unix SMB/CIFS implementation.
5 Copyright (C) Gregor Beck 2013
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #include "smbd/globals.h"
25 #include "smbd/scavenger.h"
26 #include "locking/proto.h"
27 #include "lib/util/server_id.h"
28 #include "lib/util/util_process.h"
29 #include "lib/util/sys_rw_data.h"
32 #define DBGC_CLASS DBGC_SCAVENGER
34 struct smbd_scavenger_state {
35 struct tevent_context *ev;
36 struct messaging_context *msg;
37 struct server_id parent_id;
38 struct server_id *scavenger_id;
42 static struct smbd_scavenger_state *smbd_scavenger_state = NULL;
44 struct scavenger_message {
45 struct file_id file_id;
46 uint64_t open_persistent_id;
50 static int smbd_scavenger_main(struct smbd_scavenger_state *state)
52 struct server_id_buf tmp1, tmp2;
54 DEBUG(10, ("scavenger: %s started, parent: %s\n",
55 server_id_str_buf(*state->scavenger_id, &tmp1),
56 server_id_str_buf(state->parent_id, &tmp2)));
59 TALLOC_CTX *frame = talloc_stackframe();
62 ret = tevent_loop_once(state->ev);
64 DEBUG(2, ("tevent_loop_once failed: %s\n",
70 DEBUG(10, ("scavenger: %s event loop iteration\n",
71 server_id_str_buf(*state->scavenger_id, &tmp1)));
78 static void smbd_scavenger_done(struct tevent_context *event_ctx, struct tevent_fd *fde,
79 uint16_t flags, void *private_data)
81 struct smbd_scavenger_state *state = talloc_get_type_abort(
82 private_data, struct smbd_scavenger_state);
83 struct server_id_buf tmp;
85 DEBUG(2, ("scavenger: %s died\n",
86 server_id_str_buf(*state->scavenger_id, &tmp)));
88 TALLOC_FREE(state->scavenger_id);
91 static void smbd_scavenger_parent_dead(struct tevent_context *event_ctx,
92 struct tevent_fd *fde,
93 uint16_t flags, void *private_data)
95 struct smbd_scavenger_state *state = talloc_get_type_abort(
96 private_data, struct smbd_scavenger_state);
97 struct server_id_buf tmp1, tmp2;
99 DEBUG(2, ("scavenger: %s parent %s died\n",
100 server_id_str_buf(*state->scavenger_id, &tmp1),
101 server_id_str_buf(state->parent_id, &tmp2)));
103 exit_server("smbd_scavenger_parent_dead");
106 static void scavenger_sig_term_handler(struct tevent_context *ev,
107 struct tevent_signal *se,
113 exit_server_cleanly("termination signal");
116 static void scavenger_setup_sig_term_handler(struct tevent_context *ev_ctx)
118 struct tevent_signal *se;
120 se = tevent_add_signal(ev_ctx,
123 scavenger_sig_term_handler,
126 exit_server("failed to setup SIGTERM handler");
130 static bool smbd_scavenger_running(struct smbd_scavenger_state *state)
132 if (state->scavenger_id == NULL) {
136 return serverid_exists(state->scavenger_id);
139 static int smbd_scavenger_server_id_destructor(struct server_id *id)
141 serverid_deregister(*id);
145 static bool scavenger_say_hello(int fd, struct server_id self)
148 struct server_id_buf tmp;
150 ret = write_data(fd, &self, sizeof(self));
152 DEBUG(2, ("Failed to write to pipe: %s\n", strerror(errno)));
155 if (ret < sizeof(self)) {
156 DBG_WARNING("Could not write serverid\n");
160 DEBUG(4, ("scavenger_say_hello: self[%s]\n",
161 server_id_str_buf(self, &tmp)));
165 static bool scavenger_wait_hello(int fd, struct server_id *child)
167 struct server_id_buf tmp;
170 ret = read_data(fd, child, sizeof(struct server_id));
172 DEBUG(2, ("Failed to read from pipe: %s\n",
176 if (ret < sizeof(struct server_id)) {
177 DBG_WARNING("Could not read serverid\n");
181 DEBUG(4, ("scavenger_say_hello: child[%s]\n",
182 server_id_str_buf(*child, &tmp)));
186 static bool smbd_scavenger_start(struct smbd_scavenger_state *state)
188 struct server_id self = messaging_server_id(state->msg);
189 struct tevent_fd *fde = NULL;
194 SMB_ASSERT(server_id_equal(&state->parent_id, &self));
196 if (smbd_scavenger_running(state)) {
197 struct server_id_buf tmp;
198 DEBUG(10, ("scavenger %s already running\n",
199 server_id_str_buf(*state->scavenger_id,
204 if (state->scavenger_id != NULL) {
205 struct server_id_buf tmp;
206 DEBUG(10, ("scavenger zombie %s, cleaning up\n",
207 server_id_str_buf(*state->scavenger_id,
209 TALLOC_FREE(state->scavenger_id);
212 state->scavenger_id = talloc_zero(state, struct server_id);
213 if (state->scavenger_id == NULL) {
214 DEBUG(2, ("Out of memory\n"));
217 talloc_set_destructor(state->scavenger_id,
218 smbd_scavenger_server_id_destructor);
220 ret = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
222 DEBUG(2, ("socketpair failed: %s", strerror(errno)));
226 smb_set_close_on_exec(fds[0]);
227 smb_set_close_on_exec(fds[1]);
234 DEBUG(0, ("fork failed: %s", strerror(err)));
245 status = smbd_reinit_after_fork(state->msg, state->ev,
246 true, "smbd-scavenger");
247 if (!NT_STATUS_IS_OK(status)) {
248 DEBUG(2, ("reinit_after_fork failed: %s\n",
250 exit_server("reinit_after_fork failed");
254 state->am_scavenger = true;
255 *state->scavenger_id = messaging_server_id(state->msg);
257 scavenger_setup_sig_term_handler(state->ev);
259 if (!serverid_register(*state->scavenger_id,
261 DBG_WARNING("serverid_register failed");
262 exit_server("serverid_register failed");
266 ok = scavenger_say_hello(fds[1], *state->scavenger_id);
268 DEBUG(2, ("scavenger_say_hello failed\n"));
269 exit_server("scavenger_say_hello failed");
273 fde = tevent_add_fd(state->ev, state->scavenger_id,
274 fds[1], TEVENT_FD_READ,
275 smbd_scavenger_parent_dead, state);
277 DEBUG(2, ("tevent_add_fd(smbd_scavenger_parent_dead) "
279 exit_server("tevent_add_fd(smbd_scavenger_parent_dead) "
283 tevent_fd_set_auto_close(fde);
285 ret = smbd_scavenger_main(state);
287 DEBUG(10, ("scavenger ended: %d\n", ret));
288 exit_server_cleanly("scavenger ended");
295 ok = scavenger_wait_hello(fds[0], state->scavenger_id);
301 fde = tevent_add_fd(state->ev, state->scavenger_id,
302 fds[0], TEVENT_FD_READ,
303 smbd_scavenger_done, state);
308 tevent_fd_set_auto_close(fde);
312 TALLOC_FREE(state->scavenger_id);
316 static void scavenger_add_timer(struct smbd_scavenger_state *state,
317 struct scavenger_message *msg);
319 static void smbd_scavenger_msg(struct messaging_context *msg_ctx,
322 struct server_id src,
325 struct smbd_scavenger_state *state =
326 talloc_get_type_abort(private_data,
327 struct smbd_scavenger_state);
328 TALLOC_CTX *frame = talloc_stackframe();
329 struct server_id self = messaging_server_id(msg_ctx);
330 struct scavenger_message *msg = NULL;
331 struct server_id_buf tmp1, tmp2;
333 DEBUG(10, ("smbd_scavenger_msg: %s got message from %s\n",
334 server_id_str_buf(self, &tmp1),
335 server_id_str_buf(src, &tmp2)));
337 if (server_id_equal(&state->parent_id, &self)) {
340 if (!smbd_scavenger_running(state) &&
341 !smbd_scavenger_start(state))
343 DEBUG(2, ("Failed to start scavenger\n"));
346 DEBUG(10, ("forwarding message to scavenger\n"));
348 status = messaging_send(msg_ctx,
349 *state->scavenger_id, msg_type, data);
350 if (!NT_STATUS_IS_OK(status)) {
351 DEBUG(2, ("forwarding message to scavenger failed: "
352 "%s\n", nt_errstr(status)));
358 if (!state->am_scavenger) {
359 DEBUG(10, ("im not the scavenger: ignore message\n"));
363 if (!server_id_equal(&state->parent_id, &src)) {
364 DEBUG(10, ("scavenger: ignore spurious message\n"));
368 DEBUG(10, ("scavenger: got a message\n"));
369 msg = (struct scavenger_message*)data->data;
370 scavenger_add_timer(state, msg);
375 bool smbd_scavenger_init(TALLOC_CTX *mem_ctx,
376 struct messaging_context *msg,
377 struct tevent_context *ev)
379 struct smbd_scavenger_state *state;
382 if (smbd_scavenger_state) {
383 DEBUG(10, ("smbd_scavenger_init called again\n"));
387 state = talloc_zero(mem_ctx, struct smbd_scavenger_state);
389 DEBUG(2, ("Out of memory\n"));
395 state->parent_id = messaging_server_id(msg);
397 status = messaging_register(msg, state, MSG_SMB_SCAVENGER,
399 if (!NT_STATUS_IS_OK(status)) {
400 DEBUG(2, ("failed to register message handler: %s\n",
405 smbd_scavenger_state = state;
412 void scavenger_schedule_disconnected(struct files_struct *fsp)
415 struct server_id self = messaging_server_id(fsp->conn->sconn->msg_ctx);
416 struct timeval disconnect_time, until;
417 uint64_t timeout_usec;
418 struct scavenger_message msg;
420 struct server_id_buf tmp;
422 if (fsp->op == NULL) {
425 nttime_to_timeval(&disconnect_time, fsp->op->global->disconnect_time);
426 timeout_usec = 1000 * fsp->op->global->durable_timeout_msec;
427 until = timeval_add(&disconnect_time,
428 timeout_usec / 1000000,
429 timeout_usec % 1000000);
432 msg.file_id = fsp->file_id;
433 msg.open_persistent_id = fsp->op->global->open_persistent_id;
434 msg.until = timeval_to_nttime(&until);
436 DEBUG(10, ("smbd: %s mark file %s as disconnected at %s with timeout "
438 server_id_str_buf(self, &tmp),
439 file_id_string_tos(&fsp->file_id),
440 timeval_string(talloc_tos(), &disconnect_time, true),
441 timeval_string(talloc_tos(), &until, true),
442 fsp->op->global->durable_timeout_msec/1000.0));
444 SMB_ASSERT(server_id_is_disconnected(&fsp->op->global->server_id));
445 SMB_ASSERT(!server_id_equal(&self, &smbd_scavenger_state->parent_id));
446 SMB_ASSERT(!smbd_scavenger_state->am_scavenger);
448 msg_blob = data_blob_const(&msg, sizeof(msg));
449 DEBUG(10, ("send message to scavenger\n"));
451 status = messaging_send(smbd_scavenger_state->msg,
452 smbd_scavenger_state->parent_id,
455 if (!NT_STATUS_IS_OK(status)) {
456 struct server_id_buf tmp1, tmp2;
457 DEBUG(2, ("Failed to send message to parent smbd %s "
459 server_id_str_buf(smbd_scavenger_state->parent_id,
461 server_id_str_buf(self, &tmp2),
466 struct scavenger_timer_context {
467 struct smbd_scavenger_state *state;
468 struct scavenger_message msg;
471 static void scavenger_timer(struct tevent_context *ev,
472 struct tevent_timer *te,
473 struct timeval t, void *data)
475 struct scavenger_timer_context *ctx =
476 talloc_get_type_abort(data, struct scavenger_timer_context);
480 DEBUG(10, ("scavenger: do cleanup for file %s at %s\n",
481 file_id_string_tos(&ctx->msg.file_id),
482 timeval_string(talloc_tos(), &t, true)));
484 ok = share_mode_cleanup_disconnected(ctx->msg.file_id,
485 ctx->msg.open_persistent_id);
487 DEBUG(2, ("Failed to cleanup share modes and byte range locks "
488 "for file %s open %llu\n",
489 file_id_string_tos(&ctx->msg.file_id),
490 (unsigned long long)ctx->msg.open_persistent_id));
493 status = smbXsrv_open_cleanup(ctx->msg.open_persistent_id);
494 if (!NT_STATUS_IS_OK(status)) {
495 DEBUG(2, ("Failed to cleanup open global for file %s open %llu:"
496 " %s\n", file_id_string_tos(&ctx->msg.file_id),
497 (unsigned long long)ctx->msg.open_persistent_id,
502 static void scavenger_add_timer(struct smbd_scavenger_state *state,
503 struct scavenger_message *msg)
505 struct tevent_timer *te;
506 struct scavenger_timer_context *ctx;
507 struct timeval until;
509 nttime_to_timeval(&until, msg->until);
511 DEBUG(10, ("scavenger: schedule file %s for cleanup at %s\n",
512 file_id_string_tos(&msg->file_id),
513 timeval_string(talloc_tos(), &until, true)));
515 ctx = talloc_zero(state, struct scavenger_timer_context);
517 DEBUG(2, ("Failed to talloc_zero(scavenger_timer_context)\n"));
524 te = tevent_add_timer(state->ev,
530 DEBUG(2, ("Failed to add scavenger_timer event\n"));
535 /* delete context after handler was running */
536 talloc_steal(te, ctx);