Context Navigation

source: branches/samba-3.3.x/source/smbd/oplock.c@ 425

Visit:

Last change on this file since 425 was 224, checked in by Herwig Bauernfeind, 16 years ago
Update Samba 3.3 branch to 3.3.4
File size: 28.1 KB

Line
1	/*
2	Unix SMB/CIFS implementation.
3	oplock processing
4	Copyright (C) Andrew Tridgell 1992-1998
5	Copyright (C) Jeremy Allison 1998 - 2001
6	Copyright (C) Volker Lendecke 2005
7
8	This program is free software; you can redistribute it and/or modify
9	it under the terms of the GNU General Public License as published by
10	the Free Software Foundation; either version 3 of the License, or
11	(at your option) any later version.
12
13	This program is distributed in the hope that it will be useful,
14	but WITHOUT ANY WARRANTY; without even the implied warranty of
15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	GNU General Public License for more details.
17
18	You should have received a copy of the GNU General Public License
19	along with this program. If not, see <http://www.gnu.org/licenses/>.
20	*/
21
22	#define DBGC_CLASS DBGC_LOCKING
23	#include "includes.h"
24
25	/* Current number of oplocks we have outstanding. */
26	static int32 exclusive_oplocks_open = 0;
27	static int32 level_II_oplocks_open = 0;
28	bool global_client_failed_oplock_break = False;
29
30	extern uint32 global_client_caps;
31
32	static struct kernel_oplocks *koplocks;
33
34	/****************************************************************************
35	Get the number of current exclusive oplocks.
36	****************************************************************************/
37
38	int32 get_number_of_exclusive_open_oplocks(void)
39	{
40	return exclusive_oplocks_open;
41	}
42
43	/****************************************************************************
44	Return True if an oplock message is pending.
45	****************************************************************************/
46
47	bool oplock_message_waiting(fd_set *fds)
48	{
49	if (koplocks && koplocks->msg_waiting(fds)) {
50	return True;
51	}
52
53	return False;
54	}
55
56	/****************************************************************************
57	Find out if there are any kernel oplock messages waiting and process them
58	if so. pfds is the fd_set from the main select loop (which contains any
59	kernel oplock fd if that's what the system uses (IRIX). If may be NULL if
60	we're calling this in a shutting down state.
61	****************************************************************************/
62
63	void process_kernel_oplocks(struct messaging_context msg_ctx, fd_set pfds)
64	{
65	/*
66	* We need to check for kernel oplocks before going into the select
67	* here, as the EINTR generated by the linux kernel oplock may have
68	* already been eaten. JRA.
69	*/
70
71	if (!koplocks) {
72	return;
73	}
74
75	while (koplocks->msg_waiting(pfds)) {
76	files_struct *fsp;
77	char msg[MSG_SMB_KERNEL_BREAK_SIZE];
78
79	fsp = koplocks->receive_message(pfds);
80
81	if (fsp == NULL) {
82	DEBUG(3, ("Kernel oplock message announced, but none "
83	"received\n"));
84	return;
85	}
86
87	/* Put the kernel break info into the message. */
88	push_file_id_16(msg, &fsp->file_id);
89	SIVAL(msg,16,fsp->fh->gen_id);
90
91	/* Don't need to be root here as we're only ever
92	sending to ourselves. */
93
94	messaging_send_buf(msg_ctx, procid_self(),
95	MSG_SMB_KERNEL_BREAK,
96	(uint8 *)&msg, MSG_SMB_KERNEL_BREAK_SIZE);
97	}
98	}
99
100	/****************************************************************************
101	Attempt to set an oplock on a file. Always succeeds if kernel oplocks are
102	disabled (just sets flags). Returns True if oplock set.
103	****************************************************************************/
104
105	bool set_file_oplock(files_struct *fsp, int oplock_type)
106	{
107	if ((fsp->oplock_type != NO_OPLOCK) &&
108	(fsp->oplock_type != FAKE_LEVEL_II_OPLOCK) &&
109	koplocks &&
110	!koplocks->set_oplock(fsp, oplock_type)) {
111	return False;
112	}
113
114	fsp->oplock_type = oplock_type;
115	fsp->sent_oplock_break = NO_BREAK_SENT;
116	if (oplock_type == LEVEL_II_OPLOCK) {
117	level_II_oplocks_open++;
118	} else if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
119	exclusive_oplocks_open++;
120	}
121
122	DEBUG(5,("set_file_oplock: granted oplock on file %s, %s/%lu, "
123	"tv_sec = %x, tv_usec = %x\n",
124	fsp->fsp_name, file_id_string_tos(&fsp->file_id),
125	fsp->fh->gen_id, (int)fsp->open_time.tv_sec,
126	(int)fsp->open_time.tv_usec ));
127
128	return True;
129	}
130
131	/****************************************************************************
132	Attempt to release an oplock on a file. Decrements oplock count.
133	****************************************************************************/
134
135	void release_file_oplock(files_struct *fsp)
136	{
137	if ((fsp->oplock_type != NO_OPLOCK) &&
138	(fsp->oplock_type != FAKE_LEVEL_II_OPLOCK) &&
139	koplocks) {
140	koplocks->release_oplock(fsp);
141	}
142
143	if (fsp->oplock_type == LEVEL_II_OPLOCK) {
144	level_II_oplocks_open--;
145	} else if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
146	exclusive_oplocks_open--;
147	}
148
149	SMB_ASSERT(exclusive_oplocks_open>=0);
150	SMB_ASSERT(level_II_oplocks_open>=0);
151
152	if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
153	/* This doesn't matter for close. */
154	fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
155	} else {
156	fsp->oplock_type = NO_OPLOCK;
157	}
158	fsp->sent_oplock_break = NO_BREAK_SENT;
159
160	flush_write_cache(fsp, OPLOCK_RELEASE_FLUSH);
161
162	TALLOC_FREE(fsp->oplock_timeout);
163	}
164
165	/****************************************************************************
166	Attempt to downgrade an oplock on a file. Doesn't decrement oplock count.
167	****************************************************************************/
168
169	static void downgrade_file_oplock(files_struct *fsp)
170	{
171	if (koplocks) {
172	koplocks->release_oplock(fsp);
173	}
174	fsp->oplock_type = LEVEL_II_OPLOCK;
175	exclusive_oplocks_open--;
176	level_II_oplocks_open++;
177	fsp->sent_oplock_break = NO_BREAK_SENT;
178	}
179
180	/****************************************************************************
181	Remove a file oplock. Copes with level II and exclusive.
182	Locks then unlocks the share mode lock. Client can decide to go directly
183	to none even if a "break-to-level II" was sent.
184	****************************************************************************/
185
186	bool remove_oplock(files_struct *fsp)
187	{
188	bool ret;
189	struct share_mode_lock *lck;
190
191	/* Remove the oplock flag from the sharemode. */
192	lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
193	NULL);
194	if (lck == NULL) {
195	DEBUG(0,("remove_oplock: failed to lock share entry for "
196	"file %s\n", fsp->fsp_name ));
197	return False;
198	}
199	ret = remove_share_oplock(lck, fsp);
200	if (!ret) {
201	DEBUG(0,("remove_oplock: failed to remove share oplock for "
202	"file %s fnum %d, %s\n",
203	fsp->fsp_name, fsp->fnum, file_id_string_tos(&fsp->file_id)));
204	}
205	release_file_oplock(fsp);
206	TALLOC_FREE(lck);
207	return ret;
208	}
209
210	/*
211	* Deal with a reply when a break-to-level II was sent.
212	*/
213	bool downgrade_oplock(files_struct *fsp)
214	{
215	bool ret;
216	struct share_mode_lock *lck;
217
218	lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
219	NULL);
220	if (lck == NULL) {
221	DEBUG(0,("downgrade_oplock: failed to lock share entry for "
222	"file %s\n", fsp->fsp_name ));
223	return False;
224	}
225	ret = downgrade_share_oplock(lck, fsp);
226	if (!ret) {
227	DEBUG(0,("downgrade_oplock: failed to downgrade share oplock "
228	"for file %s fnum %d, file_id %s\n",
229	fsp->fsp_name, fsp->fnum, file_id_string_tos(&fsp->file_id)));
230	}
231
232	downgrade_file_oplock(fsp);
233	TALLOC_FREE(lck);
234	return ret;
235	}
236
237	/****************************************************************************
238	Return the fd (if any) used for receiving oplock notifications.
239	****************************************************************************/
240
241	int oplock_notify_fd(void)
242	{
243	if (koplocks) {
244	return koplocks->notification_fd;
245	}
246
247	return -1;
248	}
249
250	/****************************************************************************
251	Set up an oplock break message.
252	****************************************************************************/
253
254	static char new_break_smb_message(TALLOC_CTX mem_ctx,
255	files_struct *fsp, uint8 cmd)
256	{
257	char result = TALLOC_ARRAY(mem_ctx, char, smb_size + 82 + 0);
258
259	if (result == NULL) {
260	DEBUG(0, ("talloc failed\n"));
261	return NULL;
262	}
263
264	memset(result,'\0',smb_size);
265	srv_set_message(result,8,0,true);
266	SCVAL(result,smb_com,SMBlockingX);
267	SSVAL(result,smb_tid,fsp->conn->cnum);
268	SSVAL(result,smb_pid,0xFFFF);
269	SSVAL(result,smb_uid,0);
270	SSVAL(result,smb_mid,0xFFFF);
271	SCVAL(result,smb_vwv0,0xFF);
272	SSVAL(result,smb_vwv2,fsp->fnum);
273	SCVAL(result,smb_vwv3,LOCKING_ANDX_OPLOCK_RELEASE);
274	SCVAL(result,smb_vwv3+1,cmd);
275	return result;
276	}
277
278	/****************************************************************************
279	Function to do the waiting before sending a local break.
280	****************************************************************************/
281
282	static void wait_before_sending_break(void)
283	{
284	long wait_time = (long)lp_oplock_break_wait_time();
285
286	if (wait_time) {
287	smb_msleep(wait_time);
288	}
289	}
290
291	/****************************************************************************
292	Ensure that we have a valid oplock.
293	****************************************************************************/
294
295	static files_struct *initial_break_processing(struct file_id id, unsigned long file_id)
296	{
297	files_struct *fsp = NULL;
298
299	if( DEBUGLVL( 3 ) ) {
300	dbgtext( "initial_break_processing: called for %s/%u\n",
301	file_id_string_tos(&id), (int)file_id);
302	dbgtext( "Current oplocks_open (exclusive = %d, levelII = %d)\n",
303	exclusive_oplocks_open, level_II_oplocks_open );
304	}
305
306	/*
307	* We need to search the file open table for the
308	* entry containing this dev and inode, and ensure
309	* we have an oplock on it.
310	*/
311
312	fsp = file_find_dif(id, file_id);
313
314	if(fsp == NULL) {
315	/* The file could have been closed in the meantime - return success. */
316	if( DEBUGLVL( 3 ) ) {
317	dbgtext( "initial_break_processing: cannot find open file with " );
318	dbgtext( "file_id %s gen_id = %lu", file_id_string_tos(&id), file_id);
319	dbgtext( "allowing break to succeed.\n" );
320	}
321	return NULL;
322	}
323
324	/* Ensure we have an oplock on the file */
325
326	/*
327	* There is a potential race condition in that an oplock could
328	* have been broken due to another udp request, and yet there are
329	* still oplock break messages being sent in the udp message
330	* queue for this file. So return true if we don't have an oplock,
331	* as we may have just freed it.
332	*/
333
334	if(fsp->oplock_type == NO_OPLOCK) {
335	if( DEBUGLVL( 3 ) ) {
336	dbgtext( "initial_break_processing: file %s ", fsp->fsp_name );
337	dbgtext( "(file_id = %s gen_id = %lu) has no oplock.\n",
338	file_id_string_tos(&id), fsp->fh->gen_id );
339	dbgtext( "Allowing break to succeed regardless.\n" );
340	}
341	return NULL;
342	}
343
344	return fsp;
345	}
346
347	static void oplock_timeout_handler(struct event_context *ctx,
348	struct timed_event *te,
349	struct timeval now,
350	void *private_data)
351	{
352	files_struct fsp = (files_struct )private_data;
353
354	/* Remove the timed event handler. */
355	TALLOC_FREE(fsp->oplock_timeout);
356	DEBUG(0, ("Oplock break failed for file %s -- replying anyway\n", fsp->fsp_name));
357	global_client_failed_oplock_break = True;
358	remove_oplock(fsp);
359	reply_to_oplock_break_requests(fsp);
360	}
361
362	/*******************************************************************
363	Add a timeout handler waiting for the client reply.
364	*******************************************************************/
365
366	static void add_oplock_timeout_handler(files_struct *fsp)
367	{
368	if (fsp->oplock_timeout != NULL) {
369	DEBUG(0, ("Logic problem -- have an oplock event hanging "
370	"around\n"));
371	}
372
373	fsp->oplock_timeout =
374	event_add_timed(smbd_event_context(), NULL,
375	timeval_current_ofs(OPLOCK_BREAK_TIMEOUT, 0),
376	oplock_timeout_handler, fsp);
377
378	if (fsp->oplock_timeout == NULL) {
379	DEBUG(0, ("Could not add oplock timeout handler\n"));
380	}
381	}
382
383	/*******************************************************************
384	This handles the case of a write triggering a break to none
385	message on a level2 oplock.
386	When we get this message we may be in any of three states :
387	NO_OPLOCK, LEVEL_II, FAKE_LEVEL2. We only send a message to
388	the client for LEVEL2.
389	*******************************************************************/
390
391	static void process_oplock_async_level2_break_message(struct messaging_context *msg_ctx,
392	void *private_data,
393	uint32_t msg_type,
394	struct server_id src,
395	DATA_BLOB *data)
396	{
397	struct share_mode_entry msg;
398	files_struct *fsp;
399	char *break_msg;
400	bool sign_state;
401
402	if (data->data == NULL) {
403	DEBUG(0, ("Got NULL buffer\n"));
404	return;
405	}
406
407	if (data->length != MSG_SMB_SHARE_MODE_ENTRY_SIZE) {
408	DEBUG(0, ("Got invalid msg len %d\n", (int)data->length));
409	return;
410	}
411
412	/* De-linearize incoming message. */
413	message_to_share_mode_entry(&msg, (char *)data->data);
414
415	DEBUG(10, ("Got oplock async level 2 break message from pid %s: "
416	"%s/%lu\n", procid_str(debug_ctx(), &src),
417	file_id_string_tos(&msg.id), msg.share_file_id));
418
419	fsp = initial_break_processing(msg.id, msg.share_file_id);
420
421	if (fsp == NULL) {
422	/* We hit a race here. Break messages are sent, and before we
423	* get to process this message, we have closed the file.
424	* No need to reply as this is an async message. */
425	DEBUG(3, ("process_oplock_async_level2_break_message: Did not find fsp, ignoring\n"));
426	return;
427	}
428
429	if (fsp->oplock_type == NO_OPLOCK) {
430	/* We already got a "break to none" message and we've handled it.
431	* just ignore. */
432	DEBUG(3, ("process_oplock_async_level2_break_message: already broken to none, ignoring.\n"));
433	return;
434	}
435
436	if (fsp->oplock_type == FAKE_LEVEL_II_OPLOCK) {
437	/* Don't tell the client, just downgrade. */
438	DEBUG(3, ("process_oplock_async_level2_break_message: downgrading fake level 2 oplock.\n"));
439	remove_oplock(fsp);
440	return;
441	}
442
443	/* Ensure we're really at level2 state. */
444	SMB_ASSERT(fsp->oplock_type == LEVEL_II_OPLOCK);
445
446	DEBUG(10,("process_oplock_async_level2_break_message: sending break to "
447	"none message for fid %d, file %s\n",
448	fsp->fnum,
449	fsp->fsp_name));
450
451	/* Now send a break to none message to our client. */
452
453	break_msg = new_break_smb_message(NULL, fsp, OPLOCKLEVEL_NONE);
454	if (break_msg == NULL) {
455	exit_server("Could not talloc break_msg\n");
456	}
457
458	/* Need to wait before sending a break message if we sent ourselves this message. */
459	if (procid_is_me(&src)) {
460	wait_before_sending_break();
461	}
462
463	/* Save the server smb signing state. */
464	sign_state = srv_oplock_set_signing(False);
465
466	show_msg(break_msg);
467	if (!srv_send_smb(smbd_server_fd(),
468	break_msg,
469	IS_CONN_ENCRYPTED(fsp->conn))) {
470	exit_server_cleanly("oplock_break: srv_send_smb failed.");
471	}
472
473	/* Restore the sign state to what it was. */
474	srv_oplock_set_signing(sign_state);
475
476	TALLOC_FREE(break_msg);
477
478	/* Async level2 request, don't send a reply, just remove the oplock. */
479	remove_oplock(fsp);
480	}
481
482	/*******************************************************************
483	This handles the generic oplock break message from another smbd.
484	*******************************************************************/
485
486	static void process_oplock_break_message(struct messaging_context *msg_ctx,
487	void *private_data,
488	uint32_t msg_type,
489	struct server_id src,
490	DATA_BLOB *data)
491	{
492	struct share_mode_entry msg;
493	files_struct *fsp;
494	char *break_msg;
495	bool break_to_level2 = False;
496	bool sign_state;
497
498	if (data->data == NULL) {
499	DEBUG(0, ("Got NULL buffer\n"));
500	return;
501	}
502
503	if (data->length != MSG_SMB_SHARE_MODE_ENTRY_SIZE) {
504	DEBUG(0, ("Got invalid msg len %d\n", (int)data->length));
505	return;
506	}
507
508	/* De-linearize incoming message. */
509	message_to_share_mode_entry(&msg, (char *)data->data);
510
511	DEBUG(10, ("Got oplock break message from pid %s: %s/%lu\n",
512	procid_str(debug_ctx(), &src), file_id_string_tos(&msg.id),
513	msg.share_file_id));
514
515	fsp = initial_break_processing(msg.id, msg.share_file_id);
516
517	if (fsp == NULL) {
518	/* a We hit race here. Break messages are sent, and before we
519	* get to process this message, we have closed the file. Reply
520	* with 'ok, oplock broken' */
521	DEBUG(3, ("Did not find fsp\n"));
522
523	/* We just send the same message back. */
524	messaging_send_buf(msg_ctx, src, MSG_SMB_BREAK_RESPONSE,
525	(uint8 *)data->data,
526	MSG_SMB_SHARE_MODE_ENTRY_SIZE);
527	return;
528	}
529
530	if (fsp->sent_oplock_break != NO_BREAK_SENT) {
531	/* Remember we have to inform the requesting PID when the
532	* client replies */
533	msg.pid = src;
534	ADD_TO_ARRAY(NULL, struct share_mode_entry, msg,
535	&fsp->pending_break_messages,
536	&fsp->num_pending_break_messages);
537	return;
538	}
539
540	if (EXCLUSIVE_OPLOCK_TYPE(msg.op_type) &&
541	!EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
542	DEBUG(3, ("Already downgraded oplock on %s: %s\n",
543	file_id_string_tos(&fsp->file_id),
544	fsp->fsp_name));
545	/* We just send the same message back. */
546	messaging_send_buf(msg_ctx, src, MSG_SMB_BREAK_RESPONSE,
547	(uint8 *)data->data,
548	MSG_SMB_SHARE_MODE_ENTRY_SIZE);
549	return;
550	}
551
552	if ((global_client_caps & CAP_LEVEL_II_OPLOCKS) &&
553	!(msg.op_type & FORCE_OPLOCK_BREAK_TO_NONE) &&
554	!koplocks && /* NOTE: we force levelII off for kernel oplocks -
555	* this will change when it is supported */
556	lp_level2_oplocks(SNUM(fsp->conn))) {
557	break_to_level2 = True;
558	}
559
560	break_msg = new_break_smb_message(NULL, fsp, break_to_level2 ?
561	OPLOCKLEVEL_II : OPLOCKLEVEL_NONE);
562	if (break_msg == NULL) {
563	exit_server("Could not talloc break_msg\n");
564	}
565
566	/* Need to wait before sending a break message if we sent ourselves this message. */
567	if (procid_is_me(&src)) {
568	wait_before_sending_break();
569	}
570
571	/* Save the server smb signing state. */
572	sign_state = srv_oplock_set_signing(False);
573
574	show_msg(break_msg);
575	if (!srv_send_smb(smbd_server_fd(),
576	break_msg,
577	IS_CONN_ENCRYPTED(fsp->conn))) {
578	exit_server_cleanly("oplock_break: srv_send_smb failed.");
579	}
580
581	/* Restore the sign state to what it was. */
582	srv_oplock_set_signing(sign_state);
583
584	TALLOC_FREE(break_msg);
585
586	fsp->sent_oplock_break = break_to_level2 ? LEVEL_II_BREAK_SENT:BREAK_TO_NONE_SENT;
587
588	msg.pid = src;
589	ADD_TO_ARRAY(NULL, struct share_mode_entry, msg,
590	&fsp->pending_break_messages,
591	&fsp->num_pending_break_messages);
592
593	add_oplock_timeout_handler(fsp);
594	}
595
596	/*******************************************************************
597	This handles the kernel oplock break message.
598	*******************************************************************/
599
600	static void process_kernel_oplock_break(struct messaging_context *msg_ctx,
601	void *private_data,
602	uint32_t msg_type,
603	struct server_id src,
604	DATA_BLOB *data)
605	{
606	struct file_id id;
607	unsigned long file_id;
608	files_struct *fsp;
609	char *break_msg;
610	bool sign_state;
611
612	if (data->data == NULL) {
613	DEBUG(0, ("Got NULL buffer\n"));
614	return;
615	}
616
617	if (data->length != MSG_SMB_KERNEL_BREAK_SIZE) {
618	DEBUG(0, ("Got invalid msg len %d\n", (int)data->length));
619	return;
620	}
621
622	/* Pull the data from the message. */
623	pull_file_id_16((char *)data->data, &id);
624	file_id = (unsigned long)IVAL(data->data, 16);
625
626	DEBUG(10, ("Got kernel oplock break message from pid %s: %s/%u\n",
627	procid_str(debug_ctx(), &src), file_id_string_tos(&id),
628	(unsigned int)file_id));
629
630	fsp = initial_break_processing(id, file_id);
631
632	if (fsp == NULL) {
633	DEBUG(3, ("Got a kernel oplock break message for a file "
634	"I don't know about\n"));
635	return;
636	}
637
638	if (fsp->sent_oplock_break != NO_BREAK_SENT) {
639	/* This is ok, kernel oplocks come in completely async */
640	DEBUG(3, ("Got a kernel oplock request while waiting for a "
641	"break reply\n"));
642	return;
643	}
644
645	break_msg = new_break_smb_message(NULL, fsp, OPLOCKLEVEL_NONE);
646	if (break_msg == NULL) {
647	exit_server("Could not talloc break_msg\n");
648	}
649
650	/* Save the server smb signing state. */
651	sign_state = srv_oplock_set_signing(False);
652
653	show_msg(break_msg);
654	if (!srv_send_smb(smbd_server_fd(),
655	break_msg,
656	IS_CONN_ENCRYPTED(fsp->conn))) {
657	exit_server_cleanly("oplock_break: srv_send_smb failed.");
658	}
659
660	/* Restore the sign state to what it was. */
661	srv_oplock_set_signing(sign_state);
662
663	TALLOC_FREE(break_msg);
664
665	fsp->sent_oplock_break = BREAK_TO_NONE_SENT;
666
667	add_oplock_timeout_handler(fsp);
668	}
669
670	void reply_to_oplock_break_requests(files_struct *fsp)
671	{
672	int i;
673
674	for (i=0; i<fsp->num_pending_break_messages; i++) {
675	struct share_mode_entry *e = &fsp->pending_break_messages[i];
676	char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
677
678	share_mode_entry_to_message(msg, e);
679
680	messaging_send_buf(smbd_messaging_context(), e->pid,
681	MSG_SMB_BREAK_RESPONSE,
682	(uint8 *)msg,
683	MSG_SMB_SHARE_MODE_ENTRY_SIZE);
684	}
685
686	SAFE_FREE(fsp->pending_break_messages);
687	fsp->num_pending_break_messages = 0;
688	if (fsp->oplock_timeout != NULL) {
689	/* Remove the timed event handler. */
690	TALLOC_FREE(fsp->oplock_timeout);
691	fsp->oplock_timeout = NULL;
692	}
693	return;
694	}
695
696	static void process_oplock_break_response(struct messaging_context *msg_ctx,
697	void *private_data,
698	uint32_t msg_type,
699	struct server_id src,
700	DATA_BLOB *data)
701	{
702	struct share_mode_entry msg;
703
704	if (data->data == NULL) {
705	DEBUG(0, ("Got NULL buffer\n"));
706	return;
707	}
708
709	if (data->length != MSG_SMB_SHARE_MODE_ENTRY_SIZE) {
710	DEBUG(0, ("Got invalid msg len %u\n",
711	(unsigned int)data->length));
712	return;
713	}
714
715	/* De-linearize incoming message. */
716	message_to_share_mode_entry(&msg, (char *)data->data);
717
718	DEBUG(10, ("Got oplock break response from pid %s: %s/%lu mid %u\n",
719	procid_str(debug_ctx(), &src), file_id_string_tos(&msg.id),
720	msg.share_file_id, (unsigned int)msg.op_mid));
721
722	/* Here's the hack from open.c, store the mid in the 'port' field */
723	schedule_deferred_open_smb_message(msg.op_mid);
724	}
725
726	static void process_open_retry_message(struct messaging_context *msg_ctx,
727	void *private_data,
728	uint32_t msg_type,
729	struct server_id src,
730	DATA_BLOB *data)
731	{
732	struct share_mode_entry msg;
733
734	if (data->data == NULL) {
735	DEBUG(0, ("Got NULL buffer\n"));
736	return;
737	}
738
739	if (data->length != MSG_SMB_SHARE_MODE_ENTRY_SIZE) {
740	DEBUG(0, ("Got invalid msg len %d\n", (int)data->length));
741	return;
742	}
743
744	/* De-linearize incoming message. */
745	message_to_share_mode_entry(&msg, (char *)data->data);
746
747	DEBUG(10, ("Got open retry msg from pid %s: %s mid %u\n",
748	procid_str(debug_ctx(), &src), file_id_string_tos(&msg.id),
749	(unsigned int)msg.op_mid));
750
751	schedule_deferred_open_smb_message(msg.op_mid);
752	}
753
754	/****************************************************************************
755	This function is called on any file modification or lock request. If a file
756	is level 2 oplocked then it must tell all other level 2 holders to break to
757	none.
758	****************************************************************************/
759
760	void release_level_2_oplocks_on_change(files_struct *fsp)
761	{
762	int i;
763	struct share_mode_lock *lck;
764
765	/*
766	* If this file is level II oplocked then we need
767	* to grab the shared memory lock and inform all
768	* other files with a level II lock that they need
769	* to flush their read caches. We keep the lock over
770	* the shared memory area whilst doing this.
771	*/
772
773	if (!LEVEL_II_OPLOCK_TYPE(fsp->oplock_type))
774	return;
775
776	lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
777	NULL);
778	if (lck == NULL) {
779	DEBUG(0,("release_level_2_oplocks_on_change: failed to lock "
780	"share mode entry for file %s.\n", fsp->fsp_name ));
781	return;
782	}
783
784	DEBUG(10,("release_level_2_oplocks_on_change: num_share_modes = %d\n",
785	lck->num_share_modes ));
786
787	for(i = 0; i < lck->num_share_modes; i++) {
788	struct share_mode_entry *share_entry = &lck->share_modes[i];
789	char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
790
791	if (!is_valid_share_mode_entry(share_entry)) {
792	continue;
793	}
794
795	/*
796	* As there could have been multiple writes waiting at the
797	* lock_share_entry gate we may not be the first to
798	* enter. Hence the state of the op_types in the share mode
799	* entries may be partly NO_OPLOCK and partly LEVEL_II or FAKE_LEVEL_II
800	* oplock. It will do no harm to re-send break messages to
801	* those smbd's that are still waiting their turn to remove
802	* their LEVEL_II state, and also no harm to ignore existing
803	* NO_OPLOCK states. JRA.
804	*/
805
806	DEBUG(10,("release_level_2_oplocks_on_change: "
807	"share_entry[%i]->op_type == %d\n",
808	i, share_entry->op_type ));
809
810	if (share_entry->op_type == NO_OPLOCK) {
811	continue;
812	}
813
814	/* Paranoia .... */
815	if (EXCLUSIVE_OPLOCK_TYPE(share_entry->op_type)) {
816	DEBUG(0,("release_level_2_oplocks_on_change: PANIC. "
817	"share mode entry %d is an exlusive "
818	"oplock !\n", i ));
819	TALLOC_FREE(lck);
820	abort();
821	}
822
823	share_mode_entry_to_message(msg, share_entry);
824
825	/*
826	* Deal with a race condition when breaking level2
827	* oplocks. Don't send all the messages and release
828	* the lock, this allows someone else to come in and
829	* get a level2 lock before any of the messages are
830	* processed, and thus miss getting a break message.
831	* Ensure at least one entry (the one we're breaking)
832	* is processed immediately under the lock and becomes
833	* set as NO_OPLOCK to stop any waiter getting a level2.
834	* Bugid #5979.
835	*/
836
837	if (procid_is_me(&share_entry->pid)) {
838	DATA_BLOB blob = data_blob_const(msg,
839	MSG_SMB_SHARE_MODE_ENTRY_SIZE);
840	process_oplock_async_level2_break_message(smbd_messaging_context(),
841	NULL,
842	MSG_SMB_ASYNC_LEVEL2_BREAK,
843	share_entry->pid,
844	&blob);
845	} else {
846	messaging_send_buf(smbd_messaging_context(),
847	share_entry->pid,
848	MSG_SMB_ASYNC_LEVEL2_BREAK,
849	(uint8 *)msg,
850	MSG_SMB_SHARE_MODE_ENTRY_SIZE);
851	}
852	}
853
854	/* We let the message receivers handle removing the oplock state
855	in the share mode lock db. */
856
857	TALLOC_FREE(lck);
858	}
859
860	/****************************************************************************
861	Linearize a share mode entry struct to an internal oplock break message.
862	****************************************************************************/
863
864	void share_mode_entry_to_message(char msg, const struct share_mode_entry e)
865	{
866	SIVAL(msg,0,(uint32)e->pid.pid);
867	SSVAL(msg,4,e->op_mid);
868	SSVAL(msg,6,e->op_type);
869	SIVAL(msg,8,e->access_mask);
870	SIVAL(msg,12,e->share_access);
871	SIVAL(msg,16,e->private_options);
872	SIVAL(msg,20,(uint32)e->time.tv_sec);
873	SIVAL(msg,24,(uint32)e->time.tv_usec);
874	push_file_id_16(msg+28, &e->id);
875	SIVAL(msg,44,e->share_file_id);
876	SIVAL(msg,48,e->uid);
877	SSVAL(msg,52,e->flags);
878	#ifdef CLUSTER_SUPPORT
879	SIVAL(msg,54,e->pid.vnn);
880	#endif
881	}
882
883	/****************************************************************************
884	De-linearize an internal oplock break message to a share mode entry struct.
885	****************************************************************************/
886
887	void message_to_share_mode_entry(struct share_mode_entry e, char msg)
888	{
889	e->pid.pid = (pid_t)IVAL(msg,0);
890	e->op_mid = SVAL(msg,4);
891	e->op_type = SVAL(msg,6);
892	e->access_mask = IVAL(msg,8);
893	e->share_access = IVAL(msg,12);
894	e->private_options = IVAL(msg,16);
895	e->time.tv_sec = (time_t)IVAL(msg,20);
896	e->time.tv_usec = (int)IVAL(msg,24);
897	pull_file_id_16(msg+28, &e->id);
898	e->share_file_id = (unsigned long)IVAL(msg,44);
899	e->uid = (uint32)IVAL(msg,48);
900	e->flags = (uint16)SVAL(msg,52);
901	#ifdef CLUSTER_SUPPORT
902	e->pid.vnn = IVAL(msg,54);
903	#endif
904	}
905
906	/****************************************************************************
907	Setup oplocks for this process.
908	****************************************************************************/
909
910	bool init_oplocks(struct messaging_context *msg_ctx)
911	{
912	DEBUG(3,("init_oplocks: initializing messages.\n"));
913
914	messaging_register(msg_ctx, NULL, MSG_SMB_BREAK_REQUEST,
915	process_oplock_break_message);
916	messaging_register(msg_ctx, NULL, MSG_SMB_ASYNC_LEVEL2_BREAK,
917	process_oplock_async_level2_break_message);
918	messaging_register(msg_ctx, NULL, MSG_SMB_BREAK_RESPONSE,
919	process_oplock_break_response);
920	messaging_register(msg_ctx, NULL, MSG_SMB_KERNEL_BREAK,
921	process_kernel_oplock_break);
922	messaging_register(msg_ctx, NULL, MSG_SMB_OPEN_RETRY,
923	process_open_retry_message);
924
925	if (lp_kernel_oplocks()) {
926	#if HAVE_KERNEL_OPLOCKS_IRIX
927	koplocks = irix_init_kernel_oplocks();
928	#elif HAVE_KERNEL_OPLOCKS_LINUX
929	koplocks = linux_init_kernel_oplocks();
930	#endif
931	}
932
933	return True;
934	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: