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/>.
25 #include "smbd/globals.h"
26 #include "smbd/scavenger.h"
27 #include "locking/proto.h"
28 #include "lib/util/util_process.h"
29 #include "lib/sys_rw.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
)
147 const uint8_t *msg
= (const uint8_t *)&self
;
148 size_t remaining
= sizeof(self
);
150 struct server_id_buf tmp
;
152 while (remaining
> 0) {
155 ret
= sys_write(fd
, msg
+ ofs
, remaining
);
157 DEBUG(2, ("Failed to write to pipe: %s\n",
164 DEBUG(4, ("scavenger_say_hello: self[%s]\n",
165 server_id_str_buf(self
, &tmp
)));
169 static bool scavenger_wait_hello(int fd
, struct server_id
*child
)
171 uint8_t *msg
= (uint8_t *)child
;
172 size_t remaining
= sizeof(*child
);
174 struct server_id_buf tmp
;
176 while (remaining
> 0) {
179 ret
= sys_read(fd
, msg
+ ofs
, remaining
);
181 DEBUG(2, ("Failed to read from pipe: %s\n",
188 DEBUG(4, ("scavenger_say_hello: child[%s]\n",
189 server_id_str_buf(*child
, &tmp
)));
193 static bool smbd_scavenger_start(struct smbd_scavenger_state
*state
)
195 struct server_id self
= messaging_server_id(state
->msg
);
196 struct tevent_fd
*fde
= NULL
;
202 SMB_ASSERT(server_id_equal(&state
->parent_id
, &self
));
204 if (smbd_scavenger_running(state
)) {
205 struct server_id_buf tmp
;
206 DEBUG(10, ("scavenger %s already running\n",
207 server_id_str_buf(*state
->scavenger_id
,
212 if (state
->scavenger_id
!= NULL
) {
213 struct server_id_buf tmp
;
214 DEBUG(10, ("scavenger zombie %s, cleaning up\n",
215 server_id_str_buf(*state
->scavenger_id
,
217 TALLOC_FREE(state
->scavenger_id
);
220 state
->scavenger_id
= talloc_zero(state
, struct server_id
);
221 if (state
->scavenger_id
== NULL
) {
222 DEBUG(2, ("Out of memory\n"));
225 talloc_set_destructor(state
->scavenger_id
,
226 smbd_scavenger_server_id_destructor
);
228 ret
= socketpair(AF_UNIX
, SOCK_STREAM
, 0, fds
);
230 DEBUG(2, ("socketpair failed: %s", strerror(errno
)));
234 smb_set_close_on_exec(fds
[0]);
235 smb_set_close_on_exec(fds
[1]);
237 unique_id
= serverid_get_random_unique_id();
244 DEBUG(0, ("fork failed: %s", strerror(err
)));
255 set_my_unique_id(unique_id
);
257 status
= smbd_reinit_after_fork(state
->msg
, state
->ev
, true);
258 if (!NT_STATUS_IS_OK(status
)) {
259 DEBUG(2, ("reinit_after_fork failed: %s\n",
261 exit_server("reinit_after_fork failed");
265 prctl_set_comment("smbd-scavenger");
267 state
->am_scavenger
= true;
268 *state
->scavenger_id
= messaging_server_id(state
->msg
);
270 scavenger_setup_sig_term_handler(state
->ev
);
272 if (!serverid_register(*state
->scavenger_id
,
274 DBG_WARNING("serverid_register failed");
275 exit_server("serverid_register failed");
279 ok
= scavenger_say_hello(fds
[1], *state
->scavenger_id
);
281 DEBUG(2, ("scavenger_say_hello failed\n"));
282 exit_server("scavenger_say_hello failed");
286 fde
= tevent_add_fd(state
->ev
, state
->scavenger_id
,
287 fds
[1], TEVENT_FD_READ
,
288 smbd_scavenger_parent_dead
, state
);
290 DEBUG(2, ("tevent_add_fd(smbd_scavenger_parent_dead) "
292 exit_server("tevent_add_fd(smbd_scavenger_parent_dead) "
296 tevent_fd_set_auto_close(fde
);
298 ret
= smbd_scavenger_main(state
);
300 DEBUG(10, ("scavenger ended: %d\n", ret
));
301 exit_server_cleanly("scavenger ended");
308 ok
= scavenger_wait_hello(fds
[0], state
->scavenger_id
);
314 fde
= tevent_add_fd(state
->ev
, state
->scavenger_id
,
315 fds
[0], TEVENT_FD_READ
,
316 smbd_scavenger_done
, state
);
321 tevent_fd_set_auto_close(fde
);
325 TALLOC_FREE(state
->scavenger_id
);
329 static void scavenger_add_timer(struct smbd_scavenger_state
*state
,
330 struct scavenger_message
*msg
);
332 static void smbd_scavenger_msg(struct messaging_context
*msg_ctx
,
335 struct server_id src
,
338 struct smbd_scavenger_state
*state
=
339 talloc_get_type_abort(private_data
,
340 struct smbd_scavenger_state
);
341 TALLOC_CTX
*frame
= talloc_stackframe();
342 struct server_id self
= messaging_server_id(msg_ctx
);
343 struct scavenger_message
*msg
= NULL
;
344 struct server_id_buf tmp1
, tmp2
;
346 DEBUG(10, ("smbd_scavenger_msg: %s got message from %s\n",
347 server_id_str_buf(self
, &tmp1
),
348 server_id_str_buf(src
, &tmp2
)));
350 if (server_id_equal(&state
->parent_id
, &self
)) {
353 if (!smbd_scavenger_running(state
) &&
354 !smbd_scavenger_start(state
))
356 DEBUG(2, ("Failed to start scavenger\n"));
359 DEBUG(10, ("forwarding message to scavenger\n"));
361 status
= messaging_send(msg_ctx
,
362 *state
->scavenger_id
, msg_type
, data
);
363 if (!NT_STATUS_IS_OK(status
)) {
364 DEBUG(2, ("forwarding message to scavenger failed: "
365 "%s\n", nt_errstr(status
)));
371 if (!state
->am_scavenger
) {
372 DEBUG(10, ("im not the scavenger: ignore message\n"));
376 if (!server_id_equal(&state
->parent_id
, &src
)) {
377 DEBUG(10, ("scavenger: ignore spurious message\n"));
381 DEBUG(10, ("scavenger: got a message\n"));
382 msg
= (struct scavenger_message
*)data
->data
;
383 scavenger_add_timer(state
, msg
);
388 bool smbd_scavenger_init(TALLOC_CTX
*mem_ctx
,
389 struct messaging_context
*msg
,
390 struct tevent_context
*ev
)
392 struct smbd_scavenger_state
*state
;
395 if (smbd_scavenger_state
) {
396 DEBUG(10, ("smbd_scavenger_init called again\n"));
400 state
= talloc_zero(mem_ctx
, struct smbd_scavenger_state
);
402 DEBUG(2, ("Out of memory\n"));
408 state
->parent_id
= messaging_server_id(msg
);
410 status
= messaging_register(msg
, state
, MSG_SMB_SCAVENGER
,
412 if (!NT_STATUS_IS_OK(status
)) {
413 DEBUG(2, ("failed to register message handler: %s\n",
418 smbd_scavenger_state
= state
;
425 void scavenger_schedule_disconnected(struct files_struct
*fsp
)
428 struct server_id self
= messaging_server_id(fsp
->conn
->sconn
->msg_ctx
);
429 struct timeval disconnect_time
, until
;
430 uint64_t timeout_usec
;
431 struct scavenger_message msg
;
433 struct server_id_buf tmp
;
435 if (fsp
->op
== NULL
) {
438 nttime_to_timeval(&disconnect_time
, fsp
->op
->global
->disconnect_time
);
439 timeout_usec
= 1000 * fsp
->op
->global
->durable_timeout_msec
;
440 until
= timeval_add(&disconnect_time
,
441 timeout_usec
/ 1000000,
442 timeout_usec
% 1000000);
445 msg
.file_id
= fsp
->file_id
;
446 msg
.open_persistent_id
= fsp
->op
->global
->open_persistent_id
;
447 msg
.until
= timeval_to_nttime(&until
);
449 DEBUG(10, ("smbd: %s mark file %s as disconnected at %s with timeout "
451 server_id_str_buf(self
, &tmp
),
452 file_id_string_tos(&fsp
->file_id
),
453 timeval_string(talloc_tos(), &disconnect_time
, true),
454 timeval_string(talloc_tos(), &until
, true),
455 fsp
->op
->global
->durable_timeout_msec
/1000.0));
457 SMB_ASSERT(server_id_is_disconnected(&fsp
->op
->global
->server_id
));
458 SMB_ASSERT(!server_id_equal(&self
, &smbd_scavenger_state
->parent_id
));
459 SMB_ASSERT(!smbd_scavenger_state
->am_scavenger
);
461 msg_blob
= data_blob_const(&msg
, sizeof(msg
));
462 DEBUG(10, ("send message to scavenger\n"));
464 status
= messaging_send(smbd_scavenger_state
->msg
,
465 smbd_scavenger_state
->parent_id
,
468 if (!NT_STATUS_IS_OK(status
)) {
469 struct server_id_buf tmp1
, tmp2
;
470 DEBUG(2, ("Failed to send message to parent smbd %s "
472 server_id_str_buf(smbd_scavenger_state
->parent_id
,
474 server_id_str_buf(self
, &tmp2
),
479 struct scavenger_timer_context
{
480 struct smbd_scavenger_state
*state
;
481 struct scavenger_message msg
;
484 static void scavenger_timer(struct tevent_context
*ev
,
485 struct tevent_timer
*te
,
486 struct timeval t
, void *data
)
488 struct scavenger_timer_context
*ctx
=
489 talloc_get_type_abort(data
, struct scavenger_timer_context
);
493 DEBUG(10, ("scavenger: do cleanup for file %s at %s\n",
494 file_id_string_tos(&ctx
->msg
.file_id
),
495 timeval_string(talloc_tos(), &t
, true)));
497 ok
= share_mode_cleanup_disconnected(ctx
->msg
.file_id
,
498 ctx
->msg
.open_persistent_id
);
500 DEBUG(2, ("Failed to cleanup share modes and byte range locks "
501 "for file %s open %llu\n",
502 file_id_string_tos(&ctx
->msg
.file_id
),
503 (unsigned long long)ctx
->msg
.open_persistent_id
));
506 status
= smbXsrv_open_cleanup(ctx
->msg
.open_persistent_id
);
507 if (!NT_STATUS_IS_OK(status
)) {
508 DEBUG(2, ("Failed to cleanup open global for file %s open %llu:"
509 " %s\n", file_id_string_tos(&ctx
->msg
.file_id
),
510 (unsigned long long)ctx
->msg
.open_persistent_id
,
515 static void scavenger_add_timer(struct smbd_scavenger_state
*state
,
516 struct scavenger_message
*msg
)
518 struct tevent_timer
*te
;
519 struct scavenger_timer_context
*ctx
;
520 struct timeval until
;
522 nttime_to_timeval(&until
, msg
->until
);
524 DEBUG(10, ("scavenger: schedule file %s for cleanup at %s\n",
525 file_id_string_tos(&msg
->file_id
),
526 timeval_string(talloc_tos(), &until
, true)));
528 ctx
= talloc_zero(state
, struct scavenger_timer_context
);
530 DEBUG(2, ("Failed to talloc_zero(scavenger_timer_context)\n"));
537 te
= tevent_add_timer(state
->ev
,
543 DEBUG(2, ("Failed to add scavenger_timer event\n"));
548 /* delete context after handler was running */
549 talloc_steal(te
, ctx
);