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
2011-08-02 18:44:53 +04:00
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 .
2011-08-02 18:44:53 +04:00
1998-08-17 17:11:34 +04:00
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 .
2011-08-02 18:44:53 +04:00
1998-08-17 17:11:34 +04:00
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"
2017-01-01 23:00:55 +03:00
# include "lib/util/server_id.h"
2011-03-22 18:57:01 +03:00
# include "smbd/smbd.h"
2009-01-08 14:03:45 +03:00
# include "smbd/globals.h"
2011-03-24 17:31:06 +03:00
# include "messages.h"
2011-11-24 17:11:28 +04:00
# include "../librpc/gen_ndr/open_files.h"
2017-05-26 12:57:08 +03:00
# include "../librpc/gen_ndr/ndr_open_files.h"
2000-06-10 17:38:07 +04:00
2009-01-23 12:08:44 +03:00
/*
* helper function used by the kernel oplock backends to post the break message
*/
void break_kernel_oplock ( struct messaging_context * msg_ctx , files_struct * fsp )
2001-09-06 02:45:48 +04:00
{
2009-01-23 12:08:44 +03:00
uint8_t msg [ MSG_SMB_KERNEL_BREAK_SIZE ] ;
2001-09-06 02:45:48 +04:00
2009-01-23 12:08:44 +03:00
/* Put the kernel break info into the message. */
2009-02-16 10:45:28 +03:00
push_file_id_24 ( ( char * ) msg , & fsp - > file_id ) ;
SIVAL ( msg , 24 , fsp - > fh - > gen_id ) ;
2000-06-09 10:58:06 +04:00
2009-01-23 12:08:44 +03:00
/* Don't need to be root here as we're only ever
sending to ourselves . */
2002-07-15 14:35:28 +04:00
2010-07-04 20:07:29 +04:00
messaging_send_buf ( msg_ctx , messaging_server_id ( msg_ctx ) ,
2009-01-23 12:08:44 +03:00
MSG_SMB_KERNEL_BREAK ,
msg , MSG_SMB_KERNEL_BREAK_SIZE ) ;
1998-09-23 05:48:45 +04:00
}
1999-12-13 16:27:58 +03:00
/****************************************************************************
2011-01-31 23:00:15 +03:00
Attempt to set an oplock on a file . Succeeds if kernel oplocks are
2013-09-03 17:31:27 +04:00
disabled ( just sets flags ) .
1999-12-13 16:27:58 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2001-10-21 01:59:34 +04:00
2013-09-03 17:57:11 +04:00
NTSTATUS set_file_oplock ( files_struct * fsp )
1999-12-13 16:27:58 +03:00
{
2012-05-25 01:15:08 +04:00
struct smbd_server_connection * sconn = fsp - > conn - > sconn ;
2012-05-25 01:33:32 +04:00
struct kernel_oplocks * koplocks = sconn - > oplocks . kernel_ops ;
2018-01-03 20:52:33 +03:00
bool use_kernel = lp_kernel_oplocks ( SNUM ( fsp - > conn ) ) & &
( koplocks ! = NULL ) ;
2012-03-30 18:11:08 +04:00
2011-01-31 23:00:15 +03:00
if ( fsp - > oplock_type = = LEVEL_II_OPLOCK ) {
2012-03-30 18:11:08 +04:00
if ( use_kernel & &
2011-01-31 23:00:15 +03:00
! ( koplocks - > flags & KOPLOCKS_LEVEL2_SUPPORTED ) ) {
DEBUG ( 10 , ( " Refusing level2 oplock, kernel oplocks "
" don't support them \n " ) ) ;
2012-06-08 19:47:31 +04:00
return NT_STATUS_NOT_SUPPORTED ;
2011-01-31 23:00:15 +03:00
}
2009-04-08 10:29:23 +04:00
}
2011-01-31 23:00:15 +03:00
2008-12-18 04:23:13 +03:00
if ( ( fsp - > oplock_type ! = NO_OPLOCK ) & &
2012-03-30 18:11:08 +04:00
use_kernel & &
2013-09-03 17:57:11 +04:00
! koplocks - > ops - > set_oplock ( koplocks , fsp , fsp - > oplock_type ) )
2012-06-08 19:47:31 +04:00
{
return map_nt_error_from_unix ( errno ) ;
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 - > sent_oplock_break = NO_BREAK_SENT ;
2013-09-03 17:57:11 +04:00
if ( fsp - > oplock_type = = LEVEL_II_OPLOCK ) {
2012-05-25 01:15:08 +04:00
sconn - > oplocks . level_II_open + + ;
2008-12-18 04:23:13 +03:00
} else if ( EXCLUSIVE_OPLOCK_TYPE ( fsp - > oplock_type ) ) {
2012-05-25 01:15:08 +04:00
sconn - > oplocks . exclusive_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 " ,
2009-07-11 01:50:37 +04:00
fsp_str_dbg ( fsp ) , 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
2012-06-08 19:47:31 +04:00
return NT_STATUS_OK ;
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 .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2013-09-13 15:55:05 +04:00
static void release_file_oplock ( files_struct * fsp )
1999-12-13 16:27:58 +03:00
{
2012-05-25 01:15:08 +04:00
struct smbd_server_connection * sconn = fsp - > conn - > sconn ;
2012-05-25 01:33:32 +04:00
struct kernel_oplocks * koplocks = sconn - > oplocks . kernel_ops ;
2018-01-03 20:52:33 +03:00
bool use_kernel = lp_kernel_oplocks ( SNUM ( fsp - > conn ) ) & &
( koplocks ! = NULL ) ;
2012-05-25 01:15:08 +04:00
2005-09-30 21:13:37 +04:00
if ( ( fsp - > oplock_type ! = NO_OPLOCK ) & &
2016-01-05 01:12:25 +03:00
use_kernel ) {
2009-01-10 00:07:58 +03:00
koplocks - > ops - > release_oplock ( koplocks , fsp , NO_OPLOCK ) ;
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 ) {
2012-05-25 01:15:08 +04:00
sconn - > oplocks . level_II_open - - ;
2006-01-13 01:17:54 +03:00
} else if ( EXCLUSIVE_OPLOCK_TYPE ( fsp - > oplock_type ) ) {
2012-05-25 01:15:08 +04:00
sconn - > oplocks . exclusive_open - - ;
2006-01-13 01:17:54 +03:00
}
2005-09-30 21:13:37 +04:00
2012-05-25 01:15:08 +04:00
SMB_ASSERT ( sconn - > oplocks . exclusive_open > = 0 ) ;
SMB_ASSERT ( sconn - > oplocks . level_II_open > = 0 ) ;
2008-12-18 04:23:13 +03:00
2013-09-11 20:07:33 +04:00
fsp - > oplock_type = NO_OPLOCK ;
2000-06-09 10:58:06 +04:00
fsp - > sent_oplock_break = NO_BREAK_SENT ;
2008-12-18 04:23:13 +03:00
2013-11-22 09:33:33 +04:00
flush_write_cache ( fsp , SAMBA_OPLOCK_RELEASE_FLUSH ) ;
2010-10-02 19:07:00 +04:00
delete_write_cache ( fsp ) ;
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 )
{
2012-05-25 01:15:08 +04:00
struct smbd_server_connection * sconn = fsp - > conn - > sconn ;
2012-05-25 01:33:32 +04:00
struct kernel_oplocks * koplocks = sconn - > oplocks . kernel_ops ;
2018-01-03 20:52:33 +03:00
bool use_kernel = lp_kernel_oplocks ( SNUM ( fsp - > conn ) ) & &
( koplocks ! = NULL ) ;
2012-05-25 01:15:08 +04:00
2009-01-28 03:13:35 +03:00
if ( ! EXCLUSIVE_OPLOCK_TYPE ( fsp - > oplock_type ) ) {
DEBUG ( 0 , ( " trying to downgrade an already-downgraded oplock! \n " ) ) ;
return ;
}
2018-01-03 20:52:33 +03:00
if ( use_kernel ) {
2009-01-10 00:07:58 +03:00
koplocks - > ops - > release_oplock ( koplocks , fsp , LEVEL_II_OPLOCK ) ;
2006-01-13 01:17:54 +03:00
}
2000-06-10 17:38:07 +04:00
fsp - > oplock_type = LEVEL_II_OPLOCK ;
2012-05-25 01:15:08 +04:00
sconn - > oplocks . exclusive_open - - ;
sconn - > oplocks . level_II_open + + ;
2000-06-10 17:38:07 +04:00
fsp - > sent_oplock_break = NO_BREAK_SENT ;
2013-09-04 15:57:00 +04:00
2014-11-06 11:23:46 +03:00
flush_write_cache ( fsp , SAMBA_OPLOCK_RELEASE_FLUSH ) ;
delete_write_cache ( fsp ) ;
2013-09-04 15:57:00 +04:00
TALLOC_FREE ( fsp - > oplock_timeout ) ;
1999-12-13 16:27:58 +03:00
}
2017-03-04 15:55:55 +03:00
uint32_t get_lease_type ( const struct share_mode_data * d ,
const struct share_mode_entry * e )
2014-10-29 01:31:46 +03:00
{
if ( e - > op_type = = LEASE_OPLOCK ) {
return d - > leases [ e - > lease_idx ] . current_state ;
}
return map_oplock_to_lease_type ( e - > op_type ) ;
}
2014-10-29 01:27:09 +03:00
bool update_num_read_oplocks ( files_struct * fsp , struct share_mode_lock * lck )
{
struct share_mode_data * d = lck - > data ;
struct byte_range_lock * br_lck ;
uint32_t num_read_oplocks = 0 ;
uint32_t i ;
2017-05-04 12:52:16 +03:00
if ( fsp_lease_type_is_exclusive ( fsp ) ) {
2017-05-26 12:57:08 +03:00
const struct share_mode_entry * e = NULL ;
uint32_t e_lease_type = 0 ;
2014-10-29 01:27:09 +03:00
/*
2017-05-04 12:52:16 +03:00
* If we ' re fully exclusive , we don ' t need a brlock entry
2014-10-29 01:27:09 +03:00
*/
2016-04-20 14:13:38 +03:00
remove_stale_share_mode_entries ( d ) ;
2017-05-04 12:52:16 +03:00
2017-05-26 12:57:08 +03:00
e = find_share_mode_entry ( lck , fsp ) ;
if ( e ! = NULL ) {
e_lease_type = get_lease_type ( d , e ) ;
}
if ( ! lease_type_is_exclusive ( e_lease_type ) ) {
char * timestr = NULL ;
2017-05-04 12:52:16 +03:00
2017-05-26 12:57:08 +03:00
timestr = timeval_string ( talloc_tos ( ) ,
& fsp - > open_time ,
true ) ;
NDR_PRINT_DEBUG ( share_mode_data , d ) ;
DBG_ERR ( " file [%s] file_id [%s] gen_id [%lu] "
" open_time[%s] lease_type [0x%x] "
" oplock_type [0x%x] \n " ,
fsp_str_dbg ( fsp ) ,
file_id_string_tos ( & fsp - > file_id ) ,
fsp - > fh - > gen_id , timestr ,
e_lease_type , fsp - > oplock_type ) ;
smb_panic ( " Found non-exclusive lease " ) ;
2017-05-04 12:52:16 +03:00
}
2017-05-26 12:57:08 +03:00
2014-10-29 01:27:09 +03:00
return true ;
}
for ( i = 0 ; i < d - > num_share_modes ; i + + ) {
struct share_mode_entry * e = & d - > share_modes [ i ] ;
2014-10-29 01:31:46 +03:00
uint32_t e_lease_type = get_lease_type ( d , e ) ;
2014-10-29 01:27:09 +03:00
2014-10-29 01:31:46 +03:00
if ( e_lease_type & SMB2_LEASE_READ ) {
2014-10-29 01:27:09 +03:00
num_read_oplocks + = 1 ;
}
}
br_lck = brl_get_locks_readonly ( fsp ) ;
if ( br_lck = = NULL ) {
return false ;
}
if ( brl_num_read_oplocks ( br_lck ) = = num_read_oplocks ) {
return true ;
}
br_lck = brl_get_locks ( talloc_tos ( ) , fsp ) ;
if ( br_lck = = NULL ) {
return false ;
}
brl_set_num_read_oplocks ( br_lck , num_read_oplocks ) ;
TALLOC_FREE ( br_lck ) ;
return true ;
}
2016-08-11 00:39:52 +03:00
/****************************************************************************
Remove a file oplock with lock already held . Copes with level II and exclusive .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
bool remove_oplock_under_lock ( files_struct * fsp , struct share_mode_lock * lck )
{
bool ret ;
ret = remove_share_oplock ( lck , fsp ) ;
if ( ! ret ) {
DBG_ERR ( " failed to remove share oplock for "
" file %s, %s, %s \n " ,
fsp_str_dbg ( fsp ) , fsp_fnum_dbg ( fsp ) ,
file_id_string_tos ( & fsp - > file_id ) ) ;
}
release_file_oplock ( fsp ) ;
ret = update_num_read_oplocks ( fsp , lck ) ;
if ( ! ret ) {
DBG_ERR ( " update_num_read_oplocks failed for "
" file %s, %s, %s \n " ,
fsp_str_dbg ( fsp ) , fsp_fnum_dbg ( fsp ) ,
file_id_string_tos ( & fsp - > file_id ) ) ;
}
return ret ;
}
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
2016-08-11 00:35:42 +03:00
DBG_DEBUG ( " remove_oplock called for %s \n " , fsp_str_dbg ( fsp ) ) ;
2013-09-13 16:13:51 +04:00
2000-06-10 17:38:07 +04:00
/* Remove the oplock flag from the sharemode. */
2012-02-19 17:23:56 +04:00
lck = get_existing_share_mode_lock ( talloc_tos ( ) , fsp - > file_id ) ;
2005-09-30 21:13:37 +04:00
if ( lck = = NULL ) {
2016-08-11 00:35:42 +03:00
DBG_ERR ( " failed to lock share entry for "
" file %s \n " , fsp_str_dbg ( fsp ) ) ;
return false ;
2000-06-10 17:38:07 +04:00
}
2013-09-11 20:07:33 +04:00
2016-08-11 00:39:52 +03:00
ret = remove_oplock_under_lock ( fsp , lck ) ;
2014-10-29 01:27:09 +03:00
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
2013-09-13 16:13:51 +04:00
DEBUG ( 10 , ( " downgrade_oplock called for %s \n " ,
fsp_str_dbg ( fsp ) ) ) ;
2012-02-19 17:23:56 +04:00
lck = get_existing_share_mode_lock ( talloc_tos ( ) , fsp - > file_id ) ;
2005-09-30 21:13:37 +04:00
if ( lck = = NULL ) {
DEBUG ( 0 , ( " downgrade_oplock: failed to lock share entry for "
2009-07-11 01:50:37 +04:00
" file %s \n " , fsp_str_dbg ( fsp ) ) ) ;
2005-09-30 21:13:37 +04:00
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 "
2012-06-14 14:55:59 +04:00
" for file %s, %s, file_id %s \n " ,
fsp_str_dbg ( fsp ) , fsp_fnum_dbg ( fsp ) ,
2009-07-11 01:50:37 +04:00
file_id_string_tos ( & fsp - > file_id ) ) ) ;
2005-09-30 21:13:37 +04:00
}
downgrade_file_oplock ( fsp ) ;
2013-09-11 20:07:33 +04:00
2014-10-29 01:27:09 +03:00
ret = update_num_read_oplocks ( fsp , lck ) ;
if ( ! ret ) {
DEBUG ( 0 , ( " %s: update_num_read_oplocks failed for "
" file %s, %s, %s \n " ,
__func__ , fsp_str_dbg ( fsp ) , fsp_fnum_dbg ( fsp ) ,
file_id_string_tos ( & fsp - > file_id ) ) ) ;
2013-09-11 20:07:33 +04:00
}
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
}
2014-10-29 01:31:46 +03:00
static void lease_timeout_handler ( struct tevent_context * ctx ,
struct tevent_timer * te ,
struct timeval now ,
void * private_data )
{
struct fsp_lease * lease =
talloc_get_type_abort ( private_data ,
struct fsp_lease ) ;
struct files_struct * fsp ;
struct share_mode_lock * lck ;
uint16_t old_epoch = lease - > lease . lease_epoch ;
fsp = file_find_one_fsp_from_lease_key ( lease - > sconn ,
& lease - > lease . lease_key ) ;
if ( fsp = = NULL ) {
/* race? */
TALLOC_FREE ( lease - > timeout ) ;
return ;
}
lck = get_existing_share_mode_lock (
talloc_tos ( ) , fsp - > file_id ) ;
if ( lck = = NULL ) {
/* race? */
TALLOC_FREE ( lease - > timeout ) ;
return ;
}
fsp_lease_update ( lck , fsp_client_guid ( fsp ) , lease ) ;
if ( lease - > lease . lease_epoch ! = old_epoch ) {
/*
* If the epoch changed we need to wait for
* the next timeout to happen .
*/
DEBUG ( 10 , ( " lease break timeout race (epoch) for file %s - ignoring \n " ,
fsp_str_dbg ( fsp ) ) ) ;
TALLOC_FREE ( lck ) ;
return ;
}
if ( ! ( lease - > lease . lease_flags & SMB2_LEASE_FLAG_BREAK_IN_PROGRESS ) ) {
/*
* If the epoch changed we need to wait for
* the next timeout to happen .
*/
DEBUG ( 10 , ( " lease break timeout race (flags) for file %s - ignoring \n " ,
fsp_str_dbg ( fsp ) ) ) ;
TALLOC_FREE ( lck ) ;
return ;
}
DEBUG ( 1 , ( " lease break timed out for file %s -- replying anyway \n " ,
fsp_str_dbg ( fsp ) ) ) ;
( void ) downgrade_lease ( lease - > sconn - > client - > connections ,
1 ,
& fsp - > file_id ,
& lease - > lease . lease_key ,
SMB2_LEASE_NONE ) ;
TALLOC_FREE ( lck ) ;
}
bool fsp_lease_update ( struct share_mode_lock * lck ,
const struct GUID * client_guid ,
struct fsp_lease * lease )
{
struct share_mode_data * d = lck - > data ;
int idx ;
struct share_mode_lease * l = NULL ;
idx = find_share_mode_lease ( d , client_guid , & lease - > lease . lease_key ) ;
if ( idx ! = - 1 ) {
l = & d - > leases [ idx ] ;
}
if ( l = = NULL ) {
DEBUG ( 1 , ( " %s: Could not find lease entry \n " , __func__ ) ) ;
TALLOC_FREE ( lease - > timeout ) ;
lease - > lease . lease_state = SMB2_LEASE_NONE ;
lease - > lease . lease_epoch + = 1 ;
lease - > lease . lease_flags = 0 ;
return false ;
}
DEBUG ( 10 , ( " %s: refresh lease state \n " , __func__ ) ) ;
/* Ensure we're in sync with current lease state. */
if ( lease - > lease . lease_epoch ! = l - > epoch ) {
DEBUG ( 10 , ( " %s: cancel outdated timeout \n " , __func__ ) ) ;
TALLOC_FREE ( lease - > timeout ) ;
}
lease - > lease . lease_epoch = l - > epoch ;
lease - > lease . lease_state = l - > current_state ;
if ( l - > breaking ) {
lease - > lease . lease_flags | = SMB2_LEASE_FLAG_BREAK_IN_PROGRESS ;
if ( lease - > timeout = = NULL ) {
struct timeval t = timeval_current_ofs ( OPLOCK_BREAK_TIMEOUT , 0 ) ;
DEBUG ( 10 , ( " %s: setup timeout handler \n " , __func__ ) ) ;
lease - > timeout = tevent_add_timer ( lease - > sconn - > ev_ctx ,
lease , t ,
lease_timeout_handler ,
lease ) ;
if ( lease - > timeout = = NULL ) {
DEBUG ( 0 , ( " %s: Could not add lease timeout handler \n " ,
__func__ ) ) ;
}
}
} else {
lease - > lease . lease_flags & = ~ SMB2_LEASE_FLAG_BREAK_IN_PROGRESS ;
TALLOC_FREE ( lease - > timeout ) ;
}
return true ;
}
struct downgrade_lease_additional_state {
struct tevent_immediate * im ;
struct smbXsrv_connection * xconn ;
uint32_t break_flags ;
struct smb2_lease_key lease_key ;
uint32_t break_from ;
uint32_t break_to ;
uint16_t new_epoch ;
} ;
static void downgrade_lease_additional_trigger ( struct tevent_context * ev ,
struct tevent_immediate * im ,
void * private_data )
{
struct downgrade_lease_additional_state * state =
talloc_get_type_abort ( private_data ,
struct downgrade_lease_additional_state ) ;
struct smbXsrv_connection * xconn = state - > xconn ;
NTSTATUS status ;
status = smbd_smb2_send_lease_break ( xconn ,
state - > new_epoch ,
state - > break_flags ,
& state - > lease_key ,
state - > break_from ,
state - > break_to ) ;
TALLOC_FREE ( state ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
smbd_server_connection_terminate ( xconn ,
nt_errstr ( status ) ) ;
return ;
}
}
struct downgrade_lease_fsps_state {
struct file_id id ;
struct share_mode_lock * lck ;
const struct smb2_lease_key * key ;
} ;
static struct files_struct * downgrade_lease_fsps ( struct files_struct * fsp ,
void * private_data )
{
struct downgrade_lease_fsps_state * state =
( struct downgrade_lease_fsps_state * ) private_data ;
if ( fsp - > oplock_type ! = LEASE_OPLOCK ) {
return NULL ;
}
if ( ! smb2_lease_key_equal ( & fsp - > lease - > lease . lease_key , state - > key ) ) {
return NULL ;
}
if ( ! file_id_equal ( & fsp - > file_id , & state - > id ) ) {
return NULL ;
}
fsp_lease_update ( state - > lck , fsp_client_guid ( fsp ) , fsp - > lease ) ;
return NULL ;
}
NTSTATUS downgrade_lease ( struct smbXsrv_connection * xconn ,
uint32_t num_file_ids ,
const struct file_id * ids ,
const struct smb2_lease_key * key ,
uint32_t lease_state )
{
struct smbd_server_connection * sconn = xconn - > client - > sconn ;
struct share_mode_lock * lck ;
struct share_mode_lease * l = NULL ;
const struct file_id id = ids [ 0 ] ;
uint32_t i ;
NTSTATUS status ;
DEBUG ( 10 , ( " %s: Downgrading %s to %x \n " , __func__ ,
file_id_string_tos ( & id ) , ( unsigned ) lease_state ) ) ;
lck = get_existing_share_mode_lock ( talloc_tos ( ) , id ) ;
if ( lck = = NULL ) {
return NT_STATUS_OBJECT_NAME_NOT_FOUND ;
}
status = downgrade_share_lease ( sconn , lck , key , lease_state , & l ) ;
DEBUG ( 10 , ( " %s: Downgrading %s to %x => %s \n " , __func__ ,
file_id_string_tos ( & id ) , ( unsigned ) lease_state , nt_errstr ( status ) ) ) ;
if ( NT_STATUS_EQUAL ( status , NT_STATUS_OPLOCK_BREAK_IN_PROGRESS ) ) {
struct downgrade_lease_additional_state * state ;
state = talloc_zero ( xconn ,
struct downgrade_lease_additional_state ) ;
if ( state = = NULL ) {
TALLOC_FREE ( lck ) ;
return NT_STATUS_NO_MEMORY ;
}
state - > im = tevent_create_immediate ( state ) ;
if ( state - > im = = NULL ) {
TALLOC_FREE ( state ) ;
TALLOC_FREE ( lck ) ;
return NT_STATUS_NO_MEMORY ;
}
state - > xconn = xconn ;
if ( l - > current_state & ( ~ SMB2_LEASE_READ ) ) {
state - > break_flags = SMB2_NOTIFY_BREAK_LEASE_FLAG_ACK_REQUIRED ;
}
state - > lease_key = l - > lease_key ;
state - > break_from = l - > current_state ;
state - > break_to = l - > breaking_to_requested ;
if ( l - > lease_version > 1 ) {
state - > new_epoch = l - > epoch ;
}
if ( state - > break_flags = = 0 ) {
/*
* This is an async break without
* SMB2_NOTIFY_BREAK_LEASE_FLAG_ACK_REQUIRED
*
* we need to store NONE state in the
* database .
*/
l - > current_state = 0 ;
l - > breaking_to_requested = 0 ;
l - > breaking_to_required = 0 ;
l - > breaking = false ;
lck - > data - > modified = true ;
}
tevent_schedule_immediate ( state - > im , xconn - > ev_ctx ,
downgrade_lease_additional_trigger ,
state ) ;
}
{
struct downgrade_lease_fsps_state state = {
. id = id , . lck = lck , . key = key ,
} ;
files_forall ( sconn , downgrade_lease_fsps , & state ) ;
}
TALLOC_FREE ( lck ) ;
DEBUG ( 10 , ( " %s: Downgrading %s to %x => %s \n " , __func__ ,
file_id_string_tos ( & id ) , ( unsigned ) lease_state , nt_errstr ( status ) ) ) ;
/*
* Dynamic share case . Ensure other opens are copies .
* This will only be breaking to NONE .
*/
for ( i = 1 ; i < num_file_ids ; i + + ) {
lck = get_existing_share_mode_lock ( talloc_tos ( ) , ids [ i ] ) ;
if ( lck = = NULL ) {
return NT_STATUS_OBJECT_NAME_NOT_FOUND ;
}
{
struct downgrade_lease_fsps_state state = {
. id = ids [ i ] , . lck = lck , . key = key ,
} ;
files_forall ( sconn , downgrade_lease_fsps , & state ) ;
}
DEBUG ( 10 , ( " %s: Downgrading %s to %x => %s \n " , __func__ ,
file_id_string_tos ( & ids [ i ] ) , ( unsigned ) lease_state , nt_errstr ( status ) ) ) ;
TALLOC_FREE ( lck ) ;
}
return status ;
}
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
2013-08-19 16:28:24 +04:00
# define SMB1_BREAK_MESSAGE_LENGTH (smb_size + 8*2)
2001-10-21 01:59:34 +04:00
2013-08-19 16:28:24 +04:00
static void new_break_message_smb1 ( files_struct * fsp , int cmd ,
char result [ SMB1_BREAK_MESSAGE_LENGTH ] )
{
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 ) ;
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
2010-10-03 19:18:26 +04:00
static files_struct * initial_break_processing (
struct smbd_server_connection * sconn , 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 ;
2013-09-16 06:18:41 +04:00
DEBUG ( 3 , ( " initial_break_processing: called for %s/%u \n "
" Current oplocks_open (exclusive = %d, levelII = %d) \n " ,
file_id_string_tos ( & id ) , ( int ) file_id ,
sconn - > oplocks . exclusive_open ,
sconn - > oplocks . level_II_open ) ) ;
2001-10-21 01:59:34 +04:00
/*
* We need to search the file open table for the
* entry containing this dev and inode , and ensure
* we have an oplock on it .
*/
2010-10-03 19:18:26 +04:00
fsp = file_find_dif ( sconn , 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. */
2013-09-16 06:18:41 +04:00
DEBUG ( 3 , ( " initial_break_processing: cannot find open file "
" with file_id %s gen_id = %lu, allowing break to "
" succeed. \n " , file_id_string_tos ( & id ) , file_id ) ) ;
2001-10-21 01:59:34 +04:00
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 ) {
2013-09-16 06:18:41 +04:00
DEBUG ( 3 , ( " initial_break_processing: file %s (file_id = %s "
" gen_id = %lu) has no oplock. Allowing break to "
" succeed regardless. \n " , fsp_str_dbg ( fsp ) ,
file_id_string_tos ( & id ) , fsp - > fh - > gen_id ) ) ;
2001-10-21 01:59:34 +04:00
return NULL ;
}
return fsp ;
1999-12-13 16:27:58 +03:00
}
2013-02-18 12:56:41 +04:00
static void oplock_timeout_handler ( struct tevent_context * ctx ,
2013-02-18 13:18:29 +04:00
struct tevent_timer * te ,
2009-01-05 12:22:50 +03:00
struct timeval now ,
2005-09-30 21:13:37 +04:00
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
2013-09-04 16:20:00 +04:00
SMB_ASSERT ( fsp - > sent_oplock_break ! = NO_BREAK_SENT ) ;
2007-06-22 21:19:08 +04:00
/* Remove the timed event handler. */
TALLOC_FREE ( fsp - > oplock_timeout ) ;
2009-07-11 01:50:37 +04:00
DEBUG ( 0 , ( " Oplock break failed for file %s -- replying anyway \n " ,
fsp_str_dbg ( fsp ) ) ) ;
2005-09-30 21:13:37 +04:00
remove_oplock ( 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 )
{
2012-05-25 01:33:32 +04:00
struct smbd_server_connection * sconn = fsp - > conn - > sconn ;
struct kernel_oplocks * koplocks = sconn - > oplocks . kernel_ops ;
2018-01-03 20:52:33 +03:00
bool use_kernel = lp_kernel_oplocks ( SNUM ( fsp - > conn ) ) & &
( koplocks ! = NULL ) ;
2012-05-25 01:33:32 +04:00
2009-02-04 02:40:23 +03:00
/*
* If kernel oplocks already notifies smbds when an oplock break times
* out , just return .
*/
2018-01-03 20:52:33 +03:00
if ( use_kernel & &
2009-02-04 02:40:23 +03:00
( koplocks - > flags & KOPLOCKS_TIMEOUT_NOTIFICATION ) ) {
return ;
}
2006-01-28 02:30:30 +03:00
if ( fsp - > oplock_timeout ! = NULL ) {
DEBUG ( 0 , ( " Logic problem -- have an oplock event hanging "
" around \n " ) ) ;
}
fsp - > oplock_timeout =
2011-12-12 16:51:27 +04:00
tevent_add_timer ( fsp - > conn - > sconn - > ev_ctx , fsp ,
timeval_current_ofs ( OPLOCK_BREAK_TIMEOUT , 0 ) ,
oplock_timeout_handler , fsp ) ;
2006-01-28 02:30:30 +03:00
if ( fsp - > oplock_timeout = = NULL ) {
DEBUG ( 0 , ( " Could not add oplock timeout handler \n " ) ) ;
}
}
2010-04-24 11:29:41 +04:00
static void send_break_message_smb1 ( files_struct * fsp , int level )
2010-04-08 06:00:44 +04:00
{
2014-09-16 11:23:54 +04:00
struct smbXsrv_connection * xconn = NULL ;
2013-08-19 16:28:24 +04:00
char break_msg [ SMB1_BREAK_MESSAGE_LENGTH ] ;
2014-09-16 11:23:54 +04:00
/*
* For SMB1 we only have one connection
*/
xconn = fsp - > conn - > sconn - > client - > connections ;
2013-08-19 16:28:24 +04:00
new_break_message_smb1 ( fsp , level , break_msg ) ;
2010-04-08 06:00:44 +04:00
show_msg ( break_msg ) ;
2014-06-11 14:55:24 +04:00
if ( ! srv_send_smb ( xconn ,
2010-04-08 06:00:44 +04:00
break_msg , false , 0 ,
IS_CONN_ENCRYPTED ( fsp - > conn ) ,
NULL ) ) {
2010-04-10 06:26:34 +04:00
exit_server_cleanly ( " send_break_message_smb1: "
2010-04-08 06:00:44 +04:00
" srv_send_smb failed. " ) ;
}
}
2006-01-28 02:30:30 +03:00
/*******************************************************************
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 ;
2012-03-30 18:11:08 +04:00
bool use_kernel ;
2011-12-13 16:18:47 +04:00
struct smbd_server_connection * sconn =
2011-12-14 12:50:24 +04:00
talloc_get_type_abort ( private_data ,
2011-12-13 16:18:47 +04:00
struct smbd_server_connection ) ;
2012-06-02 15:39:33 +04:00
struct server_id self = messaging_server_id ( sconn - > msg_ctx ) ;
2012-05-25 01:33:32 +04:00
struct kernel_oplocks * koplocks = sconn - > oplocks . kernel_ops ;
2014-10-29 01:31:46 +03:00
uint16_t break_from ;
2013-09-27 03:15:31 +04:00
uint16_t break_to ;
2014-10-29 01:31:46 +03:00
bool break_needed = true ;
2015-04-28 14:30:58 +03:00
struct server_id_buf tmp ;
2001-10-21 01:59:34 +04:00
2011-12-13 16:18:47 +04:00
if ( data - > data = = NULL ) {
DEBUG ( 0 , ( " Got NULL buffer \n " ) ) ;
2010-10-03 19:22:09 +04:00
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 ) ) ;
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. */
2018-02-07 13:39:32 +03:00
message_to_share_mode_entry ( & msg . id , & msg , ( char * ) data - > data ) ;
2013-09-27 03:15:31 +04:00
break_to = msg . op_type ;
2006-01-13 01:17:54 +03:00
2013-09-27 03:15:31 +04:00
DEBUG ( 10 , ( " Got oplock break to %u message from pid %s: %s/%llu \n " ,
2015-04-28 14:30:58 +03:00
( unsigned ) break_to , server_id_str_buf ( src , & tmp ) ,
2011-12-02 18:03:05 +04:00
file_id_string_tos ( & msg . id ) ,
( unsigned long long ) msg . share_file_id ) ) ;
2001-10-21 01:59:34 +04:00
2010-10-03 19:22:09 +04:00
fsp = initial_break_processing ( sconn , 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 ) {
2010-01-19 18:51:33 +03:00
/* We hit a race here. Break messages are sent, and before we
2013-04-12 16:03:08 +04:00
* get to process this message , we have closed the file . */
2005-09-30 21:13:37 +04:00
DEBUG ( 3 , ( " Did not find fsp \n " ) ) ;
return ;
2001-10-21 01:59:34 +04:00
}
2014-10-29 01:31:46 +03:00
break_from = fsp_lease_type ( fsp ) ;
if ( fsp - > oplock_type ! = LEASE_OPLOCK ) {
if ( fsp - > sent_oplock_break ! = NO_BREAK_SENT ) {
/*
* Nothing to do anymore
*/
DEBUG ( 10 , ( " fsp->sent_oplock_break = %d \n " ,
fsp - > sent_oplock_break ) ) ;
return ;
}
}
if ( ! ( global_client_caps & CAP_LEVEL_II_OPLOCKS ) ) {
DEBUG ( 10 , ( " client_caps without level2 oplocks \n " ) ) ;
break_to & = ~ SMB2_LEASE_READ ;
}
2018-01-03 20:52:33 +03:00
use_kernel = lp_kernel_oplocks ( SNUM ( fsp - > conn ) ) & &
( koplocks ! = NULL ) ;
2014-10-29 01:31:46 +03:00
if ( use_kernel & & ! ( koplocks - > flags & KOPLOCKS_LEVEL2_SUPPORTED ) ) {
DEBUG ( 10 , ( " Kernel oplocks don't allow level2 \n " ) ) ;
break_to & = ~ SMB2_LEASE_READ ;
}
if ( ! lp_level2_oplocks ( SNUM ( fsp - > conn ) ) ) {
DEBUG ( 10 , ( " no level2 oplocks by config \n " ) ) ;
break_to & = ~ SMB2_LEASE_READ ;
}
if ( fsp - > oplock_type = = LEASE_OPLOCK ) {
struct share_mode_lock * lck ;
int idx ;
lck = get_existing_share_mode_lock (
talloc_tos ( ) , fsp - > file_id ) ;
if ( lck = = NULL ) {
/*
* We hit a race here . Break messages are sent , and
* before we get to process this message , we have closed
* the file .
*/
DEBUG ( 3 , ( " Did not find share_mode \n " ) ) ;
return ;
}
idx = find_share_mode_lease (
lck - > data ,
fsp_client_guid ( fsp ) ,
& fsp - > lease - > lease . lease_key ) ;
if ( idx ! = - 1 ) {
struct share_mode_lease * l ;
l = & lck - > data - > leases [ idx ] ;
break_from = l - > current_state ;
break_to & = l - > current_state ;
if ( l - > breaking ) {
break_to & = l - > breaking_to_required ;
if ( l - > breaking_to_required ! = break_to ) {
/*
* Note we don ' t increment the epoch
* here , which might be a bug in
* Windows too . . .
*/
l - > breaking_to_required = break_to ;
lck - > data - > modified = true ;
}
break_needed = false ;
} else if ( l - > current_state = = break_to ) {
break_needed = false ;
} else if ( l - > current_state = = SMB2_LEASE_READ ) {
l - > current_state = SMB2_LEASE_NONE ;
/* Need to increment the epoch */
l - > epoch + = 1 ;
lck - > data - > modified = true ;
} else {
l - > breaking = true ;
l - > breaking_to_required = break_to ;
l - > breaking_to_requested = break_to ;
/* Need to increment the epoch */
l - > epoch + = 1 ;
lck - > data - > modified = true ;
}
/* Ensure we're in sync with current lease state. */
fsp_lease_update ( lck , fsp_client_guid ( fsp ) , fsp - > lease ) ;
}
TALLOC_FREE ( lck ) ;
}
if ( ! break_needed ) {
DEBUG ( 10 , ( " %s: skip break \n " , __func__ ) ) ;
2005-09-30 21:13:37 +04:00
return ;
2001-10-21 01:59:34 +04:00
}
2014-10-29 01:31:46 +03:00
if ( ( break_from = = SMB2_LEASE_NONE ) & & ! break_needed ) {
DEBUG ( 3 , ( " Already downgraded oplock to none on %s: %s \n " ,
2007-09-10 14:56:07 +04:00
file_id_string_tos ( & fsp - > file_id ) ,
2009-07-11 01:50:37 +04:00
fsp_str_dbg ( fsp ) ) ) ;
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
2014-10-29 01:31:46 +03:00
DEBUG ( 10 , ( " break_from=%u, break_to=%u \n " ,
( unsigned ) break_from , ( unsigned ) break_to ) ) ;
2012-03-30 18:11:08 +04:00
2014-10-29 01:31:46 +03:00
if ( ( break_from = = break_to ) & & ! break_needed ) {
DEBUG ( 3 , ( " Already downgraded oplock to %u on %s: %s \n " ,
( unsigned ) break_to ,
file_id_string_tos ( & fsp - > file_id ) ,
fsp_str_dbg ( fsp ) ) ) ;
return ;
2005-09-30 21:13:37 +04:00
}
2001-10-21 01:59:34 +04:00
2010-04-08 06:00:44 +04:00
/* Need to wait before sending a break
message if we sent ourselves this message . */
2012-06-16 02:26:26 +04:00
if ( serverid_equal ( & self , & src ) ) {
2005-09-30 21:13:37 +04:00
wait_before_sending_break ( ) ;
}
2001-10-21 01:59:34 +04:00
2010-06-10 06:12:02 +04:00
if ( sconn - > using_smb2 ) {
2014-10-29 01:31:46 +03:00
send_break_message_smb2 ( fsp , break_from , break_to ) ;
2010-04-08 06:00:44 +04:00
} else {
2014-10-29 01:31:46 +03:00
send_break_message_smb1 ( fsp , ( break_to & SMB2_LEASE_READ ) ?
OPLOCKLEVEL_II : OPLOCKLEVEL_NONE ) ;
2003-07-17 01:06:21 +04:00
}
2003-07-17 04:58:14 +04:00
2014-10-29 01:31:46 +03:00
if ( ( break_from = = SMB2_LEASE_READ ) & &
( break_to = = SMB2_LEASE_NONE ) ) {
2013-10-22 15:33:42 +04:00
/*
* This is an async break without a reply and thus no timeout
2014-10-29 01:31:46 +03:00
*
* leases are handled above .
2013-10-22 15:33:42 +04:00
*/
2014-10-29 01:31:46 +03:00
if ( fsp - > oplock_type ! = LEASE_OPLOCK ) {
remove_oplock ( fsp ) ;
}
return ;
}
if ( fsp - > oplock_type = = LEASE_OPLOCK ) {
2013-10-22 15:33:42 +04:00
return ;
}
2014-10-29 01:31:46 +03:00
fsp - > sent_oplock_break = ( break_to & SMB2_LEASE_READ ) ?
LEVEL_II_BREAK_SENT : 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
}
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 ;
2011-12-13 16:18:47 +04:00
struct smbd_server_connection * sconn =
2011-12-14 12:50:24 +04:00
talloc_get_type_abort ( private_data ,
2011-12-13 16:18:47 +04:00
struct smbd_server_connection ) ;
2015-04-28 14:30:58 +03:00
struct server_id_buf tmp ;
2011-12-13 16:18:47 +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. */
2009-02-16 10:45:28 +03:00
pull_file_id_24 ( ( char * ) data - > data , & id ) ;
file_id = ( unsigned long ) IVAL ( data - > data , 24 ) ;
2001-10-21 01:59:34 +04:00
2009-04-03 12:42:43 +04:00
DEBUG ( 10 , ( " Got kernel oplock break message from pid %s: %s/%u \n " ,
2015-04-28 14:30:58 +03:00
server_id_str_buf ( src , & tmp ) , file_id_string_tos ( & id ) ,
2006-01-13 01:17:54 +03:00
( unsigned int ) file_id ) ) ;
2010-10-03 19:24:33 +04:00
fsp = initial_break_processing ( sconn , 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
}
2010-06-10 06:12:02 +04:00
if ( sconn - > using_smb2 ) {
2014-10-29 01:31:46 +03:00
send_break_message_smb2 ( fsp , 0 , OPLOCKLEVEL_NONE ) ;
2010-04-08 06:00:44 +04:00
} else {
2010-04-10 06:26:34 +04:00
send_break_message_smb1 ( fsp , OPLOCKLEVEL_NONE ) ;
2001-10-21 01:59: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
2012-01-13 16:26:41 +04:00
struct break_to_none_state {
struct smbd_server_connection * sconn ;
struct file_id id ;
2014-10-29 01:31:46 +03:00
struct smb2_lease_key lease_key ;
struct GUID client_guid ;
2012-01-13 16:26:41 +04:00
} ;
2013-08-16 15:40:38 +04:00
static void do_break_to_none ( struct tevent_context * ctx ,
struct tevent_immediate * im ,
void * private_data ) ;
2012-01-13 16:26:41 +04: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
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-02-03 22:56:35 +03:00
static void contend_level2_oplocks_begin_default ( files_struct * fsp ,
enum level2_contention_type type )
2000-11-16 03:59:18 +03:00
{
2012-01-13 16:26:41 +04:00
struct smbd_server_connection * sconn = fsp - > conn - > sconn ;
2013-08-16 15:40:38 +04:00
struct tevent_immediate * im ;
2012-01-13 16:26:41 +04:00
struct break_to_none_state * state ;
2013-09-11 20:07:33 +04:00
struct byte_range_lock * brl ;
2014-10-29 01:27:09 +03:00
uint32_t num_read_oplocks = 0 ;
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 .
*/
2017-04-20 22:37:37 +03:00
if ( fsp_lease_type_is_exclusive ( fsp ) ) {
2013-09-11 20:07:33 +04:00
/*
* There can ' t be any level2 oplocks , we ' re alone .
*/
return ;
}
brl = brl_get_locks_readonly ( fsp ) ;
2014-10-29 01:27:09 +03:00
if ( brl ! = NULL ) {
num_read_oplocks = brl_num_read_oplocks ( brl ) ;
}
DEBUG ( 10 , ( " num_read_oplocks = % " PRIu32 " \n " , num_read_oplocks ) ) ;
if ( num_read_oplocks = = 0 ) {
2013-09-11 20:07:33 +04:00
DEBUG ( 10 , ( " No read oplocks around \n " ) ) ;
2000-11-16 03:59:18 +03:00
return ;
2013-09-11 20:07:33 +04:00
}
2000-11-16 03:59:18 +03:00
2012-01-13 16:26:41 +04:00
/*
* When we get here we might have a brlock entry locked . Also
* locking the share mode entry would violate the locking
* order . Breaking level2 oplocks to none is asynchronous
2013-10-02 19:20:16 +04:00
* anyway , so we postpone this into an immediate event .
2012-01-13 16:26:41 +04:00
*/
2014-10-29 01:31:46 +03:00
state = talloc_zero ( sconn , struct break_to_none_state ) ;
2012-01-13 16:26:41 +04:00
if ( state = = NULL ) {
DEBUG ( 1 , ( " talloc failed \n " ) ) ;
return ;
}
state - > sconn = sconn ;
state - > id = fsp - > file_id ;
2014-10-29 01:31:46 +03:00
if ( fsp - > oplock_type = = LEASE_OPLOCK ) {
state - > client_guid = * fsp_client_guid ( fsp ) ;
state - > lease_key = fsp - > lease - > lease . lease_key ;
DEBUG ( 10 , ( " Breaking through lease key % " PRIu64 " /% " PRIu64 " \n " ,
state - > lease_key . data [ 0 ] ,
state - > lease_key . data [ 1 ] ) ) ;
}
2013-08-16 15:40:38 +04:00
im = tevent_create_immediate ( state ) ;
if ( im = = NULL ) {
DEBUG ( 1 , ( " tevent_create_immediate failed \n " ) ) ;
2012-01-13 16:26:41 +04:00
TALLOC_FREE ( state ) ;
2006-03-07 12:09:13 +03:00
return ;
2000-11-16 03:59:18 +03:00
}
2013-08-16 15:40:38 +04:00
tevent_schedule_immediate ( im , sconn - > ev_ctx , do_break_to_none , state ) ;
2012-01-13 16:26:41 +04:00
}
2014-10-29 01:31:46 +03:00
static void send_break_to_none ( struct messaging_context * msg_ctx ,
const struct share_mode_entry * e )
{
char msg [ MSG_SMB_SHARE_MODE_ENTRY_SIZE ] ;
2018-02-07 13:36:51 +03:00
share_mode_entry_to_message ( msg , & e - > id , e ) ;
2014-10-29 01:31:46 +03:00
/* Overload entry->op_type */
SSVAL ( msg , OP_BREAK_MSG_OP_TYPE_OFFSET , NO_OPLOCK ) ;
messaging_send_buf ( msg_ctx , e - > pid , MSG_SMB_BREAK_REQUEST ,
2015-05-03 07:01:14 +03:00
( uint8_t * ) msg , sizeof ( msg ) ) ;
2014-10-29 01:31:46 +03:00
}
2013-08-16 15:40:38 +04:00
static void do_break_to_none ( struct tevent_context * ctx ,
struct tevent_immediate * im ,
void * private_data )
2012-01-13 16:26:41 +04:00
{
2013-08-16 15:40:38 +04:00
struct break_to_none_state * state = talloc_get_type_abort (
private_data , struct break_to_none_state ) ;
2014-10-29 01:31:46 +03:00
uint32_t i ;
2012-01-13 16:26:41 +04:00
struct share_mode_lock * lck ;
2014-10-29 01:31:46 +03:00
struct share_mode_data * d ;
2012-01-13 16:26:41 +04:00
2012-02-19 17:23:56 +04:00
lck = get_existing_share_mode_lock ( talloc_tos ( ) , state - > id ) ;
2012-01-13 16:26:41 +04:00
if ( lck = = NULL ) {
2013-11-01 15:55:43 +04:00
DEBUG ( 1 , ( " %s: failed to lock share mode entry for file %s. \n " ,
__func__ , file_id_string_tos ( & state - > id ) ) ) ;
2012-01-13 16:26:41 +04:00
goto done ;
}
2014-10-29 01:31:46 +03:00
d = lck - > data ;
2000-11-16 03:59:18 +03:00
2014-10-29 01:31:46 +03:00
/*
* Walk leases and oplocks separately : We have to send one break per
* lease . If we have multiple share_mode_entry having a common lease ,
* we would break the lease twice if we don ' t walk the leases list
* separately .
*/
for ( i = 0 ; i < d - > num_leases ; i + + ) {
struct share_mode_lease * l = & d - > leases [ i ] ;
2016-06-16 04:00:20 +03:00
struct share_mode_entry * e = NULL ;
2014-10-29 01:31:46 +03:00
uint32_t j ;
if ( ( l - > current_state & SMB2_LEASE_READ ) = = 0 ) {
continue ;
}
if ( smb2_lease_equal ( & state - > client_guid ,
& state - > lease_key ,
& l - > client_guid ,
& l - > lease_key ) ) {
DEBUG ( 10 , ( " Don't break our own lease \n " ) ) ;
continue ;
}
for ( j = 0 ; j < d - > num_share_modes ; j + + ) {
e = & d - > share_modes [ j ] ;
if ( ! is_valid_share_mode_entry ( e ) ) {
continue ;
}
if ( e - > lease_idx = = i ) {
break ;
}
}
if ( j = = d - > num_share_modes ) {
DEBUG ( 0 , ( " leases[% " PRIu32 " ] has no share mode \n " ,
i ) ) ;
continue ;
}
DEBUG ( 10 , ( " Breaking lease# % " PRIu32 " with share_entry# "
" % " PRIu32 " \n " , i , j ) ) ;
send_break_to_none ( state - > sconn - > msg_ctx , e ) ;
}
2005-09-30 21:13:37 +04:00
2014-10-29 01:31:46 +03:00
for ( i = 0 ; i < d - > num_share_modes ; i + + ) {
struct share_mode_entry * e = & d - > share_modes [ i ] ;
2000-11-16 03:59:18 +03:00
2014-10-29 01:31:46 +03:00
if ( ! is_valid_share_mode_entry ( e ) ) {
2006-01-27 22:54:39 +03:00
continue ;
}
2014-10-29 01:31:46 +03:00
if ( e - > op_type = = LEASE_OPLOCK ) {
/*
* Took care of those in the loop above
*/
continue ;
}
2006-01-27 22:54:39 +03:00
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
2013-09-13 17:18:15 +04:00
* entries may be partly NO_OPLOCK and partly 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
*/
2014-10-29 01:31:46 +03:00
DEBUG ( 10 , ( " %s: share_entry[%i]->op_type == %d \n " , __func__ ,
i , e - > op_type ) ) ;
2001-08-22 04:29:40 +04:00
2014-10-29 01:31:46 +03:00
if ( e - > 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 .... */
2014-10-29 01:31:46 +03:00
if ( EXCLUSIVE_OPLOCK_TYPE ( e - > op_type ) ) {
2013-11-01 15:55:43 +04:00
DEBUG ( 0 , ( " %s: PANIC. "
2015-07-08 05:34:25 +03:00
" share mode entry %d is an exclusive "
2013-11-01 15:55:43 +04:00
" oplock ! \n " , __func__ , i ) ) ;
2006-02-20 20:59:58 +03:00
TALLOC_FREE ( lck ) ;
2000-11-16 03:59:18 +03:00
abort ( ) ;
}
2014-10-29 01:31:46 +03:00
send_break_to_none ( state - > sconn - > msg_ctx , e ) ;
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 ) ;
2012-01-13 16:26:41 +04:00
done :
TALLOC_FREE ( state ) ;
return ;
2004-06-08 20:14:31 +04:00
}
2011-05-31 07:18:37 +04:00
void smbd_contend_level2_oplocks_begin ( files_struct * fsp ,
2009-02-03 22:56:35 +03:00
enum level2_contention_type type )
{
2012-05-25 01:33:32 +04:00
struct smbd_server_connection * sconn = fsp - > conn - > sconn ;
struct kernel_oplocks * koplocks = sconn - > oplocks . kernel_ops ;
2018-01-03 20:52:33 +03:00
bool use_kernel = lp_kernel_oplocks ( SNUM ( fsp - > conn ) ) & &
( koplocks ! = NULL ) ;
2012-05-25 01:33:32 +04:00
2018-01-03 20:52:33 +03:00
if ( use_kernel & & koplocks - > ops - > contend_level2_oplocks_begin ) {
2009-02-03 22:56:35 +03:00
koplocks - > ops - > contend_level2_oplocks_begin ( fsp , type ) ;
return ;
}
contend_level2_oplocks_begin_default ( fsp , type ) ;
}
2011-05-31 07:18:37 +04:00
void smbd_contend_level2_oplocks_end ( files_struct * fsp ,
2009-02-03 22:56:35 +03:00
enum level2_contention_type type )
{
2012-05-25 01:33:32 +04:00
struct smbd_server_connection * sconn = fsp - > conn - > sconn ;
struct kernel_oplocks * koplocks = sconn - > oplocks . kernel_ops ;
2018-01-03 20:52:33 +03:00
bool use_kernel = lp_kernel_oplocks ( SNUM ( fsp - > conn ) ) & &
( koplocks ! = NULL ) ;
2012-05-25 01:33:32 +04:00
2009-02-03 22:56:35 +03:00
/* Only kernel oplocks implement this so far */
2018-01-03 20:52:33 +03:00
if ( use_kernel & & koplocks - > ops - > contend_level2_oplocks_end ) {
2009-02-03 22:56:35 +03:00
koplocks - > ops - > contend_level2_oplocks_end ( fsp , type ) ;
}
}
2006-01-13 01:17:54 +03:00
/****************************************************************************
Linearize a share mode entry struct to an internal oplock break message .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2018-02-07 13:36:51 +03:00
void share_mode_entry_to_message ( char * msg , const struct file_id * id ,
const struct share_mode_entry * e )
2006-01-13 01:17:54 +03:00
{
2015-05-03 07:01:14 +03:00
SIVAL ( msg , OP_BREAK_MSG_PID_OFFSET , ( uint32_t ) e - > pid . pid ) ;
2010-04-13 08:40:28 +04:00
SBVAL ( msg , OP_BREAK_MSG_MID_OFFSET , e - > op_mid ) ;
SSVAL ( msg , OP_BREAK_MSG_OP_TYPE_OFFSET , e - > op_type ) ;
SIVAL ( msg , OP_BREAK_MSG_ACCESS_MASK_OFFSET , e - > access_mask ) ;
SIVAL ( msg , OP_BREAK_MSG_SHARE_ACCESS_OFFSET , e - > share_access ) ;
SIVAL ( msg , OP_BREAK_MSG_PRIV_OFFSET , e - > private_options ) ;
SIVAL ( msg , OP_BREAK_MSG_TIME_SEC_OFFSET , ( uint32_t ) e - > time . tv_sec ) ;
SIVAL ( msg , OP_BREAK_MSG_TIME_USEC_OFFSET , ( uint32_t ) e - > time . tv_usec ) ;
2018-02-07 13:36:51 +03:00
/*
* " id " used to be part of share_mode_entry , thus the strange
* place to put this . Feel free to move somewhere else : - )
*/
push_file_id_24 ( msg + OP_BREAK_MSG_DEV_OFFSET , id ) ;
2010-04-13 08:40:28 +04:00
SIVAL ( msg , OP_BREAK_MSG_FILE_ID_OFFSET , e - > share_file_id ) ;
SIVAL ( msg , OP_BREAK_MSG_UID_OFFSET , e - > uid ) ;
SSVAL ( msg , OP_BREAK_MSG_FLAGS_OFFSET , e - > flags ) ;
2011-01-26 01:01:52 +03:00
SIVAL ( msg , OP_BREAK_MSG_NAME_HASH_OFFSET , e - > name_hash ) ;
2010-04-13 08:40:28 +04:00
SIVAL ( msg , OP_BREAK_MSG_VNN_OFFSET , e - > pid . vnn ) ;
2006-01-13 01:17:54 +03:00
}
/****************************************************************************
De - linearize an internal oplock break message to a share mode entry struct .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2018-02-07 13:39:32 +03:00
void message_to_share_mode_entry ( struct file_id * id ,
struct share_mode_entry * e ,
const char * msg )
2006-01-13 01:17:54 +03:00
{
2010-04-13 08:40:28 +04:00
e - > pid . pid = ( pid_t ) IVAL ( msg , OP_BREAK_MSG_PID_OFFSET ) ;
e - > op_mid = BVAL ( msg , OP_BREAK_MSG_MID_OFFSET ) ;
e - > op_type = SVAL ( msg , OP_BREAK_MSG_OP_TYPE_OFFSET ) ;
e - > access_mask = IVAL ( msg , OP_BREAK_MSG_ACCESS_MASK_OFFSET ) ;
e - > share_access = IVAL ( msg , OP_BREAK_MSG_SHARE_ACCESS_OFFSET ) ;
e - > private_options = IVAL ( msg , OP_BREAK_MSG_PRIV_OFFSET ) ;
e - > time . tv_sec = ( time_t ) IVAL ( msg , OP_BREAK_MSG_TIME_SEC_OFFSET ) ;
e - > time . tv_usec = ( int ) IVAL ( msg , OP_BREAK_MSG_TIME_USEC_OFFSET ) ;
2018-02-07 13:39:32 +03:00
/*
* " id " used to be part of share_mode_entry , thus the strange
* place to put this . Feel free to move somewhere else : - )
*/
pull_file_id_24 ( msg + OP_BREAK_MSG_DEV_OFFSET , id ) ;
2010-04-13 08:40:28 +04:00
e - > share_file_id = ( unsigned long ) IVAL ( msg , OP_BREAK_MSG_FILE_ID_OFFSET ) ;
2015-05-03 07:01:14 +03:00
e - > uid = ( uint32_t ) IVAL ( msg , OP_BREAK_MSG_UID_OFFSET ) ;
e - > flags = ( uint16_t ) SVAL ( msg , OP_BREAK_MSG_FLAGS_OFFSET ) ;
2011-01-26 01:01:52 +03:00
e - > name_hash = IVAL ( msg , OP_BREAK_MSG_NAME_HASH_OFFSET ) ;
2010-04-13 08:40:28 +04:00
e - > pid . vnn = IVAL ( msg , OP_BREAK_MSG_VNN_OFFSET ) ;
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
2011-12-13 16:13:53 +04:00
bool init_oplocks ( struct smbd_server_connection * sconn )
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
2011-12-13 16:18:47 +04:00
messaging_register ( sconn - > msg_ctx , sconn , MSG_SMB_BREAK_REQUEST ,
2007-05-15 00:31:28 +04:00
process_oplock_break_message ) ;
2011-12-13 16:18:47 +04:00
messaging_register ( sconn - > msg_ctx , sconn , MSG_SMB_KERNEL_BREAK ,
2007-05-15 00:31:28 +04:00
process_kernel_oplock_break ) ;
2012-03-30 17:51:25 +04:00
return true ;
}
void init_kernel_oplocks ( struct smbd_server_connection * sconn )
{
2012-05-25 01:33:32 +04:00
struct kernel_oplocks * koplocks = sconn - > oplocks . kernel_ops ;
2012-03-30 17:51:25 +04:00
/* only initialize once */
if ( koplocks = = NULL ) {
2000-06-10 17:38:07 +04:00
# if HAVE_KERNEL_OPLOCKS_IRIX
2011-12-13 16:38:41 +04:00
koplocks = irix_init_kernel_oplocks ( sconn ) ;
2000-06-11 09:57:58 +04:00
# elif HAVE_KERNEL_OPLOCKS_LINUX
2011-12-13 16:38:41 +04:00
koplocks = linux_init_kernel_oplocks ( sconn ) ;
2000-06-10 17:38:07 +04:00
# endif
2012-05-25 01:33:32 +04:00
sconn - > oplocks . kernel_ops = koplocks ;
2000-06-10 17:38:07 +04:00
}
1998-09-18 21:50:18 +04:00
}