2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 2006
5 Copyright (C) Volker Lendecke 2012
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/>.
22 this is the change notify database. It implements mechanisms for
23 storing current change notify waiters in a tdb, and checking if a
24 given event matches any of the stored notify waiiters.
28 #include "system/filesys.h"
29 #include "librpc/gen_ndr/ndr_notify.h"
30 #include "dbwrap/dbwrap.h"
31 #include "dbwrap/dbwrap_open.h"
32 #include "dbwrap/dbwrap_tdb.h"
33 #include "smbd/smbd.h"
35 #include "lib/tdb_wrap/tdb_wrap.h"
37 #include "lib/param/param.h"
38 #include "lib/dbwrap/dbwrap_cache.h"
39 #include "ctdb_srvids.h"
40 #include "ctdbd_conn.h"
41 #include "ctdb_conn.h"
42 #include "lib/util/tevent_unix.h"
45 struct notify_list
*next
, *prev
;
47 void (*callback
)(void *, const struct notify_event
*);
51 struct notify_context
{
52 struct messaging_context
*msg
;
53 struct notify_list
*list
;
56 * The notify database is split up into two databases: One
57 * relatively static index db and the real notify db with the
62 * "db_notify" is indexed by pathname. Per record it stores an
63 * array of notify_db_entry structs. These represent the
64 * notify records as requested by the smb client. This
65 * database is always held locally, it is never clustered.
67 struct db_context
*db_notify
;
70 * "db_index" is indexed by pathname. The records are an array
71 * of VNNs which have any interest in notifies for this path
74 * In the non-clustered case this database is cached in RAM by
75 * means of db_cache_open, which maintains a cache per
76 * process. Cache consistency is maintained by the tdb
79 * In the clustered case right now we can not use the tdb
80 * sequence number, but by means of read only records we
81 * should be able to avoid a lot of full migrations.
83 * In both cases, it is important to keep the update
84 * operations to db_index to a minimum. This is achieved by
85 * delayed deletion. When a db_notify is initially created,
86 * the db_index record is also created. When more notifies are
87 * add for a path, then only the db_notify record needs to be
88 * modified, the db_index record is not touched. When the last
89 * entry from the db_notify record is deleted, the db_index
90 * record is not immediately deleted. Instead, the db_notify
91 * record is replaced with a current timestamp. A regular
92 * cleanup process will delete all db_index records that are
93 * older than a minute.
95 struct db_context
*db_index
;
98 static void notify_trigger_local(struct notify_context
*notify
,
99 uint32_t action
, uint32_t filter
,
100 const char *path
, size_t path_len
,
102 static NTSTATUS
notify_send(struct notify_context
*notify
,
103 struct server_id
*pid
,
104 const char *path
, uint32_t action
,
106 static NTSTATUS
notify_add_entry(struct db_record
*rec
,
107 const struct notify_db_entry
*e
,
109 static NTSTATUS
notify_add_idx(struct db_record
*rec
, uint32_t vnn
);
111 static NTSTATUS
notify_del_entry(struct db_record
*rec
,
112 const struct server_id
*pid
,
114 static NTSTATUS
notify_del_idx(struct db_record
*rec
, uint32_t vnn
);
116 static int notify_context_destructor(struct notify_context
*notify
);
118 static void notify_handler(struct messaging_context
*msg_ctx
,
119 void *private_data
, uint32_t msg_type
,
120 struct server_id server_id
, DATA_BLOB
*data
);
122 struct notify_context
*notify_init(TALLOC_CTX
*mem_ctx
,
123 struct messaging_context
*msg
,
124 struct event_context
*ev
)
126 struct loadparm_context
*lp_ctx
;
127 struct notify_context
*notify
;
129 notify
= talloc(mem_ctx
, struct notify_context
);
130 if (notify
== NULL
) {
136 lp_ctx
= loadparm_init_s3(notify
, loadparm_s3_context());
137 notify
->db_notify
= db_open_tdb(
138 notify
, lp_ctx
, lock_path("notify.tdb"),
139 0, TDB_CLEAR_IF_FIRST
|TDB_INCOMPATIBLE_HASH
,
140 O_RDWR
|O_CREAT
, 0644, DBWRAP_LOCK_ORDER_2
);
141 talloc_unlink(notify
, lp_ctx
);
142 if (notify
->db_notify
== NULL
) {
145 notify
->db_index
= db_open(
146 notify
, lock_path("notify_index.tdb"),
147 0, TDB_SEQNUM
|TDB_CLEAR_IF_FIRST
|TDB_INCOMPATIBLE_HASH
,
148 O_RDWR
|O_CREAT
, 0644, DBWRAP_LOCK_ORDER_3
);
149 if (notify
->db_index
== NULL
) {
152 if (!lp_clustering()) {
153 notify
->db_index
= db_open_cache(notify
, notify
->db_index
);
154 if (notify
->db_index
== NULL
) {
159 if (notify
->msg
!= NULL
) {
162 status
= messaging_register(notify
->msg
, notify
,
163 MSG_PVFS_NOTIFY
, notify_handler
);
164 if (!NT_STATUS_IS_OK(status
)) {
165 DEBUG(1, ("messaging_register returned %s\n",
171 talloc_set_destructor(notify
, notify_context_destructor
);
179 static int notify_context_destructor(struct notify_context
*notify
)
181 DEBUG(10, ("notify_context_destructor called\n"));
183 if (notify
->msg
!= NULL
) {
184 messaging_deregister(notify
->msg
, MSG_PVFS_NOTIFY
, notify
);
187 while (notify
->list
!= NULL
) {
188 DEBUG(10, ("Removing private_data=%p\n",
189 notify
->list
->private_data
));
190 notify_remove(notify
, notify
->list
->private_data
);
195 NTSTATUS
notify_add(struct notify_context
*notify
,
196 const char *path
, uint32_t filter
, uint32_t subdir_filter
,
197 void (*callback
)(void *, const struct notify_event
*),
200 struct notify_db_entry e
;
201 struct notify_list
*listel
;
202 struct db_record
*notify_rec
, *idx_rec
;
205 TDB_DATA key
, notify_copy
;
207 if (notify
== NULL
) {
208 return NT_STATUS_NOT_IMPLEMENTED
;
211 DEBUG(10, ("notify_add: path=[%s], private_data=%p\n", path
,
214 listel
= talloc(notify
, struct notify_list
);
215 if (listel
== NULL
) {
216 return NT_STATUS_NO_MEMORY
;
218 listel
->callback
= callback
;
219 listel
->private_data
= private_data
;
220 listel
->path
= talloc_strdup(listel
, path
);
221 if (listel
->path
== NULL
) {
223 return NT_STATUS_NO_MEMORY
;
225 DLIST_ADD(notify
->list
, listel
);
229 e
.subdir_filter
= subdir_filter
;
230 e
.server
= messaging_server_id(notify
->msg
);
231 e
.private_data
= private_data
;
233 key
= string_tdb_data(path
);
235 notify_rec
= dbwrap_fetch_locked(notify
->db_notify
,
237 if (notify_rec
== NULL
) {
238 status
= NT_STATUS_INTERNAL_DB_CORRUPTION
;
243 * Make a copy of the notify_rec for easy restore in case
244 * updating the index_rec fails;
246 notify_copy
= dbwrap_record_get_value(notify_rec
);
247 if (notify_copy
.dsize
!= 0) {
248 notify_copy
.dptr
= (uint8_t *)talloc_memdup(
249 notify_rec
, notify_copy
.dptr
,
251 if (notify_copy
.dptr
== NULL
) {
252 TALLOC_FREE(notify_rec
);
253 status
= NT_STATUS_NO_MEMORY
;
258 if (DEBUGLEVEL
>= 10) {
259 NDR_PRINT_DEBUG(notify_db_entry
, &e
);
262 status
= notify_add_entry(notify_rec
, &e
, &add_idx
);
263 if (!NT_STATUS_IS_OK(status
)) {
268 * Someone else has added the idx entry already
270 TALLOC_FREE(notify_rec
);
274 idx_rec
= dbwrap_fetch_locked(notify
->db_index
,
276 if (idx_rec
== NULL
) {
277 status
= NT_STATUS_INTERNAL_DB_CORRUPTION
;
280 status
= notify_add_idx(idx_rec
, get_my_vnn());
281 if (!NT_STATUS_IS_OK(status
)) {
285 TALLOC_FREE(idx_rec
);
286 TALLOC_FREE(notify_rec
);
290 if (notify_copy
.dsize
!= 0) {
291 dbwrap_record_store(notify_rec
, notify_copy
, 0);
293 dbwrap_record_delete(notify_rec
);
295 TALLOC_FREE(notify_rec
);
297 DLIST_REMOVE(notify
->list
, listel
);
302 static NTSTATUS
notify_add_entry(struct db_record
*rec
,
303 const struct notify_db_entry
*e
,
306 TDB_DATA value
= dbwrap_record_get_value(rec
);
307 struct notify_db_entry
*entries
;
312 if (value
.dsize
== sizeof(time_t)) {
313 DEBUG(10, ("Re-using deleted entry\n"));
318 if ((value
.dsize
% sizeof(struct notify_db_entry
)) != 0) {
319 DEBUG(1, ("Invalid value.dsize = %u\n",
320 (unsigned)value
.dsize
));
321 return NT_STATUS_INTERNAL_DB_CORRUPTION
;
323 num_entries
= value
.dsize
/ sizeof(struct notify_db_entry
);
325 if (num_entries
!= 0) {
329 entries
= talloc_array(rec
, struct notify_db_entry
, num_entries
+ 1);
330 if (entries
== NULL
) {
331 return NT_STATUS_NO_MEMORY
;
333 memcpy(entries
, value
.dptr
, value
.dsize
);
335 entries
[num_entries
] = *e
;
336 value
= make_tdb_data((uint8_t *)entries
, talloc_get_size(entries
));
337 status
= dbwrap_record_store(rec
, value
, 0);
338 TALLOC_FREE(entries
);
339 if (!NT_STATUS_IS_OK(status
)) {
342 *p_add_idx
= add_idx
;
346 static NTSTATUS
notify_add_idx(struct db_record
*rec
, uint32_t vnn
)
348 TDB_DATA value
= dbwrap_record_get_value(rec
);
353 if ((value
.dsize
% sizeof(uint32_t)) != 0) {
354 DEBUG(1, ("Invalid value.dsize = %u\n",
355 (unsigned)value
.dsize
));
356 return NT_STATUS_INTERNAL_DB_CORRUPTION
;
358 num_vnns
= value
.dsize
/ sizeof(uint32_t);
359 vnns
= (uint32_t *)value
.dptr
;
361 for (i
=0; i
<num_vnns
; i
++) {
362 if (vnns
[i
] == vnn
) {
370 value
.dptr
= (uint8_t *)talloc_realloc(
371 rec
, value
.dptr
, uint32_t, num_vnns
+ 1);
372 if (value
.dptr
== NULL
) {
373 return NT_STATUS_NO_MEMORY
;
375 value
.dsize
= talloc_get_size(value
.dptr
);
377 vnns
= (uint32_t *)value
.dptr
;
379 memmove(&vnns
[i
+1], &vnns
[i
], sizeof(uint32_t) * (num_vnns
- i
));
382 status
= dbwrap_record_store(rec
, value
, 0);
383 if (!NT_STATUS_IS_OK(status
)) {
389 NTSTATUS
notify_remove(struct notify_context
*notify
, void *private_data
)
391 struct server_id pid
;
392 struct notify_list
*listel
;
393 struct db_record
*notify_rec
;
396 if ((notify
== NULL
) || (notify
->msg
== NULL
)) {
397 return NT_STATUS_NOT_IMPLEMENTED
;
400 DEBUG(10, ("notify_remove: private_data=%p\n", private_data
));
402 pid
= messaging_server_id(notify
->msg
);
404 for (listel
=notify
->list
;listel
;listel
=listel
->next
) {
405 if (listel
->private_data
== private_data
) {
406 DLIST_REMOVE(notify
->list
, listel
);
410 if (listel
== NULL
) {
411 DEBUG(10, ("%p not found\n", private_data
));
412 return NT_STATUS_NOT_FOUND
;
414 notify_rec
= dbwrap_fetch_locked(notify
->db_notify
, talloc_tos(),
415 string_tdb_data(listel
->path
));
417 if (notify_rec
== NULL
) {
418 return NT_STATUS_INTERNAL_DB_CORRUPTION
;
420 status
= notify_del_entry(notify_rec
, &pid
, private_data
);
421 DEBUG(10, ("del_entry returned %s\n", nt_errstr(status
)));
422 TALLOC_FREE(notify_rec
);
426 static NTSTATUS
notify_del_entry(struct db_record
*rec
,
427 const struct server_id
*pid
,
430 TDB_DATA value
= dbwrap_record_get_value(rec
);
431 struct notify_db_entry
*entries
;
432 size_t i
, num_entries
;
435 DEBUG(10, ("del_entry called for %s %p\n", procid_str_static(pid
),
438 if ((value
.dsize
% sizeof(struct notify_db_entry
)) != 0) {
439 DEBUG(1, ("Invalid value.dsize = %u\n",
440 (unsigned)value
.dsize
));
441 return NT_STATUS_INTERNAL_DB_CORRUPTION
;
443 num_entries
= value
.dsize
/ sizeof(struct notify_db_entry
);
444 entries
= (struct notify_db_entry
*)value
.dptr
;
446 for (i
=0; i
<num_entries
; i
++) {
447 struct notify_db_entry
*e
= &entries
[i
];
449 if (DEBUGLEVEL
>= 10) {
450 NDR_PRINT_DEBUG(notify_db_entry
, e
);
453 if (e
->private_data
!= private_data
) {
456 if (procid_equal(&e
->server
, pid
)) {
460 if (i
== num_entries
) {
461 return NT_STATUS_NOT_FOUND
;
463 entries
[i
] = entries
[num_entries
-1];
464 value
.dsize
-= sizeof(struct notify_db_entry
);
466 if (value
.dsize
== 0) {
468 value
.dptr
= (uint8_t *)&now
;
469 value
.dsize
= sizeof(now
);
471 return dbwrap_record_store(rec
, value
, 0);
474 struct notify_trigger_index_state
{
481 static void notify_trigger_index_parser(TDB_DATA key
, TDB_DATA data
,
484 struct notify_trigger_index_state
*state
=
485 (struct notify_trigger_index_state
*)private_data
;
487 size_t i
, num_vnns
, num_new_vnns
;
489 if ((data
.dsize
% sizeof(uint32_t)) != 0) {
490 DEBUG(1, ("Invalid record size in notify index db: %u\n",
491 (unsigned)data
.dsize
));
494 new_vnns
= (uint32_t *)data
.dptr
;
495 num_new_vnns
= data
.dsize
/ sizeof(uint32_t);
497 num_vnns
= talloc_array_length(state
->vnns
);
499 for (i
=0; i
<num_new_vnns
; i
++) {
500 if (new_vnns
[i
] == state
->my_vnn
) {
501 state
->found_my_vnn
= true;
505 state
->vnns
= talloc_realloc(state
->mem_ctx
, state
->vnns
, uint32_t,
506 num_vnns
+ num_new_vnns
);
507 if ((num_vnns
+ num_new_vnns
!= 0) && (state
->vnns
== NULL
)) {
508 DEBUG(1, ("talloc_realloc failed\n"));
511 memcpy(&state
->vnns
[num_vnns
], data
.dptr
, data
.dsize
);
514 static int vnn_cmp(const void *p1
, const void *p2
)
516 const uint32_t *vnn1
= (const uint32_t *)p1
;
517 const uint32_t *vnn2
= (const uint32_t *)p2
;
522 if (*vnn1
== *vnn2
) {
528 static bool notify_push_remote_blob(TALLOC_CTX
*mem_ctx
, uint32_t action
,
529 uint32_t filter
, const char *path
,
530 uint8_t **pblob
, size_t *pblob_len
)
532 struct notify_remote_event ev
;
534 enum ndr_err_code ndr_err
;
540 if (DEBUGLEVEL
>= 10) {
541 NDR_PRINT_DEBUG(notify_remote_event
, &ev
);
544 ndr_err
= ndr_push_struct_blob(
546 (ndr_push_flags_fn_t
)ndr_push_notify_remote_event
);
547 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
551 *pblob_len
= data
.length
;
555 static bool notify_pull_remote_blob(TALLOC_CTX
*mem_ctx
,
556 const uint8_t *blob
, size_t blob_len
,
557 uint32_t *paction
, uint32_t *pfilter
,
560 struct notify_remote_event
*ev
;
561 enum ndr_err_code ndr_err
;
564 data
.data
= discard_const_p(uint8_t, blob
);
565 data
.length
= blob_len
;
567 ev
= talloc(mem_ctx
, struct notify_remote_event
);
572 ndr_err
= ndr_pull_struct_blob(
574 (ndr_pull_flags_fn_t
)ndr_pull_notify_remote_event
);
575 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
579 if (DEBUGLEVEL
>= 10) {
580 NDR_PRINT_DEBUG(notify_remote_event
, ev
);
582 *paction
= ev
->action
;
583 *pfilter
= ev
->filter
;
584 *path
= talloc_move(mem_ctx
, (char **)&ev
->path
);
590 void notify_trigger(struct notify_context
*notify
,
591 uint32_t action
, uint32_t filter
, const char *path
)
593 struct ctdbd_connection
*ctdbd_conn
;
594 struct notify_trigger_index_state idx_state
;
595 const char *p
, *next_p
;
598 uint8_t *remote_blob
= NULL
;
599 size_t remote_blob_len
= 0;
601 DEBUG(10, ("notify_trigger called action=0x%x, filter=0x%x, "
602 "path=%s\n", (unsigned)action
, (unsigned)filter
, path
));
604 /* see if change notify is enabled at all */
605 if (notify
== NULL
) {
609 idx_state
.mem_ctx
= talloc_tos();
610 idx_state
.vnns
= NULL
;
611 idx_state
.my_vnn
= get_my_vnn();
613 for (p
= path
; p
!= NULL
; p
= next_p
) {
614 ptrdiff_t path_len
= p
- path
;
617 next_p
= strchr(p
+1, '/');
618 recursive
= (next_p
!= NULL
);
620 idx_state
.found_my_vnn
= false;
624 make_tdb_data((uint8_t *)path
, path_len
),
625 notify_trigger_index_parser
, &idx_state
);
627 if (!idx_state
.found_my_vnn
) {
630 notify_trigger_local(notify
, action
, filter
,
631 path
, path_len
, recursive
);
634 ctdbd_conn
= messaging_ctdbd_connection();
635 if (ctdbd_conn
== NULL
) {
639 num_vnns
= talloc_array_length(idx_state
.vnns
);
640 qsort(idx_state
.vnns
, num_vnns
, sizeof(uint32_t), vnn_cmp
);
642 last_vnn
= 0xffffffff;
645 for (i
=0; i
<num_vnns
; i
++) {
646 uint32_t vnn
= idx_state
.vnns
[i
];
649 if (vnn
== last_vnn
) {
652 if (vnn
== idx_state
.my_vnn
) {
655 if ((remote_blob
== NULL
) &&
656 !notify_push_remote_blob(
657 talloc_tos(), action
, filter
,
658 path
, &remote_blob
, &remote_blob_len
)) {
662 status
= ctdbd_messaging_send_blob(
663 ctdbd_conn
, vnn
, CTDB_SRVID_SAMBA_NOTIFY_PROXY
,
664 remote_blob
, remote_blob_len
);
665 if (!NT_STATUS_IS_OK(status
)) {
666 DEBUG(10, ("ctdbd_messaging_send_blob to vnn %d "
667 "returned %s, ignoring\n", (int)vnn
,
675 TALLOC_FREE(remote_blob
);
676 TALLOC_FREE(idx_state
.vnns
);
679 static void notify_trigger_local(struct notify_context
*notify
,
680 uint32_t action
, uint32_t filter
,
681 const char *path
, size_t path_len
,
685 struct notify_db_entry
*entries
;
686 size_t i
, num_entries
;
689 DEBUG(10, ("notify_trigger_local called for %*s, path_len=%d, "
690 "filter=%d\n", (int)path_len
, path
, (int)path_len
,
693 status
= dbwrap_fetch(
694 notify
->db_notify
, talloc_tos(),
695 make_tdb_data((uint8_t *)path
, path_len
), &data
);
696 if (!NT_STATUS_IS_OK(status
)) {
697 DEBUG(10, ("dbwrap_fetch returned %s\n",
701 if (data
.dsize
== sizeof(time_t)) {
702 DEBUG(10, ("Got deleted record\n"));
705 if ((data
.dsize
% sizeof(struct notify_db_entry
)) != 0) {
706 DEBUG(1, ("Invalid data.dsize = %u\n",
707 (unsigned)data
.dsize
));
711 entries
= (struct notify_db_entry
*)data
.dptr
;
712 num_entries
= data
.dsize
/ sizeof(struct notify_db_entry
);
714 DEBUG(10, ("recursive = %s pathlen=%d (%c)\n",
715 recursive
? "true" : "false", (int)path_len
,
718 for (i
=0; i
<num_entries
; i
++) {
719 struct notify_db_entry
*e
= &entries
[i
];
722 if (DEBUGLEVEL
>= 10) {
723 NDR_PRINT_DEBUG(notify_db_entry
, e
);
726 e_filter
= recursive
? e
->subdir_filter
: e
->filter
;
728 if ((filter
& e_filter
) == 0) {
732 if (!procid_is_local(&e
->server
)) {
733 DEBUG(1, ("internal error: Non-local pid %s in "
735 procid_str_static(&e
->server
)));
739 status
= notify_send(notify
, &e
->server
, path
+ path_len
+ 1,
740 action
, e
->private_data
);
741 if (!NT_STATUS_IS_OK(status
)) {
742 DEBUG(10, ("notify_send returned %s\n",
748 TALLOC_FREE(data
.dptr
);
751 static NTSTATUS
notify_send(struct notify_context
*notify
,
752 struct server_id
*pid
,
753 const char *path
, uint32_t action
,
756 struct notify_event ev
;
759 enum ndr_err_code ndr_err
;
763 ev
.private_data
= private_data
;
765 ndr_err
= ndr_push_struct_blob(
766 &data
, talloc_tos(), &ev
,
767 (ndr_push_flags_fn_t
)ndr_push_notify_event
);
768 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
769 return ndr_map_error2ntstatus(ndr_err
);
771 status
= messaging_send(notify
->msg
, *pid
, MSG_PVFS_NOTIFY
,
773 TALLOC_FREE(data
.data
);
777 static void notify_handler(struct messaging_context
*msg_ctx
,
778 void *private_data
, uint32_t msg_type
,
779 struct server_id server_id
, DATA_BLOB
*data
)
781 struct notify_context
*notify
= talloc_get_type_abort(
782 private_data
, struct notify_context
);
783 enum ndr_err_code ndr_err
;
784 struct notify_event
*n
;
785 struct notify_list
*listel
;
787 n
= talloc(talloc_tos(), struct notify_event
);
789 DEBUG(1, ("talloc failed\n"));
793 ndr_err
= ndr_pull_struct_blob(
794 data
, n
, n
, (ndr_pull_flags_fn_t
)ndr_pull_notify_event
);
795 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
799 if (DEBUGLEVEL
>= 10) {
800 NDR_PRINT_DEBUG(notify_event
, n
);
803 for (listel
=notify
->list
;listel
;listel
=listel
->next
) {
804 if (listel
->private_data
== n
->private_data
) {
805 listel
->callback(listel
->private_data
, n
);
812 struct notify_walk_idx_state
{
813 void (*fn
)(const char *path
,
814 uint32_t *vnns
, size_t num_vnns
,
819 static int notify_walk_idx_fn(struct db_record
*rec
, void *private_data
)
821 struct notify_walk_idx_state
*state
=
822 (struct notify_walk_idx_state
*)private_data
;
826 key
= dbwrap_record_get_key(rec
);
827 value
= dbwrap_record_get_value(rec
);
829 if ((value
.dsize
% sizeof(uint32_t)) != 0) {
830 DEBUG(1, ("invalid value size in notify index db: %u\n",
831 (unsigned)(value
.dsize
)));
835 path
= talloc_strndup(talloc_tos(), (char *)key
.dptr
, key
.dsize
);
837 DEBUG(1, ("talloc_strndup failed\n"));
840 state
->fn(path
, (uint32_t *)value
.dptr
, value
.dsize
/sizeof(uint32_t),
841 state
->private_data
);
846 void notify_walk_idx(struct notify_context
*notify
,
847 void (*fn
)(const char *path
,
848 uint32_t *vnns
, size_t num_vnns
,
852 struct notify_walk_idx_state state
;
854 state
.private_data
= private_data
;
855 dbwrap_traverse_read(notify
->db_index
, notify_walk_idx_fn
, &state
,
859 struct notify_walk_state
{
860 void (*fn
)(const char *path
,
861 struct notify_db_entry
*entries
, size_t num_entries
,
862 time_t deleted_time
, void *private_data
);
866 static int notify_walk_fn(struct db_record
*rec
, void *private_data
)
868 struct notify_walk_state
*state
=
869 (struct notify_walk_state
*)private_data
;
871 struct notify_db_entry
*entries
;
876 key
= dbwrap_record_get_key(rec
);
877 value
= dbwrap_record_get_value(rec
);
879 if (value
.dsize
== sizeof(deleted_time
)) {
880 memcpy(&deleted_time
, value
.dptr
, sizeof(deleted_time
));
884 if ((value
.dsize
% sizeof(struct notify_db_entry
)) != 0) {
885 DEBUG(1, ("invalid value size in notify db: %u\n",
886 (unsigned)(value
.dsize
)));
889 entries
= (struct notify_db_entry
*)value
.dptr
;
890 num_entries
= value
.dsize
/ sizeof(struct notify_db_entry
);
894 path
= talloc_strndup(talloc_tos(), (char *)key
.dptr
, key
.dsize
);
896 DEBUG(1, ("talloc_strndup failed\n"));
899 state
->fn(path
, entries
, num_entries
, deleted_time
,
900 state
->private_data
);
905 void notify_walk(struct notify_context
*notify
,
906 void (*fn
)(const char *path
,
907 struct notify_db_entry
*entries
,
909 time_t deleted_time
, void *private_data
),
912 struct notify_walk_state state
;
914 state
.private_data
= private_data
;
915 dbwrap_traverse_read(notify
->db_notify
, notify_walk_fn
, &state
,
919 struct notify_cleanup_state
{
921 time_t delete_before
;
927 static void notify_cleanup_collect(
928 const char *path
, struct notify_db_entry
*entries
, size_t num_entries
,
929 time_t deleted_time
, void *private_data
)
931 struct notify_cleanup_state
*state
=
932 (struct notify_cleanup_state
*)private_data
;
935 if (num_entries
!= 0) {
938 if (deleted_time
>= state
->delete_before
) {
942 p
= talloc_strdup(state
->mem_ctx
, path
);
944 DEBUG(1, ("talloc_strdup failed\n"));
947 add_to_large_array(state
->mem_ctx
, sizeof(p
), (void *)&p
,
948 &state
->paths
, &state
->num_paths
,
950 if (state
->array_size
== -1) {
955 static bool notify_cleanup_path(struct notify_context
*notify
,
956 const char *path
, time_t delete_before
);
958 void notify_cleanup(struct notify_context
*notify
)
960 struct notify_cleanup_state state
;
961 uint32_t failure_pool
;
964 state
.mem_ctx
= talloc_stackframe();
966 state
.delete_before
= time(NULL
)
967 - lp_parm_int(-1, "smbd", "notify cleanup interval", 60);
969 notify_walk(notify
, notify_cleanup_collect
, &state
);
971 failure_pool
= state
.num_paths
;
973 while (state
.num_paths
!= 0) {
977 * This loop is designed to be as kind as possible to
978 * ctdb. ctdb does not like it if many smbds hammer on a
979 * single record. If on many nodes the cleanup process starts
980 * running, it can happen that all of them need to clean up
981 * records in the same order. This would generate a ctdb
982 * migrate storm on these records. Randomizing the load across
983 * multiple records reduces the load on the individual record.
986 generate_random_buffer((uint8_t *)&idx
, sizeof(idx
));
987 idx
= idx
% state
.num_paths
;
989 if (!notify_cleanup_path(notify
, state
.paths
[idx
],
990 state
.delete_before
)) {
992 * notify_cleanup_path failed, the most likely reason
993 * is that dbwrap_try_fetch_locked failed due to
994 * contention. We allow one failed attempt per deleted
995 * path on average before we give up.
998 if (failure_pool
== 0) {
1000 * Too many failures. We will come back here,
1001 * maybe next time there is less contention.
1007 TALLOC_FREE(state
.paths
[idx
]);
1008 state
.paths
[idx
] = state
.paths
[state
.num_paths
-1];
1009 state
.num_paths
-= 1;
1011 TALLOC_FREE(state
.mem_ctx
);
1014 static bool notify_cleanup_path(struct notify_context
*notify
,
1015 const char *path
, time_t delete_before
)
1017 struct db_record
*notify_rec
= NULL
;
1018 struct db_record
*idx_rec
= NULL
;
1019 TDB_DATA key
= string_tdb_data(path
);
1024 notify_rec
= dbwrap_fetch_locked(notify
->db_notify
, talloc_tos(), key
);
1025 if (notify_rec
== NULL
) {
1026 DEBUG(10, ("Could not fetch notify_rec\n"));
1029 value
= dbwrap_record_get_value(notify_rec
);
1031 if (value
.dsize
!= sizeof(deleted
)) {
1032 DEBUG(10, ("record %s has been re-used\n", path
));
1035 memcpy(&deleted
, value
.dptr
, sizeof(deleted
));
1037 if (deleted
>= delete_before
) {
1038 DEBUG(10, ("record %s too young\n", path
));
1043 * Be kind to ctdb and only try one dmaster migration at most.
1045 idx_rec
= dbwrap_try_fetch_locked(notify
->db_index
, talloc_tos(), key
);
1046 if (idx_rec
== NULL
) {
1047 DEBUG(10, ("Could not fetch idx_rec\n"));
1051 status
= dbwrap_record_delete(notify_rec
);
1052 if (!NT_STATUS_IS_OK(status
)) {
1053 DEBUG(10, ("Could not delete notify_rec: %s\n",
1054 nt_errstr(status
)));
1057 status
= notify_del_idx(idx_rec
, get_my_vnn());
1058 if (!NT_STATUS_IS_OK(status
)) {
1059 DEBUG(10, ("Could not delete idx_rec: %s\n",
1060 nt_errstr(status
)));
1064 TALLOC_FREE(idx_rec
);
1065 TALLOC_FREE(notify_rec
);
1069 static NTSTATUS
notify_del_idx(struct db_record
*rec
, uint32_t vnn
)
1071 TDB_DATA value
= dbwrap_record_get_value(rec
);
1075 if ((value
.dsize
% sizeof(uint32_t)) != 0) {
1076 DEBUG(1, ("Invalid value.dsize = %u\n",
1077 (unsigned)value
.dsize
));
1078 return NT_STATUS_INTERNAL_DB_CORRUPTION
;
1080 num_vnns
= value
.dsize
/ sizeof(uint32_t);
1081 vnns
= (uint32_t *)value
.dptr
;
1083 for (i
=0; i
<num_vnns
; i
++) {
1084 if (vnns
[i
] == vnn
) {
1089 if (i
== num_vnns
) {
1091 * Not found. Should not happen, but okay...
1093 return NT_STATUS_OK
;
1096 memmove(&vnns
[i
], &vnns
[i
+1], sizeof(uint32_t) * (num_vnns
- i
- 1));
1097 value
.dsize
-= sizeof(uint32_t);
1099 if (value
.dsize
== 0) {
1100 return dbwrap_record_delete(rec
);
1102 return dbwrap_record_store(rec
, value
, 0);
1105 struct notify_cluster_proxy_state
{
1106 struct tevent_context
*ev
;
1107 struct notify_context
*notify
;
1108 struct ctdb_msg_channel
*chan
;
1111 static void notify_cluster_proxy_got_chan(struct tevent_req
*subreq
);
1112 static void notify_cluster_proxy_got_msg(struct tevent_req
*subreq
);
1113 static void notify_cluster_proxy_trigger(struct notify_context
*notify
,
1114 uint32_t action
, uint32_t filter
,
1117 struct tevent_req
*notify_cluster_proxy_send(
1118 TALLOC_CTX
*mem_ctx
, struct tevent_context
*ev
,
1119 struct notify_context
*notify
)
1121 struct tevent_req
*req
, *subreq
;
1122 struct notify_cluster_proxy_state
*state
;
1124 req
= tevent_req_create(mem_ctx
, &state
,
1125 struct notify_cluster_proxy_state
);
1130 state
->notify
= notify
;
1132 subreq
= ctdb_msg_channel_init_send(
1133 state
, state
->ev
, lp_ctdbd_socket(),
1134 CTDB_SRVID_SAMBA_NOTIFY_PROXY
);
1135 if (tevent_req_nomem(subreq
, req
)) {
1136 return tevent_req_post(req
, ev
);
1138 tevent_req_set_callback(subreq
, notify_cluster_proxy_got_chan
, req
);
1142 static void notify_cluster_proxy_got_chan(struct tevent_req
*subreq
)
1144 struct tevent_req
*req
= tevent_req_callback_data(
1145 subreq
, struct tevent_req
);
1146 struct notify_cluster_proxy_state
*state
= tevent_req_data(
1147 req
, struct notify_cluster_proxy_state
);
1150 ret
= ctdb_msg_channel_init_recv(subreq
, state
, &state
->chan
);
1151 TALLOC_FREE(subreq
);
1153 tevent_req_error(req
, ret
);
1156 subreq
= ctdb_msg_read_send(state
, state
->ev
, state
->chan
);
1157 if (tevent_req_nomem(subreq
, req
)) {
1160 tevent_req_set_callback(subreq
, notify_cluster_proxy_got_msg
, req
);
1163 static void notify_cluster_proxy_got_msg(struct tevent_req
*subreq
)
1165 struct tevent_req
*req
= tevent_req_callback_data(
1166 subreq
, struct tevent_req
);
1167 struct notify_cluster_proxy_state
*state
= tevent_req_data(
1168 req
, struct notify_cluster_proxy_state
);
1171 uint32_t action
, filter
;
1176 ret
= ctdb_msg_read_recv(subreq
, talloc_tos(), &msg
, &msg_len
);
1177 TALLOC_FREE(subreq
);
1179 tevent_req_error(req
, ret
);
1183 res
= notify_pull_remote_blob(talloc_tos(), msg
, msg_len
,
1184 &action
, &filter
, &path
);
1187 tevent_req_error(req
, EIO
);
1190 notify_cluster_proxy_trigger(state
->notify
, action
, filter
, path
);
1193 subreq
= ctdb_msg_read_send(state
, state
->ev
, state
->chan
);
1194 if (tevent_req_nomem(subreq
, req
)) {
1197 tevent_req_set_callback(subreq
, notify_cluster_proxy_got_msg
, req
);
1200 static void notify_cluster_proxy_trigger(struct notify_context
*notify
,
1201 uint32_t action
, uint32_t filter
,
1204 const char *p
, *next_p
;
1206 for (p
= path
; p
!= NULL
; p
= next_p
) {
1207 ptrdiff_t path_len
= p
- path
;
1210 next_p
= strchr(p
+1, '/');
1211 recursive
= (next_p
!= NULL
);
1213 notify_trigger_local(notify
, action
, filter
,
1214 path
, path_len
, recursive
);
1218 int notify_cluster_proxy_recv(struct tevent_req
*req
)
1222 if (tevent_req_is_unix_error(req
, &err
)) {