1998-08-17 17:11:34 +04:00
/*
2002-01-30 09:08:46 +03:00
Unix SMB / CIFS implementation .
1998-08-17 17:11:34 +04:00
oplock processing
Copyright ( C ) Andrew Tridgell 1992 - 1998
2001-10-21 01:59:34 +04:00
Copyright ( C ) Jeremy Allison 1998 - 2001
2005-09-30 21:13:37 +04:00
Copyright ( C ) Volker Lendecke 2005
1998-08-17 17:11:34 +04:00
This program is free software ; you can redistribute it and / or modify
it under the terms of the GNU General Public License as published by
2007-07-09 23:25:36 +04:00
the Free Software Foundation ; either version 3 of the License , or
1998-08-17 17:11:34 +04:00
( at your option ) any later version .
This program is distributed in the hope that it will be useful ,
but WITHOUT ANY WARRANTY ; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
GNU General Public License for more details .
You should have received a copy of the GNU General Public License
2007-07-10 04:52:41 +04:00
along with this program . If not , see < http : //www.gnu.org/licenses/>.
1998-08-17 17:11:34 +04:00
*/
2006-05-05 06:06:37 +04:00
# define DBGC_CLASS DBGC_LOCKING
1998-08-17 17:11:34 +04:00
# include "includes.h"
1998-08-17 17:44:05 +04:00
/* Current number of oplocks we have outstanding. */
1999-12-13 16:27:58 +03:00
static int32 exclusive_oplocks_open = 0 ;
static int32 level_II_oplocks_open = 0 ;
2007-10-19 04:40:25 +04:00
bool global_client_failed_oplock_break = False ;
1998-08-17 17:44:05 +04:00
2005-04-06 20:28:04 +04:00
extern uint32 global_client_caps ;
1998-08-17 17:11:34 +04:00
2000-06-10 17:38:07 +04:00
static struct kernel_oplocks * koplocks ;
1999-12-13 16:27:58 +03:00
/****************************************************************************
Get the number of current exclusive oplocks .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int32 get_number_of_exclusive_open_oplocks ( void )
{
return exclusive_oplocks_open ;
}
1998-09-05 09:07:05 +04:00
2001-09-06 02:45:48 +04:00
/****************************************************************************
Return True if an oplock message is pending .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-10-19 04:40:25 +04:00
bool oplock_message_waiting ( fd_set * fds )
2001-09-06 02:45:48 +04:00
{
2006-01-13 01:17:54 +03:00
if ( koplocks & & koplocks - > msg_waiting ( fds ) ) {
2001-09-06 02:45:48 +04:00
return True ;
2006-01-13 01:17:54 +03:00
}
2001-09-06 02:45:48 +04:00
return False ;
}
2000-06-09 10:58:06 +04:00
1998-09-23 05:48:45 +04:00
/****************************************************************************
2006-02-15 02:00:39 +03:00
Find out if there are any kernel oplock messages waiting and process them
if so . pfds is the fd_set from the main select loop ( which contains any
kernel oplock fd if that ' s what the system uses ( IRIX ) . If may be NULL if
we ' re calling this in a shutting down state .
1998-09-23 05:48:45 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-05-15 00:31:28 +04:00
void process_kernel_oplocks ( struct messaging_context * msg_ctx , fd_set * pfds )
1998-09-23 05:48:45 +04:00
{
2002-07-15 14:35:28 +04:00
/*
* We need to check for kernel oplocks before going into the select
* here , as the EINTR generated by the linux kernel oplock may have
* already been eaten . JRA .
*/
2005-09-30 21:13:37 +04:00
if ( ! koplocks ) {
return ;
2002-07-15 14:35:28 +04:00
}
2006-02-15 02:00:39 +03:00
while ( koplocks - > msg_waiting ( pfds ) ) {
2005-09-30 21:13:37 +04:00
files_struct * fsp ;
2006-01-13 01:17:54 +03:00
char msg [ MSG_SMB_KERNEL_BREAK_SIZE ] ;
2001-10-21 01:59:34 +04:00
2006-02-15 02:00:39 +03:00
fsp = koplocks - > receive_message ( pfds ) ;
2002-07-15 14:35:28 +04:00
2005-09-30 21:13:37 +04:00
if ( fsp = = NULL ) {
DEBUG ( 3 , ( " Kernel oplock message announced, but none "
" received \n " ) ) ;
return ;
2001-10-21 01:59:34 +04:00
}
2006-01-13 01:17:54 +03:00
/* Put the kernel break info into the message. */
2007-05-29 13:30:34 +04:00
push_file_id_16 ( msg , & fsp - > file_id ) ;
SIVAL ( msg , 16 , fsp - > fh - > gen_id ) ;
2006-01-13 01:17:54 +03:00
/* Don't need to be root here as we're only ever
sending to ourselves . */
2007-05-15 00:31:28 +04:00
messaging_send_buf ( msg_ctx , procid_self ( ) ,
MSG_SMB_KERNEL_BREAK ,
( uint8 * ) & msg , MSG_SMB_KERNEL_BREAK_SIZE ) ;
2001-10-21 01:59:34 +04:00
}
1998-09-23 05:48:45 +04:00
}
1999-12-13 16:27:58 +03:00
/****************************************************************************
Attempt to set an oplock on a file . Always succeeds if kernel oplocks are
disabled ( just sets flags ) . Returns True if oplock set .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2001-10-21 01:59:34 +04:00
2007-10-19 04:40:25 +04:00
bool set_file_oplock ( files_struct * fsp , int oplock_type )
1999-12-13 16:27:58 +03:00
{
2006-01-13 01:17:54 +03:00
if ( koplocks & & ! koplocks - > set_oplock ( fsp , oplock_type ) ) {
2000-06-09 10:58:06 +04:00
return False ;
2006-01-13 01:17:54 +03:00
}
1999-12-13 16:27:58 +03:00
2000-06-09 10:58:06 +04:00
fsp - > oplock_type = oplock_type ;
fsp - > sent_oplock_break = NO_BREAK_SENT ;
2006-01-13 01:17:54 +03:00
if ( oplock_type = = LEVEL_II_OPLOCK ) {
2000-06-09 10:58:06 +04:00
level_II_oplocks_open + + ;
2006-01-13 01:17:54 +03:00
} else {
2000-06-09 10:58:06 +04:00
exclusive_oplocks_open + + ;
2006-01-13 01:17:54 +03:00
}
1999-12-13 16:27:58 +03:00
2007-05-29 13:30:34 +04:00
DEBUG ( 5 , ( " set_file_oplock: granted oplock on file %s, %s/%lu, "
2006-05-05 06:06:37 +04:00
" tv_sec = %x, tv_usec = %x \n " ,
2007-09-10 14:56:07 +04:00
fsp - > fsp_name , file_id_string_tos ( & fsp - > file_id ) ,
2007-05-29 13:30:34 +04:00
fsp - > fh - > gen_id , ( int ) fsp - > open_time . tv_sec ,
2006-05-05 06:06:37 +04:00
( int ) fsp - > open_time . tv_usec ) ) ;
1998-08-17 17:11:34 +04:00
2000-06-09 10:58:06 +04:00
return True ;
1998-08-17 17:11:34 +04:00
}
1999-12-13 16:27:58 +03:00
/****************************************************************************
Attempt to release an oplock on a file . Decrements oplock count .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void release_file_oplock ( files_struct * fsp )
{
2005-09-30 21:13:37 +04:00
if ( ( fsp - > oplock_type ! = NO_OPLOCK ) & &
( fsp - > oplock_type ! = FAKE_LEVEL_II_OPLOCK ) & &
koplocks ) {
2001-10-21 01:59:34 +04:00
koplocks - > release_oplock ( fsp ) ;
2005-09-30 21:13:37 +04:00
}
2000-06-09 10:58:06 +04:00
2006-01-13 01:17:54 +03:00
if ( fsp - > oplock_type = = LEVEL_II_OPLOCK ) {
2000-06-09 10:58:06 +04:00
level_II_oplocks_open - - ;
2006-01-13 01:17:54 +03:00
} else if ( EXCLUSIVE_OPLOCK_TYPE ( fsp - > oplock_type ) ) {
2000-06-09 10:58:06 +04:00
exclusive_oplocks_open - - ;
2006-01-13 01:17:54 +03:00
}
2005-09-30 21:13:37 +04:00
SMB_ASSERT ( exclusive_oplocks_open > = 0 ) ;
SMB_ASSERT ( level_II_oplocks_open > = 0 ) ;
2000-06-09 10:58:06 +04:00
fsp - > oplock_type = NO_OPLOCK ;
fsp - > sent_oplock_break = NO_BREAK_SENT ;
flush_write_cache ( fsp , OPLOCK_RELEASE_FLUSH ) ;
2007-06-22 21:19:08 +04:00
TALLOC_FREE ( fsp - > oplock_timeout ) ;
1999-12-13 16:27:58 +03:00
}
/****************************************************************************
Attempt to downgrade an oplock on a file . Doesn ' t decrement oplock count .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static void downgrade_file_oplock ( files_struct * fsp )
{
2006-01-13 01:17:54 +03:00
if ( koplocks ) {
2001-10-21 01:59:34 +04:00
koplocks - > release_oplock ( fsp ) ;
2006-01-13 01:17:54 +03:00
}
2000-06-10 17:38:07 +04:00
fsp - > oplock_type = LEVEL_II_OPLOCK ;
exclusive_oplocks_open - - ;
level_II_oplocks_open + + ;
fsp - > sent_oplock_break = NO_BREAK_SENT ;
1999-12-13 16:27:58 +03:00
}
/****************************************************************************
Remove a file oplock . Copes with level II and exclusive .
2000-11-16 03:59:18 +03:00
Locks then unlocks the share mode lock . Client can decide to go directly
to none even if a " break-to-level II " was sent .
1999-12-13 16:27:58 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-10-19 04:40:25 +04:00
bool remove_oplock ( files_struct * fsp )
1999-12-13 16:27:58 +03:00
{
2007-10-19 04:40:25 +04:00
bool ret ;
2005-09-30 21:13:37 +04:00
struct share_mode_lock * lck ;
2000-06-10 17:38:07 +04:00
/* Remove the oplock flag from the sharemode. */
2008-03-12 17:32:47 +03:00
lck = get_share_mode_lock ( talloc_tos ( ) , fsp - > file_id , NULL , NULL ,
NULL ) ;
2005-09-30 21:13:37 +04:00
if ( lck = = NULL ) {
DEBUG ( 0 , ( " remove_oplock: failed to lock share entry for "
" file %s \n " , fsp - > fsp_name ) ) ;
2003-04-22 05:12:52 +04:00
return False ;
2000-06-10 17:38:07 +04:00
}
2005-09-30 21:13:37 +04:00
ret = remove_share_oplock ( lck , fsp ) ;
if ( ! ret ) {
DEBUG ( 0 , ( " remove_oplock: failed to remove share oplock for "
2007-05-29 13:30:34 +04:00
" file %s fnum %d, %s \n " ,
2007-09-10 14:56:07 +04:00
fsp - > fsp_name , fsp - > fnum , file_id_string_tos ( & fsp - > file_id ) ) ) ;
2005-09-30 21:13:37 +04:00
}
release_file_oplock ( fsp ) ;
2006-02-20 20:59:58 +03:00
TALLOC_FREE ( lck ) ;
2005-09-30 21:13:37 +04:00
return ret ;
}
1999-12-13 16:27:58 +03:00
2005-09-30 21:13:37 +04:00
/*
* Deal with a reply when a break - to - level II was sent .
*/
2007-10-19 04:40:25 +04:00
bool downgrade_oplock ( files_struct * fsp )
2005-09-30 21:13:37 +04:00
{
2007-10-19 04:40:25 +04:00
bool ret ;
2005-09-30 21:13:37 +04:00
struct share_mode_lock * lck ;
1999-12-13 16:27:58 +03:00
2008-03-12 17:32:47 +03:00
lck = get_share_mode_lock ( talloc_tos ( ) , fsp - > file_id , NULL , NULL ,
NULL ) ;
2005-09-30 21:13:37 +04:00
if ( lck = = NULL ) {
DEBUG ( 0 , ( " downgrade_oplock: failed to lock share entry for "
" file %s \n " , fsp - > fsp_name ) ) ;
return False ;
2000-06-10 17:38:07 +04:00
}
2005-09-30 21:13:37 +04:00
ret = downgrade_share_oplock ( lck , fsp ) ;
if ( ! ret ) {
DEBUG ( 0 , ( " downgrade_oplock: failed to downgrade share oplock "
2007-05-29 13:30:34 +04:00
" for file %s fnum %d, file_id %s \n " ,
2007-09-10 14:56:07 +04:00
fsp - > fsp_name , fsp - > fnum , file_id_string_tos ( & fsp - > file_id ) ) ) ;
2005-09-30 21:13:37 +04:00
}
2006-01-13 01:17:54 +03:00
2005-09-30 21:13:37 +04:00
downgrade_file_oplock ( fsp ) ;
2006-02-20 20:59:58 +03:00
TALLOC_FREE ( lck ) ;
2000-06-10 17:38:07 +04:00
return ret ;
1998-09-23 05:48:45 +04:00
}
/****************************************************************************
2006-02-13 07:07:15 +03:00
Return the fd ( if any ) used for receiving oplock notifications .
1998-09-23 05:48:45 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2006-02-13 07:07:15 +03:00
int oplock_notify_fd ( void )
1998-09-23 05:48:45 +04:00
{
2006-02-13 07:07:15 +03:00
if ( koplocks ) {
return koplocks - > notification_fd ;
2000-06-10 17:38:07 +04:00
}
1998-09-23 05:48:45 +04:00
2006-02-13 07:07:15 +03:00
return - 1 ;
1998-09-23 05:48:45 +04:00
}
/****************************************************************************
2005-09-30 21:13:37 +04:00
Set up an oplock break message .
1998-08-17 17:11:34 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2001-10-21 01:59:34 +04:00
2005-09-30 21:13:37 +04:00
static char * new_break_smb_message ( TALLOC_CTX * mem_ctx ,
2006-01-04 15:48:54 +03:00
files_struct * fsp , uint8 cmd )
1998-08-17 17:11:34 +04:00
{
2005-09-30 21:13:37 +04:00
char * result = TALLOC_ARRAY ( mem_ctx , char , smb_size + 8 * 2 + 0 ) ;
2001-10-21 01:59:34 +04:00
2005-09-30 21:13:37 +04:00
if ( result = = NULL ) {
DEBUG ( 0 , ( " talloc failed \n " ) ) ;
return NULL ;
2001-10-21 01:59:34 +04:00
}
2005-09-30 21:13:37 +04:00
memset ( result , ' \0 ' , smb_size ) ;
2008-01-04 23:56:23 +03:00
srv_set_message ( result , 8 , 0 , true ) ;
2005-09-30 21:13:37 +04:00
SCVAL ( result , smb_com , SMBlockingX ) ;
SSVAL ( result , smb_tid , fsp - > conn - > cnum ) ;
SSVAL ( result , smb_pid , 0xFFFF ) ;
SSVAL ( result , smb_uid , 0 ) ;
SSVAL ( result , smb_mid , 0xFFFF ) ;
SCVAL ( result , smb_vwv0 , 0xFF ) ;
SSVAL ( result , smb_vwv2 , fsp - > fnum ) ;
SCVAL ( result , smb_vwv3 , LOCKING_ANDX_OPLOCK_RELEASE ) ;
SCVAL ( result , smb_vwv3 + 1 , cmd ) ;
return result ;
1999-12-13 16:27:58 +03:00
}
/****************************************************************************
Function to do the waiting before sending a local break .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2005-07-17 13:56:25 +04:00
static void wait_before_sending_break ( void )
1999-12-13 16:27:58 +03:00
{
2006-04-15 08:07:10 +04:00
long wait_time = ( long ) lp_oplock_break_wait_time ( ) ;
1999-12-13 16:27:58 +03:00
2006-04-15 08:07:10 +04:00
if ( wait_time ) {
smb_msleep ( wait_time ) ;
2001-10-21 01:59:34 +04:00
}
1999-12-13 16:27:58 +03:00
}
/****************************************************************************
Ensure that we have a valid oplock .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2001-10-21 01:59:34 +04:00
2007-05-29 13:30:34 +04:00
static files_struct * initial_break_processing ( struct file_id id , unsigned long file_id )
1998-08-17 17:11:34 +04:00
{
2001-10-21 01:59:34 +04:00
files_struct * fsp = NULL ;
if ( DEBUGLVL ( 3 ) ) {
2007-05-29 13:30:34 +04:00
dbgtext ( " initial_break_processing: called for %s/%u \n " ,
2007-09-10 14:56:07 +04:00
file_id_string_tos ( & id ) , ( int ) file_id ) ;
2001-10-21 01:59:34 +04:00
dbgtext ( " Current oplocks_open (exclusive = %d, levelII = %d) \n " ,
exclusive_oplocks_open , level_II_oplocks_open ) ;
}
/*
* We need to search the file open table for the
* entry containing this dev and inode , and ensure
* we have an oplock on it .
*/
2007-05-29 13:30:34 +04:00
fsp = file_find_dif ( id , file_id ) ;
2001-10-21 01:59:34 +04:00
if ( fsp = = NULL ) {
/* The file could have been closed in the meantime - return success. */
if ( DEBUGLVL ( 3 ) ) {
dbgtext ( " initial_break_processing: cannot find open file with " ) ;
2007-09-10 14:56:07 +04:00
dbgtext ( " file_id %s gen_id = %lu " , file_id_string_tos ( & id ) , file_id ) ;
2001-10-21 01:59:34 +04:00
dbgtext ( " allowing break to succeed. \n " ) ;
}
return NULL ;
}
/* Ensure we have an oplock on the file */
/*
* There is a potential race condition in that an oplock could
* have been broken due to another udp request , and yet there are
* still oplock break messages being sent in the udp message
* queue for this file . So return true if we don ' t have an oplock ,
* as we may have just freed it .
*/
if ( fsp - > oplock_type = = NO_OPLOCK ) {
if ( DEBUGLVL ( 3 ) ) {
dbgtext ( " initial_break_processing: file %s " , fsp - > fsp_name ) ;
2007-05-29 13:30:34 +04:00
dbgtext ( " (file_id = %s gen_id = %lu) has no oplock. \n " ,
2007-09-10 14:56:07 +04:00
file_id_string_tos ( & id ) , fsp - > fh - > gen_id ) ;
2001-10-21 01:59:34 +04:00
dbgtext ( " Allowing break to succeed regardless. \n " ) ;
}
return NULL ;
}
return fsp ;
1999-12-13 16:27:58 +03:00
}
2007-01-17 15:59:14 +03:00
static void oplock_timeout_handler ( struct event_context * ctx ,
struct timed_event * te ,
2005-09-30 21:13:37 +04:00
const struct timeval * now ,
void * private_data )
1999-12-13 16:27:58 +03:00
{
2006-08-08 13:56:38 +04:00
files_struct * fsp = ( files_struct * ) private_data ;
2004-06-12 03:54:52 +04:00
2007-06-22 21:19:08 +04:00
/* Remove the timed event handler. */
TALLOC_FREE ( fsp - > oplock_timeout ) ;
2006-01-28 02:30:30 +03:00
DEBUG ( 0 , ( " Oplock break failed for file %s -- replying anyway \n " , fsp - > fsp_name ) ) ;
2005-09-30 21:13:37 +04:00
global_client_failed_oplock_break = True ;
remove_oplock ( fsp ) ;
reply_to_oplock_break_requests ( fsp ) ;
1999-12-13 16:27:58 +03:00
}
2006-01-28 02:30:30 +03:00
/*******************************************************************
Add a timeout handler waiting for the client reply .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static void add_oplock_timeout_handler ( files_struct * fsp )
{
if ( fsp - > oplock_timeout ! = NULL ) {
DEBUG ( 0 , ( " Logic problem -- have an oplock event hanging "
" around \n " ) ) ;
}
fsp - > oplock_timeout =
2007-01-17 15:59:14 +03:00
event_add_timed ( smbd_event_context ( ) , NULL ,
2006-01-28 02:30:30 +03:00
timeval_current_ofs ( OPLOCK_BREAK_TIMEOUT , 0 ) ,
" oplock_timeout_handler " ,
oplock_timeout_handler , fsp ) ;
if ( fsp - > oplock_timeout = = NULL ) {
DEBUG ( 0 , ( " Could not add oplock timeout handler \n " ) ) ;
}
}
/*******************************************************************
This handles the case of a write triggering a break to none
message on a level2 oplock .
When we get this message we may be in any of three states :
NO_OPLOCK , LEVEL_II , FAKE_LEVEL2 . We only send a message to
the client for LEVEL2 .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-05-15 00:31:28 +04:00
static void process_oplock_async_level2_break_message ( struct messaging_context * msg_ctx ,
void * private_data ,
uint32_t msg_type ,
struct server_id src ,
DATA_BLOB * data )
2006-01-28 02:30:30 +03:00
{
struct share_mode_entry msg ;
files_struct * fsp ;
char * break_msg ;
2007-10-19 04:40:25 +04:00
bool sign_state ;
2006-01-28 02:30:30 +03:00
2007-05-15 00:31:28 +04:00
if ( data - > data = = NULL ) {
2006-01-28 02:30:30 +03:00
DEBUG ( 0 , ( " Got NULL buffer \n " ) ) ;
return ;
}
2007-05-15 00:31:28 +04:00
if ( data - > length ! = MSG_SMB_SHARE_MODE_ENTRY_SIZE ) {
DEBUG ( 0 , ( " Got invalid msg len %d \n " , ( int ) data - > length ) ) ;
2006-01-28 02:30:30 +03:00
return ;
}
/* De-linearize incoming message. */
2007-05-15 00:31:28 +04:00
message_to_share_mode_entry ( & msg , ( char * ) data - > data ) ;
2006-01-28 02:30:30 +03:00
2007-05-29 13:30:34 +04:00
DEBUG ( 10 , ( " Got oplock async level 2 break message from pid %d: %s/%lu \n " ,
2007-09-10 14:56:07 +04:00
( int ) procid_to_pid ( & src ) , file_id_string_tos ( & msg . id ) , msg . share_file_id ) ) ;
2006-01-28 02:30:30 +03:00
2007-05-29 13:30:34 +04:00
fsp = initial_break_processing ( msg . id , msg . share_file_id ) ;
2006-01-28 02:30:30 +03:00
if ( fsp = = NULL ) {
/* We hit a race here. Break messages are sent, and before we
* get to process this message , we have closed the file .
* No need to reply as this is an async message . */
DEBUG ( 3 , ( " process_oplock_async_level2_break_message: Did not find fsp, ignoring \n " ) ) ;
return ;
}
if ( fsp - > oplock_type = = NO_OPLOCK ) {
/* We already got a "break to none" message and we've handled it.
* just ignore . */
DEBUG ( 3 , ( " process_oplock_async_level2_break_message: already broken to none, ignoring. \n " ) ) ;
return ;
}
if ( fsp - > oplock_type = = FAKE_LEVEL_II_OPLOCK ) {
/* Don't tell the client, just downgrade. */
DEBUG ( 3 , ( " process_oplock_async_level2_break_message: downgrading fake level 2 oplock. \n " ) ) ;
remove_oplock ( fsp ) ;
return ;
}
/* Ensure we're really at level2 state. */
SMB_ASSERT ( fsp - > oplock_type = = LEVEL_II_OPLOCK ) ;
/* Now send a break to none message to our client. */
break_msg = new_break_smb_message ( NULL , fsp , OPLOCKLEVEL_NONE ) ;
if ( break_msg = = NULL ) {
exit_server ( " Could not talloc break_msg \n " ) ;
}
/* Need to wait before sending a break message if we sent ourselves this message. */
if ( procid_to_pid ( & src ) = = sys_getpid ( ) ) {
wait_before_sending_break ( ) ;
}
/* Save the server smb signing state. */
sign_state = srv_oplock_set_signing ( False ) ;
show_msg ( break_msg ) ;
2008-01-04 23:56:23 +03:00
if ( ! srv_send_smb ( smbd_server_fd ( ) ,
break_msg ,
IS_CONN_ENCRYPTED ( fsp - > conn ) ) ) {
exit_server_cleanly ( " oplock_break: srv_send_smb failed. " ) ;
2006-01-28 02:30:30 +03:00
}
/* Restore the sign state to what it was. */
srv_oplock_set_signing ( sign_state ) ;
2006-02-20 20:59:58 +03:00
TALLOC_FREE ( break_msg ) ;
2006-01-28 02:30:30 +03:00
/* Async level2 request, don't send a reply, just remove the oplock. */
remove_oplock ( fsp ) ;
}
/*******************************************************************
This handles the generic oplock break message from another smbd .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-05-15 00:31:28 +04:00
static void process_oplock_break_message ( struct messaging_context * msg_ctx ,
void * private_data ,
uint32_t msg_type ,
struct server_id src ,
DATA_BLOB * data )
1999-12-13 16:27:58 +03:00
{
2006-01-13 01:17:54 +03:00
struct share_mode_entry msg ;
2005-09-30 21:13:37 +04:00
files_struct * fsp ;
char * break_msg ;
2007-10-19 04:40:25 +04:00
bool break_to_level2 = False ;
bool sign_state ;
2001-10-21 01:59:34 +04:00
2007-05-15 00:31:28 +04:00
if ( data - > data = = NULL ) {
2005-09-30 21:13:37 +04:00
DEBUG ( 0 , ( " Got NULL buffer \n " ) ) ;
return ;
2005-01-26 03:13:15 +03:00
}
2001-10-21 01:59:34 +04:00
2007-05-15 00:31:28 +04:00
if ( data - > length ! = MSG_SMB_SHARE_MODE_ENTRY_SIZE ) {
DEBUG ( 0 , ( " Got invalid msg len %d \n " , ( int ) data - > length ) ) ;
2005-09-30 21:13:37 +04:00
return ;
2001-10-21 01:59:34 +04:00
}
2006-01-13 01:17:54 +03:00
/* De-linearize incoming message. */
2007-05-15 00:31:28 +04:00
message_to_share_mode_entry ( & msg , ( char * ) data - > data ) ;
2006-01-13 01:17:54 +03:00
2007-05-29 13:30:34 +04:00
DEBUG ( 10 , ( " Got oplock break message from pid %d: %s/%lu \n " ,
2007-09-10 14:56:07 +04:00
( int ) procid_to_pid ( & src ) , file_id_string_tos ( & msg . id ) , msg . share_file_id ) ) ;
2001-10-21 01:59:34 +04:00
2007-05-29 13:30:34 +04:00
fsp = initial_break_processing ( msg . id , msg . share_file_id ) ;
2001-10-21 01:59:34 +04:00
2005-09-30 21:13:37 +04:00
if ( fsp = = NULL ) {
2006-01-28 02:30:30 +03:00
/* a We hit race here. Break messages are sent, and before we
2005-09-30 21:13:37 +04:00
* get to process this message , we have closed the file . Reply
* with ' ok , oplock broken ' */
DEBUG ( 3 , ( " Did not find fsp \n " ) ) ;
2006-01-13 01:17:54 +03:00
/* We just send the same message back. */
2007-05-15 00:31:28 +04:00
messaging_send_buf ( msg_ctx , src , MSG_SMB_BREAK_RESPONSE ,
( uint8 * ) data - > data ,
MSG_SMB_SHARE_MODE_ENTRY_SIZE ) ;
2005-09-30 21:13:37 +04:00
return ;
2001-10-21 01:59:34 +04:00
}
2005-09-30 21:13:37 +04:00
if ( fsp - > sent_oplock_break ! = NO_BREAK_SENT ) {
/* Remember we have to inform the requesting PID when the
* client replies */
2006-01-13 01:17:54 +03:00
msg . pid = src ;
ADD_TO_ARRAY ( NULL , struct share_mode_entry , msg ,
2005-09-30 21:13:37 +04:00
& fsp - > pending_break_messages ,
& fsp - > num_pending_break_messages ) ;
return ;
2001-10-21 01:59:34 +04:00
}
2006-01-13 01:17:54 +03:00
if ( EXCLUSIVE_OPLOCK_TYPE ( msg . op_type ) & &
2005-09-30 21:13:37 +04:00
! EXCLUSIVE_OPLOCK_TYPE ( fsp - > oplock_type ) ) {
2007-05-29 13:30:34 +04:00
DEBUG ( 3 , ( " Already downgraded oplock on %s: %s \n " ,
2007-09-10 14:56:07 +04:00
file_id_string_tos ( & fsp - > file_id ) ,
2005-09-30 21:13:37 +04:00
fsp - > fsp_name ) ) ;
2006-01-13 01:17:54 +03:00
/* We just send the same message back. */
2007-05-15 00:31:28 +04:00
messaging_send_buf ( msg_ctx , src , MSG_SMB_BREAK_RESPONSE ,
( uint8 * ) data - > data ,
MSG_SMB_SHARE_MODE_ENTRY_SIZE ) ;
2005-09-30 21:13:37 +04:00
return ;
2005-07-17 13:56:25 +04:00
}
2001-10-21 01:59:34 +04:00
2006-01-28 02:30:30 +03:00
if ( ( global_client_caps & CAP_LEVEL_II_OPLOCKS ) & &
2006-05-30 22:17:37 +04:00
! ( msg . op_type & FORCE_OPLOCK_BREAK_TO_NONE ) & &
2005-09-30 21:13:37 +04:00
! koplocks & & /* NOTE: we force levelII off for kernel oplocks -
* this will change when it is supported */
lp_level2_oplocks ( SNUM ( fsp - > conn ) ) ) {
break_to_level2 = True ;
}
2001-10-21 01:59:34 +04:00
2005-09-30 21:13:37 +04:00
break_msg = new_break_smb_message ( NULL , fsp , break_to_level2 ?
OPLOCKLEVEL_II : OPLOCKLEVEL_NONE ) ;
if ( break_msg = = NULL ) {
exit_server ( " Could not talloc break_msg \n " ) ;
2001-10-21 01:59:34 +04:00
}
2006-01-28 02:30:30 +03:00
/* Need to wait before sending a break message if we sent ourselves this message. */
2005-09-30 21:13:37 +04:00
if ( procid_to_pid ( & src ) = = sys_getpid ( ) ) {
wait_before_sending_break ( ) ;
}
2001-10-21 01:59:34 +04:00
2003-07-17 04:58:14 +04:00
/* Save the server smb signing state. */
sign_state = srv_oplock_set_signing ( False ) ;
2005-09-30 21:13:37 +04:00
show_msg ( break_msg ) ;
2008-01-04 23:56:23 +03:00
if ( ! srv_send_smb ( smbd_server_fd ( ) ,
break_msg ,
IS_CONN_ENCRYPTED ( fsp - > conn ) ) ) {
exit_server_cleanly ( " oplock_break: srv_send_smb failed. " ) ;
2003-07-17 01:06:21 +04:00
}
2003-07-17 04:58:14 +04:00
/* Restore the sign state to what it was. */
srv_oplock_set_signing ( sign_state ) ;
2001-10-21 01:59:34 +04:00
2006-02-20 20:59:58 +03:00
TALLOC_FREE ( break_msg ) ;
2001-10-21 01:59:34 +04:00
2006-01-28 02:30:30 +03:00
fsp - > sent_oplock_break = break_to_level2 ? LEVEL_II_BREAK_SENT : BREAK_TO_NONE_SENT ;
2006-01-13 01:17:54 +03:00
msg . pid = src ;
ADD_TO_ARRAY ( NULL , struct share_mode_entry , msg ,
2005-09-30 21:13:37 +04:00
& fsp - > pending_break_messages ,
& fsp - > num_pending_break_messages ) ;
2001-10-21 01:59:34 +04:00
2006-01-28 02:30:30 +03:00
add_oplock_timeout_handler ( fsp ) ;
2005-09-30 21:13:37 +04:00
}
2001-10-21 01:59:34 +04:00
2006-01-28 02:30:30 +03:00
/*******************************************************************
This handles the kernel oplock break message .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-05-15 00:31:28 +04:00
static void process_kernel_oplock_break ( struct messaging_context * msg_ctx ,
void * private_data ,
uint32_t msg_type ,
struct server_id src ,
DATA_BLOB * data )
2005-09-30 21:13:37 +04:00
{
2007-05-29 13:30:34 +04:00
struct file_id id ;
2006-01-13 01:17:54 +03:00
unsigned long file_id ;
2005-09-30 21:13:37 +04:00
files_struct * fsp ;
char * break_msg ;
2007-10-19 04:40:25 +04:00
bool sign_state ;
2001-10-21 01:59:34 +04:00
2007-05-15 00:31:28 +04:00
if ( data - > data = = NULL ) {
2005-09-30 21:13:37 +04:00
DEBUG ( 0 , ( " Got NULL buffer \n " ) ) ;
return ;
2001-10-21 01:59:34 +04:00
}
2007-05-15 00:31:28 +04:00
if ( data - > length ! = MSG_SMB_KERNEL_BREAK_SIZE ) {
DEBUG ( 0 , ( " Got invalid msg len %d \n " , ( int ) data - > length ) ) ;
2005-09-30 21:13:37 +04:00
return ;
2001-10-21 01:59:34 +04:00
}
2006-01-13 01:17:54 +03:00
/* Pull the data from the message. */
2007-05-29 13:30:34 +04:00
pull_file_id_16 ( ( char * ) data - > data , & id ) ;
2007-05-15 00:31:28 +04:00
file_id = ( unsigned long ) IVAL ( data - > data , 16 ) ;
2001-10-21 01:59:34 +04:00
2007-05-29 13:30:34 +04:00
DEBUG ( 10 , ( " Got kernel oplock break message from pid %d: %s/%u \n " ,
2007-09-10 14:56:07 +04:00
( int ) procid_to_pid ( & src ) , file_id_string_tos ( & id ) ,
2006-01-13 01:17:54 +03:00
( unsigned int ) file_id ) ) ;
2007-05-29 13:30:34 +04:00
fsp = initial_break_processing ( id , file_id ) ;
2001-10-21 01:59:34 +04:00
2005-09-30 21:13:37 +04:00
if ( fsp = = NULL ) {
DEBUG ( 3 , ( " Got a kernel oplock break message for a file "
" I don't know about \n " ) ) ;
return ;
2001-10-21 01:59:34 +04:00
}
2005-09-30 21:13:37 +04:00
if ( fsp - > sent_oplock_break ! = NO_BREAK_SENT ) {
/* This is ok, kernel oplocks come in completely async */
DEBUG ( 3 , ( " Got a kernel oplock request while waiting for a "
" break reply \n " ) ) ;
return ;
2001-10-21 01:59:34 +04:00
}
2005-09-30 21:13:37 +04:00
break_msg = new_break_smb_message ( NULL , fsp , OPLOCKLEVEL_NONE ) ;
if ( break_msg = = NULL ) {
exit_server ( " Could not talloc break_msg \n " ) ;
2001-10-21 01:59:34 +04:00
}
2005-09-30 21:13:37 +04:00
/* Save the server smb signing state. */
sign_state = srv_oplock_set_signing ( False ) ;
2005-04-02 03:11:28 +04:00
2005-09-30 21:13:37 +04:00
show_msg ( break_msg ) ;
2008-01-04 23:56:23 +03:00
if ( ! srv_send_smb ( smbd_server_fd ( ) ,
break_msg ,
IS_CONN_ENCRYPTED ( fsp - > conn ) ) ) {
exit_server_cleanly ( " oplock_break: srv_send_smb failed. " ) ;
2001-10-21 01:59:34 +04:00
}
2005-09-30 21:13:37 +04:00
/* Restore the sign state to what it was. */
srv_oplock_set_signing ( sign_state ) ;
1998-08-17 17:11:34 +04:00
2006-02-20 20:59:58 +03:00
TALLOC_FREE ( break_msg ) ;
1998-08-17 17:11:34 +04:00
2005-09-30 21:13:37 +04:00
fsp - > sent_oplock_break = BREAK_TO_NONE_SENT ;
2006-01-28 02:30:30 +03:00
add_oplock_timeout_handler ( fsp ) ;
2005-09-30 21:13:37 +04:00
}
1998-08-17 17:11:34 +04:00
2005-09-30 21:13:37 +04:00
void reply_to_oplock_break_requests ( files_struct * fsp )
{
int i ;
2001-08-21 05:25:45 +04:00
2005-09-30 21:13:37 +04:00
for ( i = 0 ; i < fsp - > num_pending_break_messages ; i + + ) {
2006-01-13 01:17:54 +03:00
struct share_mode_entry * e = & fsp - > pending_break_messages [ i ] ;
char msg [ MSG_SMB_SHARE_MODE_ENTRY_SIZE ] ;
share_mode_entry_to_message ( msg , e ) ;
2007-05-15 00:31:28 +04:00
messaging_send_buf ( smbd_messaging_context ( ) , e - > pid ,
MSG_SMB_BREAK_RESPONSE ,
( uint8 * ) msg ,
MSG_SMB_SHARE_MODE_ENTRY_SIZE ) ;
2001-10-21 01:59:34 +04:00
}
2005-09-30 21:13:37 +04:00
SAFE_FREE ( fsp - > pending_break_messages ) ;
fsp - > num_pending_break_messages = 0 ;
if ( fsp - > oplock_timeout ! = NULL ) {
2006-01-28 02:30:30 +03:00
/* Remove the timed event handler. */
2006-02-20 20:59:58 +03:00
TALLOC_FREE ( fsp - > oplock_timeout ) ;
2005-09-30 21:13:37 +04:00
fsp - > oplock_timeout = NULL ;
2001-10-21 01:59:34 +04:00
}
2005-09-30 21:13:37 +04:00
return ;
}
2001-10-21 01:59:34 +04:00
2007-05-15 00:31:28 +04:00
static void process_oplock_break_response ( struct messaging_context * msg_ctx ,
void * private_data ,
uint32_t msg_type ,
struct server_id src ,
DATA_BLOB * data )
2005-09-30 21:13:37 +04:00
{
2006-01-13 01:17:54 +03:00
struct share_mode_entry msg ;
2001-10-21 01:59:34 +04:00
2007-05-15 00:31:28 +04:00
if ( data - > data = = NULL ) {
2005-09-30 21:13:37 +04:00
DEBUG ( 0 , ( " Got NULL buffer \n " ) ) ;
return ;
2001-10-21 01:59:34 +04:00
}
2007-05-15 00:31:28 +04:00
if ( data - > length ! = MSG_SMB_SHARE_MODE_ENTRY_SIZE ) {
DEBUG ( 0 , ( " Got invalid msg len %u \n " ,
( unsigned int ) data - > length ) ) ;
2005-09-30 21:13:37 +04:00
return ;
2001-10-21 01:59:34 +04:00
}
2006-01-13 01:17:54 +03:00
/* De-linearize incoming message. */
2007-05-15 00:31:28 +04:00
message_to_share_mode_entry ( & msg , ( char * ) data - > data ) ;
2006-01-13 01:17:54 +03:00
2007-05-29 13:30:34 +04:00
DEBUG ( 10 , ( " Got oplock break response from pid %d: %s/%lu mid %u \n " ,
2007-09-10 14:56:07 +04:00
( int ) procid_to_pid ( & src ) , file_id_string_tos ( & msg . id ) , msg . share_file_id ,
2006-05-05 06:06:37 +04:00
( unsigned int ) msg . op_mid ) ) ;
2001-10-21 01:59:34 +04:00
2005-09-30 21:13:37 +04:00
/* Here's the hack from open.c, store the mid in the 'port' field */
2006-01-13 01:17:54 +03:00
schedule_deferred_open_smb_message ( msg . op_mid ) ;
1998-08-17 17:11:34 +04:00
}
2007-05-15 00:31:28 +04:00
static void process_open_retry_message ( struct messaging_context * msg_ctx ,
void * private_data ,
uint32_t msg_type ,
struct server_id src ,
DATA_BLOB * data )
1998-08-17 17:11:34 +04:00
{
2006-01-13 01:17:54 +03:00
struct share_mode_entry msg ;
2005-09-30 21:13:37 +04:00
2007-05-15 00:31:28 +04:00
if ( data - > data = = NULL ) {
2005-09-30 21:13:37 +04:00
DEBUG ( 0 , ( " Got NULL buffer \n " ) ) ;
return ;
2001-10-21 01:59:34 +04:00
}
1998-08-17 17:11:34 +04:00
2007-05-15 00:31:28 +04:00
if ( data - > length ! = MSG_SMB_SHARE_MODE_ENTRY_SIZE ) {
DEBUG ( 0 , ( " Got invalid msg len %d \n " , ( int ) data - > length ) ) ;
2005-09-30 21:13:37 +04:00
return ;
2005-01-26 23:01:21 +03:00
}
2006-01-13 01:17:54 +03:00
/* De-linearize incoming message. */
2007-05-15 00:31:28 +04:00
message_to_share_mode_entry ( & msg , ( char * ) data - > data ) ;
2005-01-26 23:01:21 +03:00
2007-05-29 13:30:34 +04:00
DEBUG ( 10 , ( " Got open retry msg from pid %d: %s mid %u \n " ,
2007-09-10 14:56:07 +04:00
( int ) procid_to_pid ( & src ) , file_id_string_tos ( & msg . id ) ,
2006-01-13 01:17:54 +03:00
( unsigned int ) msg . op_mid ) ) ;
schedule_deferred_open_smb_message ( msg . op_mid ) ;
2005-01-26 23:01:21 +03:00
}
2000-11-16 03:59:18 +03:00
/****************************************************************************
This function is called on any file modification or lock request . If a file
2005-09-30 21:13:37 +04:00
is level 2 oplocked then it must tell all other level 2 holders to break to
none .
2000-11-16 03:59:18 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void release_level_2_oplocks_on_change ( files_struct * fsp )
{
int i ;
2005-09-30 21:13:37 +04:00
struct share_mode_lock * lck ;
2000-11-16 03:59:18 +03:00
/*
* If this file is level II oplocked then we need
* to grab the shared memory lock and inform all
* other files with a level II lock that they need
* to flush their read caches . We keep the lock over
* the shared memory area whilst doing this .
*/
if ( ! LEVEL_II_OPLOCK_TYPE ( fsp - > oplock_type ) )
return ;
2008-03-12 17:32:47 +03:00
lck = get_share_mode_lock ( talloc_tos ( ) , fsp - > file_id , NULL , NULL ,
NULL ) ;
2005-09-30 21:13:37 +04:00
if ( lck = = NULL ) {
DEBUG ( 0 , ( " release_level_2_oplocks_on_change: failed to lock "
" share mode entry for file %s. \n " , fsp - > fsp_name ) ) ;
2006-03-07 12:09:13 +03:00
return ;
2000-11-16 03:59:18 +03:00
}
2001-08-22 04:29:40 +04:00
DEBUG ( 10 , ( " release_level_2_oplocks_on_change: num_share_modes = %d \n " ,
2005-09-30 21:13:37 +04:00
lck - > num_share_modes ) ) ;
for ( i = 0 ; i < lck - > num_share_modes ; i + + ) {
struct share_mode_entry * share_entry = & lck - > share_modes [ i ] ;
2006-01-13 01:17:54 +03:00
char msg [ MSG_SMB_SHARE_MODE_ENTRY_SIZE ] ;
2000-11-16 03:59:18 +03:00
2006-01-27 22:54:39 +03:00
if ( ! is_valid_share_mode_entry ( share_entry ) ) {
continue ;
}
2000-11-16 03:59:18 +03:00
/*
2005-09-30 21:13:37 +04:00
* As there could have been multiple writes waiting at the
* lock_share_entry gate we may not be the first to
* enter . Hence the state of the op_types in the share mode
2006-01-28 02:30:30 +03:00
* entries may be partly NO_OPLOCK and partly LEVEL_II or FAKE_LEVEL_II
2005-09-30 21:13:37 +04:00
* oplock . It will do no harm to re - send break messages to
* those smbd ' s that are still waiting their turn to remove
* their LEVEL_II state , and also no harm to ignore existing
* NO_OPLOCK states . JRA .
2000-11-16 03:59:18 +03:00
*/
2005-09-30 21:13:37 +04:00
DEBUG ( 10 , ( " release_level_2_oplocks_on_change: "
" share_entry[%i]->op_type == %d \n " ,
i , share_entry - > op_type ) ) ;
2001-08-22 04:29:40 +04:00
2006-01-28 02:30:30 +03:00
if ( share_entry - > op_type = = NO_OPLOCK ) {
2000-11-16 03:59:18 +03:00
continue ;
2005-09-30 21:13:37 +04:00
}
2000-11-16 03:59:18 +03:00
/* Paranoia .... */
if ( EXCLUSIVE_OPLOCK_TYPE ( share_entry - > op_type ) ) {
2005-09-30 21:13:37 +04:00
DEBUG ( 0 , ( " release_level_2_oplocks_on_change: PANIC. "
" share mode entry %d is an exlusive "
" oplock ! \n " , i ) ) ;
2006-02-20 20:59:58 +03:00
TALLOC_FREE ( lck ) ;
2000-11-16 03:59:18 +03:00
abort ( ) ;
}
2006-01-13 01:17:54 +03:00
share_mode_entry_to_message ( msg , share_entry ) ;
2007-05-15 00:31:28 +04:00
messaging_send_buf ( smbd_messaging_context ( ) , share_entry - > pid ,
MSG_SMB_ASYNC_LEVEL2_BREAK ,
( uint8 * ) msg ,
MSG_SMB_SHARE_MODE_ENTRY_SIZE ) ;
2004-06-08 20:14:31 +04:00
}
2006-01-28 02:30:30 +03:00
/* We let the message receivers handle removing the oplock state
in the share mode lock db . */
2006-02-20 20:59:58 +03:00
TALLOC_FREE ( lck ) ;
2004-06-08 20:14:31 +04:00
}
2006-01-13 01:17:54 +03:00
/****************************************************************************
Linearize a share mode entry struct to an internal oplock break message .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2008-05-27 22:23:59 +04:00
void share_mode_entry_to_message ( char * msg , const struct share_mode_entry * e )
2006-01-13 01:17:54 +03:00
{
SIVAL ( msg , 0 , ( uint32 ) e - > pid . pid ) ;
SSVAL ( msg , 4 , e - > op_mid ) ;
SSVAL ( msg , 6 , e - > op_type ) ;
SIVAL ( msg , 8 , e - > access_mask ) ;
SIVAL ( msg , 12 , e - > share_access ) ;
SIVAL ( msg , 16 , e - > private_options ) ;
SIVAL ( msg , 20 , ( uint32 ) e - > time . tv_sec ) ;
SIVAL ( msg , 24 , ( uint32 ) e - > time . tv_usec ) ;
2007-05-29 13:30:34 +04:00
push_file_id_16 ( msg + 28 , & e - > id ) ;
2006-01-13 01:17:54 +03:00
SIVAL ( msg , 44 , e - > share_file_id ) ;
2006-06-21 06:31:12 +04:00
SIVAL ( msg , 48 , e - > uid ) ;
2007-02-07 00:05:34 +03:00
SSVAL ( msg , 52 , e - > flags ) ;
2007-06-10 21:02:09 +04:00
# ifdef CLUSTER_SUPPORT
SIVAL ( msg , 54 , e - > pid . vnn ) ;
# endif
2006-01-13 01:17:54 +03:00
}
/****************************************************************************
De - linearize an internal oplock break message to a share mode entry struct .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void message_to_share_mode_entry ( struct share_mode_entry * e , char * msg )
{
e - > pid . pid = ( pid_t ) IVAL ( msg , 0 ) ;
e - > op_mid = SVAL ( msg , 4 ) ;
e - > op_type = SVAL ( msg , 6 ) ;
e - > access_mask = IVAL ( msg , 8 ) ;
e - > share_access = IVAL ( msg , 12 ) ;
e - > private_options = IVAL ( msg , 16 ) ;
e - > time . tv_sec = ( time_t ) IVAL ( msg , 20 ) ;
e - > time . tv_usec = ( int ) IVAL ( msg , 24 ) ;
2007-05-29 13:30:34 +04:00
pull_file_id_16 ( msg + 28 , & e - > id ) ;
2006-01-13 01:17:54 +03:00
e - > share_file_id = ( unsigned long ) IVAL ( msg , 44 ) ;
2006-06-21 06:31:12 +04:00
e - > uid = ( uint32 ) IVAL ( msg , 48 ) ;
2007-02-07 00:05:34 +03:00
e - > flags = ( uint16 ) SVAL ( msg , 52 ) ;
2007-06-10 21:02:09 +04:00
# ifdef CLUSTER_SUPPORT
e - > pid . vnn = IVAL ( msg , 54 ) ;
# endif
2006-01-13 01:17:54 +03:00
}
2004-06-08 20:14:31 +04:00
/****************************************************************************
Setup oplocks for this process .
1998-09-23 05:48:45 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2001-10-21 01:59:34 +04:00
2007-10-19 04:40:25 +04:00
bool init_oplocks ( struct messaging_context * msg_ctx )
1998-09-18 21:50:18 +04:00
{
2006-07-19 14:42:50 +04:00
DEBUG ( 3 , ( " init_oplocks: initializing messages. \n " ) ) ;
2000-06-10 17:38:07 +04:00
2007-05-15 00:31:28 +04:00
messaging_register ( msg_ctx , NULL , MSG_SMB_BREAK_REQUEST ,
process_oplock_break_message ) ;
messaging_register ( msg_ctx , NULL , MSG_SMB_ASYNC_LEVEL2_BREAK ,
process_oplock_async_level2_break_message ) ;
messaging_register ( msg_ctx , NULL , MSG_SMB_BREAK_RESPONSE ,
process_oplock_break_response ) ;
messaging_register ( msg_ctx , NULL , MSG_SMB_KERNEL_BREAK ,
process_kernel_oplock_break ) ;
messaging_register ( msg_ctx , NULL , MSG_SMB_OPEN_RETRY ,
process_open_retry_message ) ;
2000-06-10 17:38:07 +04:00
if ( lp_kernel_oplocks ( ) ) {
# if HAVE_KERNEL_OPLOCKS_IRIX
koplocks = irix_init_kernel_oplocks ( ) ;
2000-06-11 09:57:58 +04:00
# elif HAVE_KERNEL_OPLOCKS_LINUX
koplocks = linux_init_kernel_oplocks ( ) ;
2000-06-10 17:38:07 +04:00
# endif
}
return True ;
1998-09-18 21:50:18 +04:00
}