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